dali/internal/event/common/property-input-impl.h

   1 #ifndef __DALI_INTERNAL_PROPERTY_INPUT_IMPL_H__
   2 #define __DALI_INTERNAL_PROPERTY_INPUT_IMPL_H__
   3
   4 /*
   5  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <iostream>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/public-api/object/property-input.h>
  26 #include <dali/public-api/math/vector2.h>
  27 #include <dali/public-api/math/vector3.h>
  28 #include <dali/public-api/math/vector4.h>
  29 #include <dali/public-api/math/quaternion.h>
  30 #include <dali/public-api/math/matrix3.h>
  31 #include <dali/public-api/math/matrix.h>
  32 #include <dali/internal/common/buffer-index.h>
  33
  34 namespace Dali
  35 {
  36
  37 namespace Internal
  38 {
  39
  40 /**
  41  * An abstract interface for receiving property values, and for querying whether
  42  * a property value has changed i.e. whether a constraint needs to be reapplied.
  43  */
  44 class PropertyInputImpl
  45 {
  46 public:
  47
  48   /**
  49    * Virtual destructor.
  50    */
  51   virtual ~PropertyInputImpl()
  52   {
  53   }
  54
  55   /**
  56    * Query the type of property input.
  57    * @return The property type.
  58    */
  59   virtual Property::Type GetType() const = 0;
  60
  61   /**
  62    * Query the input value (for a constraint) has been initialized.
  63    * @return True if initialized, otherwise the constraint should be skipped.
  64    */
  65   virtual bool InputInitialized() const = 0;
  66
  67   /**
  68    * Query the input value (for a constraint) has changed.
  69    * @return True if the input value has changed.
  70    */
  71   virtual bool InputChanged() const = 0;
  72
  73   /**
  74    * Retrieve a boolean value.
  75    * @pre GetType() returns Property::BOOLEAN.
  76    * @param[in] bufferIndex The buffer to read from.
  77    * @return The boolean value.
  78    */
  79   virtual const bool& GetBoolean( BufferIndex bufferIndex ) const
  80   {
  81     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
  82     // the return will never be executed due to assert above so just keep the compiler happy
  83     return reinterpret_cast<const bool&>(*this);
  84   }
  85
  86   /**
  87    * Retrieve an integer value.
  88    * @pre GetType() returns Property::INTEGER.
  89    * @param[in] bufferIndex The buffer to read from.
  90    * @return The integer value.
  91    */
  92   virtual const int& GetInteger( BufferIndex bufferIndex ) const
  93   {
  94     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
  95     // the return will never be executed due to assert above so just keep the compiler happy
  96     return reinterpret_cast<const int&>(*this);
  97   }
  98
  99   /**
 100    * Retrieve a float value.
 101    * @pre GetType() returns Property::FLOAT.
 102    * @param[in] bufferIndex The buffer to read from.
 103    * @return The float value.
 104    */
 105   virtual const float& GetFloat( BufferIndex bufferIndex ) const
 106   {
 107     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
 108     // the return will never be executed due to assert above so just keep the compiler happy
 109     return reinterpret_cast<const float&>(*this);
 110   }
 111
 112   /**
 113    * Retrieve a Vector2 value.
 114    * @pre GetType() returns Property::VECTOR2.
 115    * @param[in] bufferIndex The buffer to read from.
 116    * @return The Vector2 value.
 117    */
 118   virtual const Vector2& GetVector2( BufferIndex bufferIndex ) const
 119   {
 120     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
 121     // the return will never be executed due to assert above so just keep the compiler happy
 122     return reinterpret_cast<const Vector2&>(*this);
 123   }
 124
 125   /**
 126    * Retrieve a Vector3 value.
 127    * @pre GetType() returns Property::VECTOR3.
 128    * @param[in] bufferIndex The buffer to read from.
 129    * @return The Vector3 value.
 130    */
 131   virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
 132   {
 133     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
 134     // the return will never be executed due to assert above so just keep the compiler happy
 135     return reinterpret_cast<const Vector3&>(*this);
 136   }
 137
 138   /**
 139    * Retrieve a Vector4 value.
 140    * @pre GetType() returns Property::VECTOR4.
 141    * @param[in] bufferIndex The buffer to read from.
 142    * @return The Vector4 value.
 143    */
 144   virtual const Vector4& GetVector4( BufferIndex bufferIndex ) const
 145   {
 146     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
 147     // the return will never be executed due to assert above so just keep the compiler happy
 148     return reinterpret_cast<const Vector4&>(*this);
 149   }
 150
 151   /**
 152    * Retrieve a Quaternion value.
 153    * @pre GetType() returns Property::Quaternion.
 154    * @param[in] bufferIndex The buffer to read from.
 155    * @return The Quaternion value.
 156    */
 157   virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
 158   {
 159     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
 160     // the return will never be executed due to assert above so just keep the compiler happy
 161     return reinterpret_cast<const Quaternion&>(*this);
 162   }
 163
 164   /**
 165    * Retrieve a Matrix value.
 166    * @pre GetType() returns Property::Matrix.
 167    * @param[in] bufferIndex The buffer to read from.
 168    * @return The Matrix value.
 169    */
 170   virtual const Matrix3& GetMatrix3( BufferIndex bufferIndex ) const
 171   {
 172     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
 173     // the return will never be executed due to assert above so just keep the compiler happy
 174     return reinterpret_cast<const Matrix3&>(*this);
 175   }
 176
 177   /**
 178    * Retrieve a Matrix value.
 179    * @pre GetType() returns Property::Matrix.
 180    * @param[in] bufferIndex The buffer to read from.
 181    * @return The Matrix value.
 182    */
 183   virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
 184   {
 185     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
 186     // the return will never be executed due to assert above so just keep the compiler happy
 187     return reinterpret_cast<const Matrix&>(*this);
 188   }
 189
 190   // Accessors for Constraint functions
 191
 192   /**
 193    * Retrieve a boolean input for a constraint function.
 194    * @note For inherited properties, this method should be overriden to return the value
 195    * from the previous frame i.e. not from the current update buffer.
 196    * @pre GetType() returns Property::BOOLEAN.
 197    * @param[in] updateBufferIndex The current update buffer index.
 198    * @return The boolean value.
 199    */
 200   virtual const bool& GetConstraintInputBoolean( BufferIndex updateBufferIndex ) const
 201   {
 202     return GetBoolean( updateBufferIndex );
 203   }
 204
 205   /**
 206    * Retrieve an integer input for a constraint function.
 207    * @note For inherited properties, this method should be overriden to return the value
 208    * from the previous frame i.e. not from the current update buffer.
 209    * @pre GetType() returns Property::INTEGER.
 210    * @param[in] updateBufferIndex The current update buffer index.
 211    * @return The integer value.
 212    */
 213   virtual const int& GetConstraintInputInteger( BufferIndex updateBufferIndex ) const
 214   {
 215     return GetInteger( updateBufferIndex );
 216   }
 217
 218   /**
 219    * Retrieve a float input for a constraint function.
 220    * @note For inherited properties, this method should be overriden to return the value
 221    * from the previous frame i.e. not from the current update buffer.
 222    * @pre GetType() returns Property::FLOAT.
 223    * @param[in] updateBufferIndex The current update buffer index.
 224    * @return The float value.
 225    */
 226   virtual const float& GetConstraintInputFloat( BufferIndex updateBufferIndex ) const
 227   {
 228     return GetFloat( updateBufferIndex );
 229   }
 230
 231   /**
 232    * Retrieve a Vector2 input for a constraint function.
 233    * @note For inherited properties, this method should be overriden to return the value
 234    * from the previous frame i.e. not from the current update buffer.
 235    * @pre GetType() returns Property::VECTOR2.
 236    * @param[in] updateBufferIndex The buffer to read from.
 237    * @return The Vector2 value.
 238    */
 239   virtual const Vector2& GetConstraintInputVector2( BufferIndex updateBufferIndex ) const
 240   {
 241     return GetVector2( updateBufferIndex );
 242   }
 243
 244   /**
 245    * Retrieve a Vector3 input for a constraint function.
 246    * @note For inherited properties, this method should be overriden to return the value
 247    * from the previous frame i.e. not from the current update buffer.
 248    * @pre GetType() returns Property::VECTOR3.
 249    * @param[in] updateBufferIndex The buffer to read from.
 250    * @return The Vector3 value.
 251    */
 252   virtual const Vector3& GetConstraintInputVector3( BufferIndex updateBufferIndex ) const
 253   {
 254     return GetVector3( updateBufferIndex );
 255   }
 256
 257   /**
 258    * Retrieve a Vector4 input for a constraint function.
 259    * @note For inherited properties, this method should be overriden to return the value
 260    * from the previous frame i.e. not from the current update buffer.
 261    * @pre GetType() returns Property::VECTOR4.
 262    * @param[in] updateBufferIndex The buffer to read from.
 263    * @return The Vector4 value.
 264    */
 265   virtual const Vector4& GetConstraintInputVector4( BufferIndex updateBufferIndex ) const
 266   {
 267     return GetVector4( updateBufferIndex );
 268   }
 269
 270   /**
 271    * Retrieve a Quaternion input for a constraint function.
 272    * @note For inherited properties, this method should be overriden to return the value
 273    * from the previous frame i.e. not from the current update buffer.
 274    * @pre GetType() returns Property::Quaternion.
 275    * @param[in] updateBufferIndex The buffer to read from.
 276    * @return The Quaternion value.
 277    */
 278   virtual const Quaternion& GetConstraintInputQuaternion( BufferIndex updateBufferIndex ) const
 279   {
 280     return GetQuaternion( updateBufferIndex );
 281   }
 282
 283   /**
 284    * Retrieve a Matrix3 input for a constraint function.
 285    * @note For inherited properties, this method should be overriden to return the value
 286    * from the previous frame i.e. not from the current update buffer.
 287    * @pre GetType() returns Property::Matrix.
 288    * @param[in] updateBufferIndex The buffer to read from.
 289    * @return The Matrix value.
 290    */
 291   virtual const Matrix3& GetConstraintInputMatrix3( BufferIndex updateBufferIndex ) const
 292   {
 293     return GetMatrix3( updateBufferIndex );
 294   }
 295
 296   /**
 297    * Retrieve a Matrix input for a constraint function.
 298    * @note For inherited properties, this method should be overriden to return the value
 299    * from the previous frame i.e. not from the current update buffer.
 300    * @pre GetType() returns Property::Matrix.
 301    * @param[in] updateBufferIndex The buffer to read from.
 302    * @return The Matrix value.
 303    */
 304   virtual const Matrix& GetConstraintInputMatrix( BufferIndex updateBufferIndex ) const
 305   {
 306     return GetMatrix( updateBufferIndex );
 307   }
 308
 309   /**
 310    * Print the property value using a stream.
 311    * @param[in] debugStream The output stream.
 312    * @param[in] bufferIndex The buffer to read from.
 313    * @todo Place this far-too-large-to-be-inlined function in a cpp and remove <iostream> header dependency from this file.
 314    */
 315   void DebugPrint( std::ostream& debugStream, BufferIndex bufferIndex ) const
 316   {
 317     switch ( GetType() )
 318     {
 319       case Property::BOOLEAN:
 320       {
 321         debugStream << GetBoolean( bufferIndex );
 322         break;
 323       }
 324
 325       case Property::INTEGER:
 326       {
 327         debugStream << GetInteger( bufferIndex );
 328         break;
 329       }
 330
 331       case Property::FLOAT:
 332       {
 333         debugStream << GetFloat( bufferIndex );
 334         break;
 335       }
 336
 337       case Property::VECTOR2:
 338       {
 339         debugStream << GetVector2( bufferIndex );
 340         break;
 341       }
 342
 343       case Property::VECTOR3:
 344       {
 345         debugStream << GetVector3( bufferIndex );
 346         break;
 347       }
 348
 349       case Property::VECTOR4:
 350       {
 351         debugStream << GetVector4( bufferIndex );
 352         break;
 353       }
 354
 355       case Property::ROTATION:
 356       {
 357         debugStream << GetQuaternion( bufferIndex );
 358         break;
 359       }
 360
 361       case Property::MATRIX:
 362       {
 363         debugStream << GetMatrix( bufferIndex );
 364         break;
 365       }
 366
 367       case Property::MATRIX3:
 368       {
 369         debugStream << GetMatrix3( bufferIndex );
 370         break;
 371       }
 372
 373       default:
 374         break; // print nothing
 375     }
 376   }
 377 };
 378
 379 } // namespace Internal
 380
 381 } // namespace Dali
 382
 383 #endif // __DALI_INTERNAL_PROPERTY_INPUT_IMPL_H__