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) 2019 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 #if defined (ANDROID) || defined(WIN32) || defined(__APPLE__)
  35 namespace std
  36 {
  37
  38 uint64_t _Hash_bytes(const void* bytes, uint64_t size, uint64_t seed);
  39
  40 }
  41 #endif
  42
  43 namespace Dali
  44 {
  45
  46 namespace Internal
  47 {
  48
  49 /**
  50  * An abstract interface for receiving property values, and for querying whether
  51  * a property value has changed i.e. whether a constraint needs to be reapplied.
  52  */
  53 class PropertyInputImpl
  54 {
  55 public:
  56
  57   /**
  58    * Virtual destructor.
  59    */
  60   virtual ~PropertyInputImpl()
  61   {
  62   }
  63
  64   /**
  65    * Query the type of property input.
  66    * @return The property type.
  67    */
  68   virtual Property::Type GetType() const = 0;
  69
  70   /**
  71    * Query the input value (for a constraint) has been initialized.
  72    * @return True if initialized, otherwise the constraint should be skipped.
  73    */
  74   virtual bool InputInitialized() const = 0;
  75
  76   /**
  77    * Query the input value (for a constraint) has changed.
  78    * @return True if the input value has changed.
  79    */
  80   virtual bool InputChanged() const = 0;
  81
  82   /**
  83    * Retrieve a boolean value.
  84    * @pre GetType() returns Property::BOOLEAN.
  85    * @param[in] bufferIndex The buffer to read from.
  86    * @return The boolean value.
  87    */
  88   virtual const bool& GetBoolean( BufferIndex bufferIndex ) const
  89   {
  90     // the return will never be executed, it's just to keep the compiler happy
  91     return reinterpret_cast<const bool&>(*this);
  92   }
  93
  94   /**
  95    * Retrieve an integer value.
  96    * @pre GetType() returns Property::INTEGER.
  97    * @param[in] bufferIndex The buffer to read from.
  98    * @return The integer value.
  99    */
 100   virtual const int& GetInteger( BufferIndex bufferIndex ) const
 101   {
 102     // the return will never be executed, it's just to keep the compiler happy
 103     return reinterpret_cast<const int&>(*this);
 104   }
 105
 106   /**
 107    * Retrieve a float value.
 108    * @pre GetType() returns Property::FLOAT.
 109    * @param[in] bufferIndex The buffer to read from.
 110    * @return The float value.
 111    */
 112   virtual const float& GetFloat( BufferIndex bufferIndex ) const
 113   {
 114     // the return will never be executed, it's just to keep the compiler happy
 115     return reinterpret_cast<const float&>(*this);
 116   }
 117
 118   /**
 119    * Retrieve a Vector2 value.
 120    * @pre GetType() returns Property::VECTOR2.
 121    * @param[in] bufferIndex The buffer to read from.
 122    * @return The Vector2 value.
 123    */
 124   virtual const Vector2& GetVector2( BufferIndex bufferIndex ) const
 125   {
 126     // the return will never be executed, it's just to keep the compiler happy
 127     return reinterpret_cast<const Vector2&>(*this);
 128   }
 129
 130   /**
 131    * Retrieve a Vector3 value.
 132    * @pre GetType() returns Property::VECTOR3.
 133    * @param[in] bufferIndex The buffer to read from.
 134    * @return The Vector3 value.
 135    */
 136   virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
 137   {
 138     // the return will never be executed, it's just to keep the compiler happy
 139     return reinterpret_cast<const Vector3&>(*this);
 140   }
 141
 142   /**
 143    * Retrieve a Vector4 value.
 144    * @pre GetType() returns Property::VECTOR4.
 145    * @param[in] bufferIndex The buffer to read from.
 146    * @return The Vector4 value.
 147    */
 148   virtual const Vector4& GetVector4( BufferIndex bufferIndex ) const
 149   {
 150     // the return will never be executed, it's just to keep the compiler happy
 151     return reinterpret_cast<const Vector4&>(*this);
 152   }
 153
 154   /**
 155    * Retrieve a Quaternion value.
 156    * @pre GetType() returns Property::Quaternion.
 157    * @param[in] bufferIndex The buffer to read from.
 158    * @return The Quaternion value.
 159    */
 160   virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
 161   {
 162     // the return will never be executed, it's just to keep the compiler happy
 163     return reinterpret_cast<const Quaternion&>(*this);
 164   }
 165
 166   /**
 167    * Retrieve a Matrix value.
 168    * @pre GetType() returns Property::Matrix.
 169    * @param[in] bufferIndex The buffer to read from.
 170    * @return The Matrix value.
 171    */
 172   virtual const Matrix3& GetMatrix3( BufferIndex bufferIndex ) const
 173   {
 174     // the return will never be executed, it's just to keep the compiler happy
 175     return reinterpret_cast<const Matrix3&>(*this);
 176   }
 177
 178   /**
 179    * Retrieve a Matrix value.
 180    * @pre GetType() returns Property::Matrix.
 181    * @param[in] bufferIndex The buffer to read from.
 182    * @return The Matrix value.
 183    */
 184   virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
 185   {
 186     // the return will never be executed, it's just to 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    * Query whether the property belongs to the
 311    * transform manager or not.
 312    * @return True if it is a transform manager property, false otherwise
 313    */
 314   virtual bool IsTransformManagerProperty() const
 315   {
 316     return false;
 317   }
 318
 319   std::uint64_t Hash(BufferIndex bufferIndex, uint64_t seed) const
 320   {
 321     switch ( GetType() )
 322     {
 323       case Property::BOOLEAN:
 324       {
 325         return std::_Hash_bytes(&GetBoolean(bufferIndex), sizeof(bool), seed);
 326       }
 327
 328       case Property::INTEGER:
 329       {
 330         return std::_Hash_bytes(&GetInteger(bufferIndex), sizeof(int), seed);
 331       }
 332
 333       case Property::FLOAT:
 334       {
 335         return std::_Hash_bytes(&GetFloat(bufferIndex), sizeof(float), seed);
 336       }
 337
 338       case Property::VECTOR2:
 339       {
 340         return std::_Hash_bytes(&GetVector2(bufferIndex), sizeof(Vector2), seed);
 341       }
 342
 343       case Property::VECTOR3:
 344       {
 345         return std::_Hash_bytes(&GetVector3(bufferIndex), sizeof(Vector3), seed);
 346       }
 347
 348       case Property::VECTOR4:
 349       {
 350         return std::_Hash_bytes(&GetVector4(bufferIndex), sizeof(Vector4), seed);
 351       }
 352
 353       case Property::ROTATION:
 354       {
 355         return std::_Hash_bytes(&GetQuaternion(bufferIndex), sizeof(Quaternion), seed);
 356       }
 357
 358       case Property::MATRIX:
 359       {
 360         return std::_Hash_bytes(&GetMatrix(bufferIndex), sizeof(Matrix), seed);
 361       }
 362
 363       case Property::MATRIX3:
 364       {
 365         return std::_Hash_bytes(&GetMatrix3(bufferIndex), sizeof(Matrix3), seed);
 366       }
 367
 368       default:
 369         break; // print nothing
 370     }
 371
 372     return seed;
 373   }
 374
 375
 376   /**
 377    * Print the property value using a stream.
 378    * @param[in] debugStream The output stream.
 379    * @param[in] bufferIndex The buffer to read from.
 380    * @todo Place this far-too-large-to-be-inlined function in a cpp and remove <iostream> header dependency from this file.
 381    */
 382   void DebugPrint( std::ostream& debugStream, BufferIndex bufferIndex ) const
 383   {
 384     switch ( GetType() )
 385     {
 386       case Property::BOOLEAN:
 387       {
 388         debugStream << GetBoolean( bufferIndex );
 389         break;
 390       }
 391
 392       case Property::INTEGER:
 393       {
 394         debugStream << GetInteger( bufferIndex );
 395         break;
 396       }
 397
 398       case Property::FLOAT:
 399       {
 400         debugStream << GetFloat( bufferIndex );
 401         break;
 402       }
 403
 404       case Property::VECTOR2:
 405       {
 406         debugStream << GetVector2( bufferIndex );
 407         break;
 408       }
 409
 410       case Property::VECTOR3:
 411       {
 412         debugStream << GetVector3( bufferIndex );
 413         break;
 414       }
 415
 416       case Property::VECTOR4:
 417       {
 418         debugStream << GetVector4( bufferIndex );
 419         break;
 420       }
 421
 422       case Property::ROTATION:
 423       {
 424         debugStream << GetQuaternion( bufferIndex );
 425         break;
 426       }
 427
 428       case Property::MATRIX:
 429       {
 430         debugStream << GetMatrix( bufferIndex );
 431         break;
 432       }
 433
 434       case Property::MATRIX3:
 435       {
 436         debugStream << GetMatrix3( bufferIndex );
 437         break;
 438       }
 439
 440       default:
 441         break; // print nothing
 442     }
 443   }
 444 };
 445
 446 } // namespace Internal
 447
 448 } // namespace Dali
 449
 450 #endif // DALI_INTERNAL_PROPERTY_INPUT_IMPL_H