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