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