88004cf80c86d7a1c194ab6a7c3991d97e0c0d55
[platform/core/uifw/dali-core.git] / dali / internal / event / animation / path-constrainer-impl.cpp
1 /*
2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 // CLASS HEADER
19 #include <dali/internal/event/animation/path-constrainer-impl.h>
20
21 //EXTRENAL INCLUDES
22 #include <cstring> // for strcmp
23
24 // INTERNAL INCLUDES
25 #include <dali/internal/event/common/property-helper.h>
26 #include <dali/public-api/animation/constraint.h>
27 #include <dali/public-api/object/property-array.h>
28
29 namespace Dali
30 {
31
32 namespace Internal
33 {
34
35 namespace
36 {
37
38 // Properties
39 //              Name             Type   writable animatable constraint-input  enum for index-checking
40 DALI_PROPERTY_TABLE_BEGIN
41 DALI_PROPERTY( "forward",       VECTOR3,   true,    false,       false,        Dali::PathConstrainer::Property::FORWARD )
42 DALI_PROPERTY( "points",         ARRAY,    true,    false,       false,        Dali::PathConstrainer::Property::POINTS )
43 DALI_PROPERTY( "controlPoints",  ARRAY,    true,    false,       false,        Dali::PathConstrainer::Property::CONTROL_POINTS )
44 DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX )
45
46 } //Unnamed namespace
47
48 PathConstrainer* PathConstrainer::New()
49 {
50   return new PathConstrainer();
51 }
52
53 PathConstrainer::PathConstrainer()
54 : Constrainer(),
55   mPath( Path::New() )
56 {
57 }
58
59 PathConstrainer::~PathConstrainer()
60 {
61 }
62
63 unsigned int PathConstrainer::GetDefaultPropertyCount() const
64 {
65   return DEFAULT_PROPERTY_COUNT;
66 }
67
68 void PathConstrainer::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
69 {
70   indices.Reserve( DEFAULT_PROPERTY_COUNT );
71
72   for ( Property::Index i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
73   {
74     indices.PushBack( i );
75   }
76 }
77
78 const char* PathConstrainer::GetDefaultPropertyName(Property::Index index) const
79 {
80   if ( ( index >= 0 ) && ( index < DEFAULT_PROPERTY_COUNT ) )
81   {
82     return DEFAULT_PROPERTY_DETAILS[index].name;
83   }
84
85   // index out of range
86   return NULL;
87 }
88
89 Property::Index PathConstrainer::GetDefaultPropertyIndex(const std::string& name) const
90 {
91   Property::Index index = Property::INVALID_INDEX;
92
93   // Look for name in default properties
94   for( Property::Index i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
95   {
96     const Internal::PropertyDetails* property = &DEFAULT_PROPERTY_DETAILS[ i ];
97     if( 0 == strcmp( name.c_str(), property->name ) ) // dont want to convert rhs to string
98     {
99       index = i;
100       break;
101     }
102   }
103   return index;
104 }
105
106 Property::Type PathConstrainer::GetDefaultPropertyType(Property::Index index) const
107 {
108   if( index < DEFAULT_PROPERTY_COUNT )
109   {
110     return DEFAULT_PROPERTY_DETAILS[index].type;
111   }
112
113   // index out of range
114   return Property::NONE;
115 }
116
117 Property::Value PathConstrainer::GetDefaultProperty( Property::Index index ) const
118 {
119   if( index == Dali::PathConstrainer::Property::FORWARD )
120   {
121     return Property::Value( mForward );
122   }
123   else
124   {
125     if( index == Dali::PathConstrainer::Property::POINTS )
126     {
127       Property::Value value( Property::ARRAY );
128       Property::Array* array = value.GetArray();
129       const Dali::Vector<Vector3>& point = mPath->GetPoints();
130       Property::Array::SizeType pointCount = point.Size();
131
132       if( array )
133       {
134         array->Reserve( pointCount );
135         for( Property::Array::SizeType i = 0; i < pointCount; ++i )
136         {
137           array->PushBack( point[i] );
138         }
139       }
140       return value;
141     }
142     else if( index == Dali::PathConstrainer::Property::CONTROL_POINTS )
143     {
144       Property::Value value( Property::ARRAY );
145       Property::Array* array = value.GetArray();
146       const Dali::Vector<Vector3>& point = mPath->GetControlPoints();
147       Property::Array::SizeType pointCount = point.Size();
148
149       if( array )
150       {
151         array->Reserve( pointCount );
152         for( Property::Array::SizeType i = 0; i < pointCount; ++i )
153         {
154           array->PushBack( point[i] );
155         }
156       }
157       return value;
158     }
159   }
160
161   return Property::Value();
162 }
163
164 Property::Value PathConstrainer::GetDefaultPropertyCurrentValue( Property::Index index ) const
165 {
166   return GetDefaultProperty( index ); // Event-side only properties
167 }
168
169 void PathConstrainer::SetDefaultProperty( Property::Index index, const Property::Value& propertyValue )
170 {
171   if( index == Dali::PathConstrainer::Property::FORWARD )
172   {
173     propertyValue.Get(mForward);
174   }
175   else if( index == Dali::PathConstrainer::Property::POINTS  )
176   {
177     const Property::Array* array = propertyValue.GetArray();
178     mPath->ClearPoints();
179     if( array )
180     {
181       for( Property::Array::SizeType i = 0, count = array->Count(); i < count; ++i )
182       {
183         Vector3 point;
184         array->GetElementAt( i ).Get( point );
185         mPath->AddPoint( point );
186       }
187     }
188   }
189   else if( index == Dali::PathConstrainer::Property::CONTROL_POINTS )
190   {
191     const Property::Array* array = propertyValue.GetArray();
192     mPath->ClearControlPoints();
193     if( array )
194     {
195       for( Property::Array::SizeType i = 0, count = array->Count(); i < count; ++i )
196       {
197         Vector3 point;
198         array->GetElementAt( i ).Get( point );
199         mPath->AddControlPoint( point );
200       }
201     }
202   }
203 }
204
205 bool PathConstrainer::IsDefaultPropertyWritable(Property::Index index) const
206 {
207   if( index < DEFAULT_PROPERTY_COUNT )
208   {
209     return DEFAULT_PROPERTY_DETAILS[index].writable;
210   }
211
212   return false;
213 }
214
215 bool PathConstrainer::IsDefaultPropertyAnimatable(Property::Index index) const
216 {
217   if( index < DEFAULT_PROPERTY_COUNT )
218   {
219     return DEFAULT_PROPERTY_DETAILS[index].animatable;
220   }
221
222   return false;
223 }
224
225 bool PathConstrainer::IsDefaultPropertyAConstraintInput( Property::Index index ) const
226 {
227   if( index < DEFAULT_PROPERTY_COUNT )
228   {
229     return DEFAULT_PROPERTY_DETAILS[index].constraintInput;
230   }
231
232   return false;
233 }
234
235 void PathConstrainer::Apply( Property target, Property source, const Vector2& range, const Vector2& wrap)
236 {
237   Dali::Property::Type propertyType = target.object.GetPropertyType( target.propertyIndex);
238   if( propertyType == Dali::Property::VECTOR3)
239   {
240     // If property type is Vector3, constrain its value to the position of the path
241     Dali::Constraint constraint = Dali::Constraint::New<Vector3>( target.object, target.propertyIndex, PathConstraintFunctor( mPath, range, wrap ) );
242     constraint.AddSource( Dali::Source(source.object, source.propertyIndex ) );
243
244     constraint.SetTag( static_cast<uint32_t>( reinterpret_cast<uintptr_t>( this ) ) ); // taking 32bits of this as tag
245     constraint.SetRemoveAction( Dali::Constraint::Discard );
246     constraint.Apply();
247   }
248   else if( propertyType == Dali::Property::ROTATION )
249   {
250     // If property type is Rotation, constrain its value to align the forward vector to the tangent of the path
251     Dali::Constraint constraint = Dali::Constraint::New<Quaternion>( target.object, target.propertyIndex, PathConstraintFunctor( mPath, range, mForward, wrap) );
252     constraint.AddSource( Dali::Source(source.object, source.propertyIndex ) );
253
254     constraint.SetTag( static_cast<uint32_t>( reinterpret_cast<uintptr_t>( this ) ) ); // taking 32bits of this as tag
255     constraint.SetRemoveAction( Dali::Constraint::Discard );
256     constraint.Apply();
257   }
258
259   //Start observing the object
260   Observe( target.object );
261 }
262
263 } // Internal
264
265 } // Dali