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