dali/internal/update/manager/transform-manager.cpp

   1 /*
   2  * Copyright (c) 2016 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/update/manager/transform-manager.h>
  20
  21 //EXTERNAL INCLUDES
  22 #include <algorithm>
  23 #include <cstring>
  24
  25 //INTERNAL INCLUDES
  26 #include <dali/public-api/common/constants.h>
  27 #include <dali/public-api/common/compile-time-assert.h>
  28
  29 namespace Dali
  30 {
  31
  32 namespace Internal
  33 {
  34
  35 namespace SceneGraph
  36 {
  37
  38 namespace
  39 {
  40 //Default values for scale (1.0,1.0,1.0), orientation (Identity) and position (0.0,0.0,0.0)
  41 static const float gDefaultTransformComponentAnimatableData[] = { 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f };
  42
  43 //Default values for anchor point (CENTER) and parent origin (TOP_LEFT)
  44 static const float gDefaultTransformComponentStaticData[] = { 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 0.5f };
  45
  46 DALI_COMPILE_TIME_ASSERT( sizeof(gDefaultTransformComponentAnimatableData) == sizeof(TransformComponentAnimatable) );
  47 DALI_COMPILE_TIME_ASSERT( sizeof(gDefaultTransformComponentStaticData) == sizeof(TransformComponentStatic) );
  48 }
  49
  50 TransformManager::TransformManager()
  51 :mComponentCount(0),
  52  mReorder(false)
  53 {}
  54
  55 TransformManager::~TransformManager()
  56 {}
  57
  58 TransformId TransformManager::CreateTransform()
  59 {
  60   //Get id for the new component
  61   TransformId id = mIds.Add(mComponentCount);
  62
  63   if( mTxComponentAnimatable.Size() <= mComponentCount )
  64   {
  65     //Make room for another component
  66     mTxComponentAnimatable.PushBack(TransformComponentAnimatable());
  67     mTxComponentStatic.PushBack(TransformComponentStatic());
  68     mInheritanceMode.PushBack(INHERIT_ALL);
  69     mComponentId.PushBack(id);
  70     mSize.PushBack(Vector3(0.0f,0.0f,0.0f));
  71     mParent.PushBack(INVALID_TRANSFORM_ID);
  72     mWorld.PushBack(Matrix::IDENTITY);
  73     mLocal.PushBack(Matrix::IDENTITY);
  74     mTxComponentAnimatableBaseValue.PushBack(TransformComponentAnimatable());
  75     mSizeBase.PushBack(Vector3(0.0f,0.0f,0.0f));
  76     mComponentDirty.PushBack(false);
  77     mLocalMatrixDirty.PushBack(false);
  78   }
  79   else
  80   {
  81     //Set default values
  82     memcpy( &mTxComponentAnimatable[mComponentCount], &gDefaultTransformComponentAnimatableData, sizeof( TransformComponentAnimatable ) );
  83     memcpy( &mTxComponentStatic[mComponentCount], &gDefaultTransformComponentStaticData, sizeof( TransformComponentStatic ) );
  84     memcpy( &mTxComponentAnimatableBaseValue[mComponentCount], &gDefaultTransformComponentAnimatableData, sizeof( TransformComponentAnimatable ) );
  85     mInheritanceMode[mComponentCount] = INHERIT_ALL;
  86     mComponentId[mComponentCount] = id;
  87     mSize[mComponentCount] = Vector3(0.0f,0.0f,0.0f);
  88     mParent[mComponentCount] = INVALID_TRANSFORM_ID;
  89     mLocal[mComponentCount].SetIdentity();
  90     mWorld[mComponentCount].SetIdentity();
  91     mSizeBase[mComponentCount] = Vector3(0.0f,0.0f,0.0f);
  92     mComponentDirty[mComponentCount] = false;
  93     mLocalMatrixDirty[mComponentCount] = false;
  94   }
  95
  96   mComponentCount++;
  97   return id;
  98 }
  99
 100 void TransformManager::RemoveTransform(TransformId id)
 101 {
 102   //Move the last element to the gap
 103   mComponentCount--;
 104   unsigned int index = mIds[id];
 105   mTxComponentAnimatable[index] = mTxComponentAnimatable[mComponentCount];
 106   mTxComponentStatic[index] = mTxComponentStatic[mComponentCount];
 107   mInheritanceMode[index] = mInheritanceMode[mComponentCount];
 108   mSize[index] = mSize[mComponentCount];
 109   mParent[index] = mParent[mComponentCount];
 110   mWorld[index] = mWorld[mComponentCount];
 111   mLocal[index] = mLocal[mComponentCount];
 112   mTxComponentAnimatableBaseValue[index] = mTxComponentAnimatableBaseValue[mComponentCount];
 113   mSizeBase[index] = mSizeBase[mComponentCount];
 114   mComponentDirty[index] = mComponentDirty[mComponentCount];
 115   mLocalMatrixDirty[index] = mLocalMatrixDirty[mComponentCount];
 116
 117   TransformId lastItemId = mComponentId[mComponentCount];
 118   mIds[ lastItemId ] = index;
 119   mComponentId[index] = lastItemId;
 120   mIds.Remove( id );
 121
 122   mReorder = true;
 123 }
 124
 125 void TransformManager::SetParent( TransformId id, TransformId parentId )
 126 {
 127   DALI_ASSERT_ALWAYS( id != parentId );
 128   mParent[ mIds[id] ] = parentId;
 129   mReorder = true;
 130 }
 131
 132 const Matrix& TransformManager::GetWorldMatrix( TransformId id ) const
 133 {
 134   return mWorld[ mIds[id] ];
 135 }
 136
 137 Matrix& TransformManager::GetWorldMatrix( TransformId id )
 138 {
 139   return mWorld[ mIds[id] ];
 140 }
 141
 142 void TransformManager::SetInheritPosition( TransformId id, bool inherit )
 143 {
 144   unsigned int index = mIds[id];
 145   if( inherit )
 146   {
 147     mInheritanceMode[ index ] |= INHERIT_POSITION;
 148   }
 149   else
 150   {
 151     mInheritanceMode[ index ] &= ~INHERIT_POSITION;
 152   }
 153
 154   mComponentDirty[index] = true;
 155 }
 156
 157 void TransformManager::SetInheritScale( TransformId id, bool inherit )
 158 {
 159   unsigned int index = mIds[id];
 160   if( inherit )
 161   {
 162     mInheritanceMode[ index ] |= INHERIT_SCALE;
 163   }
 164   else
 165   {
 166     mInheritanceMode[ index ] &= ~INHERIT_SCALE;
 167   }
 168
 169   mComponentDirty[index] = true;
 170 }
 171
 172 void TransformManager::SetInheritOrientation( TransformId id, bool inherit )
 173 {
 174   unsigned int index = mIds[id];
 175   if( inherit )
 176   {
 177     mInheritanceMode[ index ] |= INHERIT_ORIENTATION;
 178   }
 179   else
 180   {
 181     mInheritanceMode[ index ] &= ~INHERIT_ORIENTATION;
 182   }
 183
 184   mComponentDirty[index] = true;
 185 }
 186
 187 void TransformManager::ResetToBaseValue()
 188 {
 189   if( mComponentCount )
 190   {
 191     memcpy( &mTxComponentAnimatable[0], &mTxComponentAnimatableBaseValue[0], sizeof(TransformComponentAnimatable)*mComponentCount );
 192     memcpy( &mSize[0], &mSizeBase[0], sizeof(Vector3)*mComponentCount );
 193     memset( &mLocalMatrixDirty[0], false, sizeof(bool)*mComponentCount );
 194   }
 195 }
 196
 197 void TransformManager::Update()
 198 {
 199   if( mReorder )
 200   {
 201     //If some transform component has change its parent or has been removed since last update
 202     //we need to reorder the vectors
 203     ReorderComponents();
 204     mReorder = false;
 205   }
 206
 207   //Iterate through all components to compute its world matrix
 208   Vector3 anchorPosition;
 209   Vector3 localPosition;
 210   Vector3 half( 0.5f,0.5f,0.5f );
 211   for( unsigned int i(0); i<mComponentCount; ++i )
 212   {
 213     if( DALI_LIKELY( mInheritanceMode[i] != DONT_INHERIT_TRANSFORM && mParent[i] != INVALID_TRANSFORM_ID ) )
 214     {
 215       const unsigned int& parentIndex = mIds[mParent[i] ];
 216       if( DALI_LIKELY( mInheritanceMode[i] == INHERIT_ALL ) )
 217       {
 218         if( mComponentDirty[i] || mLocalMatrixDirty[parentIndex])
 219         {
 220           //Full transform inherited
 221           mComponentDirty[i] = false;
 222           mLocalMatrixDirty[i] = true;
 223
 224           anchorPosition = ( half - mTxComponentStatic[i].mAnchorPoint ) * mSize[i] * mTxComponentAnimatable[i].mScale;
 225           anchorPosition *= mTxComponentAnimatable[i].mOrientation;
 226           localPosition = mTxComponentAnimatable[i].mPosition + anchorPosition + ( mTxComponentStatic[i].mParentOrigin - half ) *  mSize[parentIndex];
 227           mLocal[i].SetTransformComponents( mTxComponentAnimatable[i].mScale,mTxComponentAnimatable[i].mOrientation, localPosition );
 228         }
 229
 230         Matrix::Multiply( mWorld[i], mLocal[i], mWorld[parentIndex]);
 231       }
 232       else
 233       {
 234         //Some components are not inherited
 235         Vector3 parentPosition, parentScale;
 236         Quaternion parentOrientation;
 237         const Matrix& parentMatrix = mWorld[parentIndex];
 238         parentMatrix.GetTransformComponents( parentPosition, parentOrientation, parentScale );
 239
 240         Vector3 localScale = mTxComponentAnimatable[i].mScale;
 241         if( (mInheritanceMode[i] & INHERIT_SCALE) == 0 )
 242         {
 243           //Don't inherit scale
 244           localScale /= parentScale;
 245         }
 246
 247         Quaternion localOrientation( mTxComponentAnimatable[i].mOrientation );
 248         if( (mInheritanceMode[i] & INHERIT_ORIENTATION) == 0 )
 249         {
 250           //Don't inherit orientation
 251           parentOrientation.Invert();
 252           localOrientation = parentOrientation * mTxComponentAnimatable[i].mOrientation;
 253         }
 254
 255         if( (mInheritanceMode[i] & INHERIT_POSITION) == 0 )
 256         {
 257           //Don't inherit position
 258           mLocal[i].SetTransformComponents( localScale, localOrientation, Vector3::ZERO );
 259           Matrix::Multiply( mWorld[i], mLocal[i], parentMatrix );
 260           mWorld[i].SetTranslation( mTxComponentAnimatable[i].mPosition);
 261         }
 262         else
 263         {
 264           anchorPosition = ( half - mTxComponentStatic[i].mAnchorPoint ) * mSize[i] * mTxComponentAnimatable[i].mScale;
 265           anchorPosition *= mTxComponentAnimatable[i].mOrientation;
 266           localPosition = mTxComponentAnimatable[i].mPosition + anchorPosition + ( mTxComponentStatic[i].mParentOrigin - half ) *  mSize[parentIndex];
 267           mLocal[i].SetTransformComponents( localScale, localOrientation, localPosition );
 268           Matrix::Multiply( mWorld[i], mLocal[i], parentMatrix );
 269         }
 270       }
 271     }
 272     else  //Component has no parent or doesn't inherit transform
 273     {
 274       anchorPosition = ( half - mTxComponentStatic[i].mAnchorPoint ) * mSize[i] * mTxComponentAnimatable[i].mScale;
 275       anchorPosition *= mTxComponentAnimatable[i].mOrientation;
 276       localPosition = mTxComponentAnimatable[i].mPosition + anchorPosition;
 277       mWorld[i].SetTransformComponents( mTxComponentAnimatable[i].mScale, mTxComponentAnimatable[i].mOrientation, localPosition );
 278     }
 279   }
 280 }
 281
 282 void TransformManager::SwapComponents( unsigned int i, unsigned int j )
 283 {
 284   std::swap( mTxComponentAnimatable[i], mTxComponentAnimatable[j] );
 285   std::swap( mTxComponentStatic[i], mTxComponentStatic[j] );
 286   std::swap( mInheritanceMode[i], mInheritanceMode[j] );
 287   std::swap( mSize[i], mSize[j] );
 288   std::swap( mParent[i], mParent[j] );
 289   std::swap( mComponentId[i], mComponentId[j] );
 290   std::swap( mTxComponentAnimatableBaseValue[i], mTxComponentAnimatableBaseValue[j] );
 291   std::swap( mSizeBase[i], mSizeBase[j] );
 292   std::swap( mLocal[i], mLocal[j] );
 293   std::swap( mComponentDirty[i], mComponentDirty[j] );
 294
 295   mIds[ mComponentId[i] ] = i;
 296   mIds[ mComponentId[j] ] = j;
 297 }
 298
 299 void TransformManager::ReorderComponents()
 300 {
 301   mOrderedComponents.Resize(mComponentCount);
 302
 303   TransformId parentId;
 304   for( size_t i(0); i<mComponentCount; ++i )
 305   {
 306     mOrderedComponents[i].id = mComponentId[i];
 307     mOrderedComponents[i].level = 0u;
 308
 309     parentId = mParent[i];
 310     while( parentId != INVALID_TRANSFORM_ID )
 311     {
 312       mOrderedComponents[i].level++;
 313       parentId = mParent[ mIds[parentId] ];
 314     }
 315   }
 316
 317   std::sort( mOrderedComponents.Begin(), mOrderedComponents.End());
 318   for( size_t i(0); i<mComponentCount-1; ++i )
 319   {
 320     SwapComponents( mIds[mOrderedComponents[i].id], i);
 321   }
 322 }
 323
 324 Vector3& TransformManager::GetVector3PropertyValue( TransformId id, TransformManagerProperty property )
 325 {
 326   switch( property )
 327   {
 328     case TRANSFORM_PROPERTY_POSITION:
 329     {
 330       unsigned int index( mIds[id] );
 331       mComponentDirty[ index ] = true;
 332       return mTxComponentAnimatable[ index ].mPosition;
 333     }
 334     case TRANSFORM_PROPERTY_SCALE:
 335     {
 336       unsigned int index( mIds[id] );
 337       mComponentDirty[ index ] = true;
 338       return mTxComponentAnimatable[ index ].mScale;
 339     }
 340     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 341     {
 342       unsigned int index( mIds[id] );
 343       mComponentDirty[ index ] = true;
 344       return mTxComponentStatic[ index ].mParentOrigin;
 345     }
 346     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 347     {
 348       unsigned int index( mIds[id] );
 349       mComponentDirty[ index ] = true;
 350       return mTxComponentStatic[ index ].mAnchorPoint;
 351     }
 352     case TRANSFORM_PROPERTY_SIZE:
 353     {
 354       unsigned int index( mIds[id] );
 355       mComponentDirty[ index ] = true;
 356       return mSize[ index ];
 357     }
 358     default:
 359     {
 360       DALI_ASSERT_ALWAYS(false);
 361       return mTxComponentAnimatable[ mIds[id] ].mPosition;
 362     }
 363   }
 364 }
 365
 366 const Vector3& TransformManager::GetVector3PropertyValue( TransformId id, TransformManagerProperty property ) const
 367 {
 368   switch( property )
 369   {
 370     case TRANSFORM_PROPERTY_POSITION:
 371     {
 372       return mTxComponentAnimatable[ mIds[id] ].mPosition;
 373     }
 374     case TRANSFORM_PROPERTY_SCALE:
 375     {
 376       return mTxComponentAnimatable[ mIds[id] ].mScale;
 377     }
 378     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 379     {
 380       return mTxComponentStatic[ mIds[id] ].mParentOrigin;
 381     }
 382     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 383     {
 384       return mTxComponentStatic[ mIds[id] ].mAnchorPoint;
 385     }
 386     case TRANSFORM_PROPERTY_SIZE:
 387     {
 388       return mSize[ mIds[id] ];
 389     }
 390     default:
 391     {
 392       DALI_ASSERT_ALWAYS(false);
 393       return mTxComponentAnimatable[ mIds[id] ].mPosition;
 394     }
 395   }
 396 }
 397
 398 const float& TransformManager::GetVector3PropertyComponentValue(TransformId id, TransformManagerProperty property, unsigned int component ) const
 399 {
 400   switch( property )
 401   {
 402     case TRANSFORM_PROPERTY_POSITION:
 403     {
 404       return mTxComponentAnimatable[ mIds[id] ].mPosition[component];
 405     }
 406     case TRANSFORM_PROPERTY_SCALE:
 407     {
 408       return mTxComponentAnimatable[ mIds[id] ].mScale[component];
 409     }
 410     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 411     {
 412       return mTxComponentStatic[ mIds[id] ].mParentOrigin[component];
 413     }
 414     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 415     {
 416       return mTxComponentStatic[ mIds[id] ].mAnchorPoint[component];
 417     }
 418     case TRANSFORM_PROPERTY_SIZE:
 419     {
 420       return mSize[ mIds[id] ][component];
 421     }
 422     default:
 423     {
 424       DALI_ASSERT_ALWAYS(false);
 425       return mTxComponentAnimatable[ mIds[id] ].mPosition[component];
 426     }
 427   }
 428 }
 429
 430 void TransformManager::SetVector3PropertyValue( TransformId id, TransformManagerProperty property, const Vector3& value )
 431 {
 432   unsigned int index( mIds[id] );
 433   mComponentDirty[ index ] = true;
 434
 435   switch( property )
 436   {
 437     case TRANSFORM_PROPERTY_POSITION:
 438     {
 439       mTxComponentAnimatable[ index ].mPosition = value;
 440       break;
 441     }
 442     case TRANSFORM_PROPERTY_SCALE:
 443     {
 444       mTxComponentAnimatable[ index ].mScale = value;
 445       break;
 446     }
 447     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 448     {
 449       mTxComponentStatic[ index ].mParentOrigin = value;
 450       break;
 451     }
 452     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 453     {
 454       mTxComponentStatic[ index ].mAnchorPoint = value;
 455       break;
 456     }
 457     case TRANSFORM_PROPERTY_SIZE:
 458     {
 459       mSize[ index ] = value;
 460       break;
 461     }
 462     default:
 463     {
 464       DALI_ASSERT_ALWAYS(false);
 465     }
 466   }
 467 }
 468
 469 void TransformManager::SetVector3PropertyComponentValue( TransformId id, TransformManagerProperty property, float value, unsigned int component )
 470 {
 471   unsigned int index( mIds[id] );
 472   mComponentDirty[ index ] = true;
 473
 474   switch( property )
 475   {
 476     case TRANSFORM_PROPERTY_POSITION:
 477     {
 478       mTxComponentAnimatable[ index ].mPosition[component] = value;
 479       break;
 480     }
 481     case TRANSFORM_PROPERTY_SCALE:
 482     {
 483       mTxComponentAnimatable[ index ].mScale[component] = value;
 484       break;
 485     }
 486     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 487     {
 488       mTxComponentStatic[ index ].mParentOrigin[component] = value;
 489       break;
 490     }
 491     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 492     {
 493       mTxComponentStatic[ index ].mAnchorPoint[component] = value;
 494       break;
 495     }
 496     case TRANSFORM_PROPERTY_SIZE:
 497     {
 498       mSize[ index ][component] = value;
 499       break;
 500     }
 501     default:
 502     {
 503       DALI_ASSERT_ALWAYS(false);
 504     }
 505   }
 506 }
 507
 508 void TransformManager::BakeVector3PropertyValue( TransformId id, TransformManagerProperty property, const Vector3& value )
 509 {
 510   unsigned int index( mIds[id] );
 511   mComponentDirty[ index ] = true;
 512
 513   switch( property )
 514   {
 515     case TRANSFORM_PROPERTY_POSITION:
 516     {
 517       mTxComponentAnimatable[ index ].mPosition = mTxComponentAnimatableBaseValue[index].mPosition = value;
 518       break;
 519     }
 520     case TRANSFORM_PROPERTY_SCALE:
 521     {
 522       mTxComponentAnimatable[ index ].mScale = mTxComponentAnimatableBaseValue[index].mScale = value;
 523       break;
 524     }
 525     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 526     {
 527       mTxComponentStatic[ index ].mParentOrigin = value;
 528       break;
 529     }
 530     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 531     {
 532       mTxComponentStatic[ index ].mAnchorPoint = value;
 533       break;
 534     }
 535     case TRANSFORM_PROPERTY_SIZE:
 536     {
 537       mSize[ index ] = mSizeBase[index] = value;
 538       break;
 539     }
 540     default:
 541     {
 542       DALI_ASSERT_ALWAYS(false);
 543     }
 544   }
 545 }
 546
 547 void TransformManager::BakeRelativeVector3PropertyValue( TransformId id, TransformManagerProperty property, const Vector3& value )
 548 {
 549   unsigned int index( mIds[id] );
 550   mComponentDirty[ index ] = true;
 551
 552   switch( property )
 553   {
 554     case TRANSFORM_PROPERTY_POSITION:
 555     {
 556       mTxComponentAnimatable[ index ].mPosition = mTxComponentAnimatableBaseValue[index].mPosition = mTxComponentAnimatable[ index ].mPosition + value;
 557       break;
 558     }
 559     case TRANSFORM_PROPERTY_SCALE:
 560     {
 561       mTxComponentAnimatable[ index ].mScale = mTxComponentAnimatableBaseValue[index].mScale = mTxComponentAnimatable[ index ].mScale + value;
 562       break;
 563     }
 564     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 565     {
 566       mTxComponentStatic[ index ].mParentOrigin = mTxComponentStatic[ index ].mParentOrigin + value;
 567       break;
 568     }
 569     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 570     {
 571       mTxComponentStatic[ index ].mAnchorPoint = mTxComponentStatic[ index ].mAnchorPoint + value;
 572       break;
 573     }
 574     case TRANSFORM_PROPERTY_SIZE:
 575     {
 576       mSize[ index ] = mSizeBase[index] = mSize[ index ] + value;
 577       break;
 578     }
 579     default:
 580     {
 581       DALI_ASSERT_ALWAYS(false);
 582     }
 583   }
 584 }
 585
 586 void TransformManager::BakeMultiplyVector3PropertyValue( TransformId id, TransformManagerProperty property, const Vector3& value )
 587 {
 588   unsigned int index( mIds[id] );
 589   mComponentDirty[ index ] = true;
 590
 591   switch( property )
 592   {
 593     case TRANSFORM_PROPERTY_POSITION:
 594     {
 595       mTxComponentAnimatable[ index ].mPosition = mTxComponentAnimatableBaseValue[index].mPosition = mTxComponentAnimatable[ index ].mPosition * value;
 596       break;
 597     }
 598     case TRANSFORM_PROPERTY_SCALE:
 599     {
 600       mTxComponentAnimatable[ index ].mScale = mTxComponentAnimatableBaseValue[index].mScale = mTxComponentAnimatable[ index ].mScale * value;
 601       break;
 602     }
 603     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 604     {
 605       mTxComponentStatic[ index ].mParentOrigin = mTxComponentStatic[ index ].mParentOrigin * value;
 606       break;
 607     }
 608     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 609     {
 610       mTxComponentStatic[ index ].mAnchorPoint = mTxComponentStatic[ index ].mAnchorPoint * value;
 611       break;
 612     }
 613     case TRANSFORM_PROPERTY_SIZE:
 614     {
 615       mSize[ index ] = mSizeBase[index] = mSize[ index ] * value;
 616       break;
 617     }
 618     default:
 619     {
 620       DALI_ASSERT_ALWAYS(false);
 621     }
 622   }
 623 }
 624
 625 void TransformManager::BakeVector3PropertyComponentValue( TransformId id, TransformManagerProperty property, float value, unsigned int component )
 626 {
 627   unsigned int index( mIds[id] );
 628   mComponentDirty[ index ] = true;
 629
 630   switch( property )
 631   {
 632     case TRANSFORM_PROPERTY_POSITION:
 633     {
 634       mTxComponentAnimatable[ index ].mPosition[component] = mTxComponentAnimatableBaseValue[index].mPosition[component] = value;
 635       break;
 636     }
 637     case TRANSFORM_PROPERTY_SCALE:
 638     {
 639       mTxComponentAnimatable[ index ].mScale[component] = mTxComponentAnimatableBaseValue[index].mScale[component] = value;
 640       break;
 641     }
 642     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 643     {
 644       mTxComponentStatic[ index ].mParentOrigin[component] = value;
 645       break;
 646     }
 647     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 648     {
 649       mTxComponentStatic[ index ].mAnchorPoint[component] = value;
 650       break;
 651     }
 652     case TRANSFORM_PROPERTY_SIZE:
 653     {
 654       mSize[ index ][component] = mSizeBase[index][component] = value;
 655       break;
 656     }
 657     default:
 658     {
 659       DALI_ASSERT_ALWAYS(false);
 660     }
 661   }
 662 }
 663
 664 void TransformManager::BakeXVector3PropertyValue( TransformId id, TransformManagerProperty property, float value )
 665 {
 666   unsigned int index( mIds[id] );
 667   mComponentDirty[ index ] = true;
 668
 669   switch( property )
 670   {
 671     case TRANSFORM_PROPERTY_POSITION:
 672     {
 673       mTxComponentAnimatable[ index ].mPosition.x = mTxComponentAnimatableBaseValue[index].mPosition.x = value;
 674       break;
 675     }
 676     case TRANSFORM_PROPERTY_SCALE:
 677     {
 678       mTxComponentAnimatable[ index ].mScale.x = mTxComponentAnimatableBaseValue[index].mScale.x = value;
 679       break;
 680     }
 681     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 682     {
 683       mTxComponentStatic[ index ].mParentOrigin.x = value;
 684       break;
 685     }
 686     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 687     {
 688       mTxComponentStatic[ index ].mAnchorPoint.x = value;
 689       break;
 690     }
 691     case TRANSFORM_PROPERTY_SIZE:
 692     {
 693       mSize[ index ].x = mSizeBase[index].x = value;
 694       break;
 695     }
 696     default:
 697     {
 698       DALI_ASSERT_ALWAYS(false);
 699     }
 700   }
 701 }
 702
 703 void TransformManager::BakeYVector3PropertyValue( TransformId id, TransformManagerProperty property, float value )
 704 {
 705   unsigned int index( mIds[id] );
 706   mComponentDirty[ index ] = true;
 707
 708   switch( property )
 709   {
 710     case TRANSFORM_PROPERTY_POSITION:
 711     {
 712       mTxComponentAnimatable[ index ].mPosition.y = mTxComponentAnimatableBaseValue[index].mPosition.y = value;
 713       break;
 714     }
 715     case TRANSFORM_PROPERTY_SCALE:
 716     {
 717       mTxComponentAnimatable[ index ].mScale.y = mTxComponentAnimatableBaseValue[index].mScale.y = value;
 718       break;
 719     }
 720     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 721     {
 722       mTxComponentStatic[ index ].mParentOrigin.y = value;
 723       break;
 724     }
 725     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 726     {
 727       mTxComponentStatic[ index ].mAnchorPoint.y = value;
 728       break;
 729     }
 730     case TRANSFORM_PROPERTY_SIZE:
 731     {
 732       mSize[ index ].y = mSizeBase[index].y = value;
 733       break;
 734     }
 735     default:
 736     {
 737       DALI_ASSERT_ALWAYS(false);
 738     }
 739   }
 740 }
 741
 742 void TransformManager::BakeZVector3PropertyValue( TransformId id, TransformManagerProperty property, float value )
 743 {
 744   unsigned int index( mIds[id] );
 745   mComponentDirty[ index ] = true;
 746
 747   switch( property )
 748   {
 749     case TRANSFORM_PROPERTY_POSITION:
 750     {
 751       mTxComponentAnimatable[ index ].mPosition.z = mTxComponentAnimatableBaseValue[index].mPosition.z = value;
 752       break;
 753     }
 754     case TRANSFORM_PROPERTY_SCALE:
 755     {
 756       mTxComponentAnimatable[ index ].mScale.z = mTxComponentAnimatableBaseValue[index].mScale.z = value;
 757       break;
 758     }
 759     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 760     {
 761       mTxComponentStatic[ index ].mParentOrigin.z = value;
 762       break;
 763     }
 764     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 765     {
 766       mTxComponentStatic[ index ].mAnchorPoint.z = value;
 767       break;
 768     }
 769     case TRANSFORM_PROPERTY_SIZE:
 770     {
 771       mSize[ index ].z = mSizeBase[index].z = value;
 772       break;
 773     }
 774     default:
 775     {
 776       DALI_ASSERT_ALWAYS(false);
 777     }
 778   }
 779 }
 780
 781 Quaternion& TransformManager::GetQuaternionPropertyValue( TransformId id )
 782 {
 783   unsigned int index( mIds[id] );
 784   mComponentDirty[ index ] = true;
 785   return mTxComponentAnimatable[ index ].mOrientation;
 786 }
 787
 788 const Quaternion& TransformManager::GetQuaternionPropertyValue( TransformId id ) const
 789 {
 790   return mTxComponentAnimatable[ mIds[id] ].mOrientation;
 791 }
 792
 793 void TransformManager::SetQuaternionPropertyValue( TransformId id, const Quaternion& q )
 794 {
 795   unsigned int index( mIds[id] );
 796   mTxComponentAnimatable[ index ].mOrientation = q;
 797   mComponentDirty[ index ] = true;
 798 }
 799
 800 void TransformManager::BakeQuaternionPropertyValue( TransformId id, const Quaternion& q )
 801 {
 802   unsigned int index( mIds[id] );
 803   mTxComponentAnimatable[ index ].mOrientation = mTxComponentAnimatableBaseValue[index].mOrientation = q;
 804   mComponentDirty[ index ] = true;
 805 }
 806
 807 void TransformManager::BakeRelativeQuaternionPropertyValue( TransformId id, const Quaternion& q )
 808 {
 809   unsigned int index( mIds[id] );
 810   mTxComponentAnimatable[ index ].mOrientation = mTxComponentAnimatableBaseValue[index].mOrientation = mTxComponentAnimatable[ index ].mOrientation * q;
 811   mComponentDirty[ index ] = true;
 812 }
 813
 814 } //namespace SceneGraph
 815 } //namespace Internal
 816 } //namespace Dali