dali/internal/update/common/inherited-property.h

   1 #ifndef __DALI_INTERNAL_SCENE_GRAPH_INHERITED_PROPERTY_H__
   2 #define __DALI_INTERNAL_SCENE_GRAPH_INHERITED_PROPERTY_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 // INTERNAL INCLUDES
  22 #include <dali/internal/event/common/property-input-impl.h>
  23 #include <dali/internal/update/common/double-buffered.h>
  24 #include <dali/internal/update/common/property-base.h>
  25 #include <dali/internal/update/common/scene-graph-buffers.h>
  26 #include <dali/public-api/common/dali-common.h>
  27 #include <dali/public-api/object/property.h>
  28 #include <dali/public-api/object/property-input.h>
  29 #include <dali/public-api/object/property-types.h>
  30
  31 namespace Dali
  32 {
  33
  34 namespace Internal
  35 {
  36
  37 namespace SceneGraph
  38 {
  39
  40 template <class T>
  41 class InheritedProperty;
  42
  43 /**
  44  * An inherited Vector3 property.
  45  */
  46 template <>
  47 class InheritedProperty<Vector3> : public PropertyInputImpl
  48 {
  49 public:
  50
  51   /**
  52    * Create an inherited property.
  53    * @param [in] initialValue The initial value of the property.
  54    */
  55   InheritedProperty( const Vector3& initialValue )
  56   : mValue( initialValue ),
  57     mInheritedFlag( false ),
  58     mReinheritedFlag( true )
  59   {
  60   }
  61
  62   /**
  63    * Virtual destructor.
  64    */
  65   virtual ~InheritedProperty()
  66   {
  67   }
  68
  69   /**
  70    * @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
  71    */
  72   virtual Dali::Property::Type GetType() const
  73   {
  74     return Dali::PropertyTypes::Get<Vector3>();
  75   }
  76
  77   /**
  78    * Called once per Update (only) if the property did not need to be re-inherited.
  79    * @param[in] updateBufferIndex The current update buffer index.
  80    */
  81   void CopyPrevious( BufferIndex updateBufferIndex )
  82   {
  83     if ( mReinheritedFlag )
  84     {
  85       mValue[updateBufferIndex] = mValue[updateBufferIndex ? 0 : 1];
  86
  87       mReinheritedFlag = false;
  88     }
  89   }
  90
  91   /**
  92    * @copydoc Dali::Internal::SceneGraph::PropertyBase::IsClean()
  93    */
  94   virtual bool IsClean() const
  95   {
  96     return ( false == mReinheritedFlag );
  97   }
  98
  99   /**
 100    * @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
 101    */
 102   virtual bool InputInitialized() const
 103   {
 104     // A constraint cannot use the property until it has been inherited (at least once).
 105     return mInheritedFlag;
 106   }
 107
 108   /**
 109    * @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
 110    * @note A constraint can only receive the inherited property from the previous frame.
 111    */
 112   virtual bool InputChanged() const
 113   {
 114     return !IsClean();
 115   }
 116
 117   /**
 118    * @copydoc Dali::PropertyInput::GetVector3()
 119    */
 120   virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
 121   {
 122     return mValue[ bufferIndex ];
 123   }
 124
 125   /**
 126    * @copydoc Dali::PropertyInput::GetConstraintInputVector3()
 127    */
 128   virtual const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const
 129   {
 130     // For inherited properties, constraints work with the value from the previous frame.
 131     // This is because constraints are applied to position etc, before world-position is calculated.
 132     BufferIndex eventBufferIndex = bufferIndex ? 0u : 1u;
 133
 134     return mValue[ eventBufferIndex ];
 135   }
 136
 137   /**
 138    * Set the property value. This will only persist for the current frame; the property
 139    * will be reset with the base value, at the beginning of the next frame.
 140    * @param[in] bufferIndex The buffer to write.
 141    * @param[in] value The new property value.
 142    */
 143   void Set(BufferIndex bufferIndex, const Vector3& value)
 144   {
 145     mValue[bufferIndex] = value;
 146
 147     // The value has been inherited for the first time
 148     mInheritedFlag = true;
 149
 150     mReinheritedFlag = true;
 151   }
 152
 153   /**
 154    * @copydoc Dali::SceneGraph::PropertyInterface::Get()
 155    */
 156   Vector3& Get(size_t bufferIndex)
 157   {
 158     return mValue[bufferIndex];
 159   }
 160
 161   /**
 162    * @copydoc Dali::SceneGraph::PropertyInterface::Get()
 163    */
 164   const Vector3& Get(size_t bufferIndex) const
 165   {
 166     return mValue[bufferIndex];
 167   }
 168
 169   /**
 170    * Retrieve the property value.
 171    * @param[in] bufferIndex The buffer to read.
 172    * @return The property value.
 173    */
 174   const Vector3& operator[](size_t bufferIndex) const
 175   {
 176     return mValue[bufferIndex];
 177   }
 178
 179 private:
 180
 181   // Undefined
 182   InheritedProperty(const InheritedProperty& property);
 183
 184   // Undefined
 185   InheritedProperty& operator=(const InheritedProperty& rhs);
 186
 187 private:
 188
 189   DoubleBuffered<Vector3> mValue; ///< The double-buffered property value
 190
 191   bool mInheritedFlag   :1; ///< Flag whether the value has ever been inherited
 192   bool mReinheritedFlag :1; ///< Flag whether value was re-inherited in previous frame
 193 };
 194
 195 /**
 196  * An inherited Color property.
 197  */
 198 class InheritedColor : public PropertyInputImpl
 199 {
 200 public:
 201
 202   /**
 203    * Create an inherited property.
 204    * @param [in] initialValue The initial value of the property.
 205    */
 206   InheritedColor( const Vector4& initialValue )
 207   : mValue( initialValue ),
 208     mInheritedFlag( false ),
 209     mReinheritedFlag( true )
 210   {
 211   }
 212
 213   /**
 214    * Virtual destructor.
 215    */
 216   virtual ~InheritedColor()
 217   {
 218   }
 219
 220   /**
 221    * @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
 222    */
 223   virtual Dali::Property::Type GetType() const
 224   {
 225     return Dali::PropertyTypes::Get<Vector4>();
 226   }
 227
 228   /**
 229    * Called once per Update (only) if the property did not need to be re-inherited.
 230    * @param[in] updateBufferIndex The current update buffer index.
 231    */
 232   void CopyPrevious( BufferIndex updateBufferIndex )
 233   {
 234     if ( mReinheritedFlag )
 235     {
 236       mValue[updateBufferIndex] = mValue[updateBufferIndex ? 0 : 1];
 237
 238       mReinheritedFlag = false;
 239     }
 240   }
 241
 242   /**
 243    * @copydoc Dali::Internal::SceneGraph::PropertyBase::IsClean()
 244    */
 245   virtual bool IsClean() const
 246   {
 247     return ( false == mReinheritedFlag );
 248   }
 249
 250   /**
 251    * @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
 252    */
 253   virtual bool InputInitialized() const
 254   {
 255     // A constraint cannot use the property until it has been inherited (at least once).
 256     return mInheritedFlag;
 257   }
 258
 259   /**
 260    * @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
 261    * @note A constraint can only receive the inherited property from the previous frame.
 262    */
 263   virtual bool InputChanged() const
 264   {
 265     return !IsClean();
 266   }
 267
 268   /**
 269    * @copydoc Dali::PropertyInput::GetVector4()
 270    */
 271   virtual const Vector4& GetVector4( BufferIndex bufferIndex ) const
 272   {
 273     return mValue[ bufferIndex ];
 274   }
 275
 276   /**
 277    * @copydoc Dali::PropertyInput::GetConstraintInputVector4()
 278    */
 279   virtual const Vector4& GetConstraintInputVector4( BufferIndex bufferIndex ) const
 280   {
 281     // For inherited properties, constraints work with the value from the previous frame.
 282     // This is because constraints are applied to position etc, before world-position is calculated.
 283     BufferIndex eventBufferIndex = bufferIndex ? 0u : 1u;
 284
 285     return mValue[ eventBufferIndex ];
 286   }
 287
 288   /**
 289    * Set the property value. This will only persist for the current frame; the property
 290    * will be reset with the base value, at the beginning of the next frame.
 291    * @param[in] bufferIndex The buffer to write.
 292    * @param[in] value The new property value.
 293    */
 294   void Set(BufferIndex bufferIndex, const Vector4& value)
 295   {
 296     mValue[bufferIndex] = Clamp( value, 0.0f, 1.0f ); // color values are clamped between 0 and 1
 297
 298     // The value has been inherited for the first time
 299     mInheritedFlag = true;
 300     mReinheritedFlag = true;
 301   }
 302
 303   /**
 304    * Set the property value. This will only persist for the current frame; the property
 305    * will be reset with the base value, at the beginning of the next frame.
 306    * @param[in] bufferIndex The buffer to write.
 307    * @param[in] r The new red value.
 308    * @param[in] g The new green value.
 309    * @param[in] b The new blue value.
 310    * @param[in] a The new alpha value.
 311    */
 312   void Set(BufferIndex bufferIndex, float r, float g, float b, float a )
 313   {
 314     mValue[bufferIndex].r = Clamp( r, 0.0f, 1.0f ); // color values are clamped between 0 and 1
 315     mValue[bufferIndex].g = Clamp( g, 0.0f, 1.0f ); // color values are clamped between 0 and 1
 316     mValue[bufferIndex].b = Clamp( b, 0.0f, 1.0f ); // color values are clamped between 0 and 1
 317     mValue[bufferIndex].a = Clamp( a, 0.0f, 1.0f ); // color values are clamped between 0 and 1
 318
 319     // The value has been inherited for the first time
 320     mInheritedFlag = true;
 321     mReinheritedFlag = true;
 322   }
 323
 324   /**
 325    * @copydoc Dali::SceneGraph::PropertyInterface::Get()
 326    */
 327   Vector4& Get(size_t bufferIndex)
 328   {
 329     return mValue[bufferIndex];
 330   }
 331
 332   /**
 333    * @copydoc Dali::SceneGraph::PropertyInterface::Get()
 334    */
 335   const Vector4& Get(size_t bufferIndex) const
 336   {
 337     return mValue[bufferIndex];
 338   }
 339
 340   /**
 341    * Retrieve the property value.
 342    * @param[in] bufferIndex The buffer to read.
 343    * @return The property value.
 344    */
 345   const Vector4& operator[](size_t bufferIndex) const
 346   {
 347     return mValue[bufferIndex];
 348   }
 349
 350 private:
 351
 352   // Undefined
 353   InheritedColor(const InheritedColor& property);
 354   // Undefined
 355   InheritedColor& operator=(const InheritedColor& rhs);
 356
 357 private:
 358
 359   DoubleBuffered<Vector4> mValue; ///< The double-buffered property value
 360
 361   bool mInheritedFlag   :1; ///< Flag whether the value has ever been inherited
 362   bool mReinheritedFlag :1; ///< Flag whether value was re-inherited in previous frame
 363
 364 };
 365
 366 /**
 367  * An inherited Quaternion property.
 368  */
 369 template <>
 370 class InheritedProperty<Quaternion> : public PropertyInputImpl
 371 {
 372 public:
 373
 374   /**
 375    * Create an inherited property.
 376    * @param [in] initialValue The initial value of the property.
 377    */
 378   InheritedProperty( const Quaternion& initialValue )
 379   : mValue( initialValue ),
 380     mInheritedFlag( false ),
 381     mReinheritedFlag( true )
 382   {
 383   }
 384
 385   /**
 386    * Virtual destructor.
 387    */
 388   virtual ~InheritedProperty()
 389   {
 390   }
 391
 392   /**
 393    * @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
 394    */
 395   virtual Dali::Property::Type GetType() const
 396   {
 397     return Dali::PropertyTypes::Get<Quaternion>();
 398   }
 399
 400   /**
 401    * Called once per Update (only) if the property did not need to be re-inherited.
 402    * @param[in] updateBufferIndex The current update buffer index.
 403    */
 404   void CopyPrevious( BufferIndex updateBufferIndex )
 405   {
 406     if ( mReinheritedFlag )
 407     {
 408       mValue[updateBufferIndex] = mValue[updateBufferIndex ? 0 : 1];
 409
 410       mReinheritedFlag = false;
 411     }
 412   }
 413
 414   /**
 415    * @copydoc Dali::Internal::SceneGraph::PropertyBase::IsClean()
 416    */
 417   virtual bool IsClean() const
 418   {
 419     return ( false == mReinheritedFlag );
 420   }
 421
 422   /**
 423    * @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
 424    */
 425   virtual bool InputInitialized() const
 426   {
 427     // A constraint cannot use the property until it has been inherited (at least once).
 428     return mInheritedFlag;
 429   }
 430
 431   /**
 432    * @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
 433    * @note A constraint can only receive the inherited property from the previous frame.
 434    */
 435   virtual bool InputChanged() const
 436   {
 437     return !IsClean();
 438   }
 439
 440   /**
 441    * @copydoc Dali::PropertyInput::GetQuaternion()
 442    */
 443   virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
 444   {
 445     return mValue[ bufferIndex ];
 446   }
 447
 448   /**
 449    * @copydoc Dali::PropertyInput::GetConstraintInputQuaternion()
 450    */
 451   virtual const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const
 452   {
 453     // For inherited properties, constraints work with the value from the previous frame.
 454     // This is because constraints are applied to position etc, before world-position is calculated.
 455     BufferIndex eventBufferIndex = bufferIndex ? 0u : 1u;
 456
 457     return mValue[ eventBufferIndex ];
 458   }
 459
 460   /**
 461    * Set the property value. This will only persist for the current frame; the property
 462    * will be reset with the base value, at the beginning of the next frame.
 463    * @param[in] bufferIndex The buffer to write.
 464    * @param[in] value The new property value.
 465    */
 466   void Set(BufferIndex bufferIndex, const Quaternion& value)
 467   {
 468     mValue[bufferIndex] = value;
 469
 470     // The value has been inherited for the first time
 471     mInheritedFlag = true;
 472
 473     mReinheritedFlag = true;
 474   }
 475
 476   /**
 477    * @copydoc Dali::SceneGraph::PropertyInterface::Get()
 478    */
 479   Quaternion& Get(size_t bufferIndex)
 480   {
 481     return mValue[bufferIndex];
 482   }
 483
 484   /**
 485    * @copydoc Dali::SceneGraph::PropertyInterface::Get()
 486    */
 487   const Quaternion& Get(size_t bufferIndex) const
 488   {
 489     return mValue[bufferIndex];
 490   }
 491
 492   /**
 493    * Retrieve the property value.
 494    * @param[in] bufferIndex The buffer to read.
 495    * @return The property value.
 496    */
 497   const Quaternion& operator[](size_t bufferIndex) const
 498   {
 499     return mValue[bufferIndex];
 500   }
 501
 502 private:
 503
 504   // Undefined
 505   InheritedProperty();
 506
 507   // Undefined
 508   InheritedProperty(const InheritedProperty& property);
 509
 510   // Undefined
 511   InheritedProperty& operator=(const InheritedProperty& rhs);
 512
 513 private:
 514
 515   DoubleBuffered<Quaternion> mValue; ///< The double-buffered property value
 516
 517   bool mInheritedFlag   :1;   ///< Flag whether the value has ever been inherited
 518   bool mReinheritedFlag :1;   ///< Flag whether value was re-inherited in previous frame
 519 };
 520
 521 /**
 522  * An inherited Matrix property.
 523  */
 524 template <>
 525 class InheritedProperty<Matrix> : public PropertyInputImpl
 526 {
 527 public:
 528
 529   /**
 530    * Create an inherited property.
 531    * @param [in] initialValue The initial value of the property.
 532    */
 533   InheritedProperty( const Matrix& initialValue )
 534   : mValue( initialValue ),
 535     mInheritedFlag( false ),
 536     mReinheritedFlag( true )
 537   {
 538   }
 539
 540   /**
 541    * Virtual destructor.
 542    */
 543   virtual ~InheritedProperty()
 544   {
 545   }
 546
 547   /**
 548    * @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
 549    */
 550   virtual Dali::Property::Type GetType() const
 551   {
 552     return Dali::PropertyTypes::Get<Matrix>();
 553   }
 554
 555   /**
 556    * Called once per Update (only) if the property did not need to be re-inherited.
 557    * @param[in] updateBufferIndex The current update buffer index.
 558    */
 559   void CopyPrevious( BufferIndex updateBufferIndex )
 560   {
 561     if ( mReinheritedFlag )
 562     {
 563       mValue[updateBufferIndex] = mValue[updateBufferIndex ? 0 : 1];
 564
 565       mReinheritedFlag = false;
 566     }
 567   }
 568
 569   /**
 570    * @copydoc Dali::Internal::SceneGraph::PropertyBase::IsClean()
 571    */
 572   virtual bool IsClean() const
 573   {
 574     return ( false == mReinheritedFlag );
 575   }
 576
 577   /**
 578    * @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
 579    */
 580   virtual bool InputInitialized() const
 581   {
 582     // A constraint cannot use the property until it has been inherited (at least once).
 583     return mInheritedFlag;
 584   }
 585
 586   /**
 587    * @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
 588    * @note A constraint can only receive the inherited property from the previous frame.
 589    */
 590   virtual bool InputChanged() const
 591   {
 592     return !IsClean();
 593   }
 594
 595   /**
 596    * @copydoc Dali::Internal::PropertyInputImpl::GetMatrix()
 597    */
 598   virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
 599   {
 600     return mValue[ bufferIndex ];
 601   }
 602
 603   /**
 604    * @copydoc Dali::Internal::PropertyInputImpl::GetConstraintInputMatrix()
 605    */
 606   virtual const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const
 607   {
 608     // For inherited properties, constraints work with the value from the previous frame.
 609     // This is because constraints are applied to position etc, before world-position is calculated.
 610     BufferIndex eventBufferIndex = bufferIndex ? 0u : 1u;
 611
 612     return mValue[ eventBufferIndex ];
 613   }
 614
 615   /**
 616    * @copydoc Dali::PropertyInput::GetQuaternion()
 617    */
 618   virtual const Quaternion& GetQuaternion() const
 619   {
 620     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
 621     return DUMMY_QUATERNION_VALUE;
 622   }
 623
 624   /**
 625    * @copydoc Dali::PropertyInput::GetQuaternion()
 626    */
 627   virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
 628   {
 629     DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
 630     return DUMMY_QUATERNION_VALUE;
 631   }
 632
 633   /**
 634    * Set the property value. This will only persist for the current frame; the property
 635    * will be reset with the base value, at the beginning of the next frame.
 636    * @param[in] bufferIndex The buffer to write.
 637    * @param[in] value The new property value.
 638    */
 639   void Set(BufferIndex bufferIndex, const Matrix& value)
 640   {
 641     mValue[bufferIndex] = value;
 642
 643     // The value has been inherited for the first time
 644     mInheritedFlag = true;
 645
 646     mReinheritedFlag = true;
 647   }
 648
 649   /**
 650    * @copydoc Dali::SceneGraph::PropertyInterface::Get()
 651    */
 652   Matrix& Get(size_t bufferIndex)
 653   {
 654     return mValue[bufferIndex];
 655   }
 656
 657   /**
 658    * @copydoc Dali::SceneGraph::PropertyInterface::Get()
 659    */
 660   const Matrix& Get(size_t bufferIndex) const
 661   {
 662     return mValue[bufferIndex];
 663   }
 664
 665   /**
 666    * Retrieve the property value.
 667    * @param[in] bufferIndex The buffer to read.
 668    * @return The property value.
 669    */
 670   const Matrix& operator[](size_t bufferIndex) const
 671   {
 672     return mValue[bufferIndex];
 673   }
 674
 675   void SetDirty(size_t bufferIndex)
 676   {
 677     mReinheritedFlag = true;
 678
 679     // The value has been inherited for the first time
 680     mInheritedFlag = true;
 681   }
 682
 683 private:
 684
 685   // Undefined
 686   InheritedProperty();
 687
 688   // Undefined
 689   InheritedProperty(const InheritedProperty& property);
 690
 691   // Undefined
 692   InheritedProperty& operator=(const InheritedProperty& rhs);
 693
 694 private:
 695
 696   DoubleBuffered<Matrix> mValue; ///< The double-buffered property value
 697
 698   bool mInheritedFlag   :1;   ///< Flag whether the value has ever been inherited
 699   bool mReinheritedFlag :1;   ///< Flag whether value was re-inherited in previous frame
 700
 701 };
 702
 703 } // namespace SceneGraph
 704
 705 } // namespace Internal
 706
 707 } // namespace Dali
 708
 709 #endif // __DALI_INTERNAL_SCENE_GRAPH_INHERITED_PROPERTY_H__