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
 316   mIds[ mComponentId[i] ] = i;
 317   mIds[ mComponentId[j] ] = j;
 318 }
 319
 320 void TransformManager::ReorderComponents()
 321 {
 322   mOrderedComponents.Resize(mComponentCount);
 323
 324   TransformId parentId;
 325   for( size_t i(0); i<mComponentCount; ++i )
 326   {
 327     mOrderedComponents[i].id = mComponentId[i];
 328     mOrderedComponents[i].level = 0u;
 329
 330     parentId = mParent[i];
 331     while( parentId != INVALID_TRANSFORM_ID )
 332     {
 333       mOrderedComponents[i].level++;
 334       parentId = mParent[ mIds[parentId] ];
 335     }
 336   }
 337
 338   std::sort( mOrderedComponents.Begin(), mOrderedComponents.End());
 339   for( size_t i(0); i<mComponentCount-1; ++i )
 340   {
 341     SwapComponents( mIds[mOrderedComponents[i].id], i);
 342   }
 343 }
 344
 345 Vector3& TransformManager::GetVector3PropertyValue( TransformId id, TransformManagerProperty property )
 346 {
 347   switch( property )
 348   {
 349     case TRANSFORM_PROPERTY_POSITION:
 350     {
 351       unsigned int index( mIds[id] );
 352       mComponentDirty[ index ] = true;
 353       return mTxComponentAnimatable[ index ].mPosition;
 354     }
 355     case TRANSFORM_PROPERTY_SCALE:
 356     {
 357       unsigned int index( mIds[id] );
 358       mComponentDirty[ index ] = true;
 359       return mTxComponentAnimatable[ index ].mScale;
 360     }
 361     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 362     {
 363       unsigned int index( mIds[id] );
 364       mComponentDirty[ index ] = true;
 365       return mTxComponentStatic[ index ].mParentOrigin;
 366     }
 367     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 368     {
 369       unsigned int index( mIds[id] );
 370       mComponentDirty[ index ] = true;
 371       return mTxComponentStatic[ index ].mAnchorPoint;
 372     }
 373     case TRANSFORM_PROPERTY_SIZE:
 374     {
 375       unsigned int index( mIds[id] );
 376       mComponentDirty[ index ] = true;
 377       return mSize[ index ];
 378     }
 379     default:
 380     {
 381       DALI_ASSERT_ALWAYS(false);
 382       return mTxComponentAnimatable[ mIds[id] ].mPosition;
 383     }
 384   }
 385 }
 386
 387 const Vector3& TransformManager::GetVector3PropertyValue( TransformId id, TransformManagerProperty property ) const
 388 {
 389   switch( property )
 390   {
 391     case TRANSFORM_PROPERTY_POSITION:
 392     {
 393       return mTxComponentAnimatable[ mIds[id] ].mPosition;
 394     }
 395     case TRANSFORM_PROPERTY_SCALE:
 396     {
 397       return mTxComponentAnimatable[ mIds[id] ].mScale;
 398     }
 399     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 400     {
 401       return mTxComponentStatic[ mIds[id] ].mParentOrigin;
 402     }
 403     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 404     {
 405       return mTxComponentStatic[ mIds[id] ].mAnchorPoint;
 406     }
 407     case TRANSFORM_PROPERTY_SIZE:
 408     {
 409       return mSize[ mIds[id] ];
 410     }
 411     default:
 412     {
 413       DALI_ASSERT_ALWAYS(false);
 414       return mTxComponentAnimatable[ mIds[id] ].mPosition;
 415     }
 416   }
 417 }
 418
 419 const float& TransformManager::GetVector3PropertyComponentValue(TransformId id, TransformManagerProperty property, unsigned int component ) const
 420 {
 421   switch( property )
 422   {
 423     case TRANSFORM_PROPERTY_POSITION:
 424     {
 425       return mTxComponentAnimatable[ mIds[id] ].mPosition[component];
 426     }
 427     case TRANSFORM_PROPERTY_SCALE:
 428     {
 429       return mTxComponentAnimatable[ mIds[id] ].mScale[component];
 430     }
 431     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 432     {
 433       return mTxComponentStatic[ mIds[id] ].mParentOrigin[component];
 434     }
 435     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 436     {
 437       return mTxComponentStatic[ mIds[id] ].mAnchorPoint[component];
 438     }
 439     case TRANSFORM_PROPERTY_SIZE:
 440     {
 441       return mSize[ mIds[id] ][component];
 442     }
 443     default:
 444     {
 445       DALI_ASSERT_ALWAYS(false);
 446       return mTxComponentAnimatable[ mIds[id] ].mPosition[component];
 447     }
 448   }
 449 }
 450
 451 void TransformManager::SetVector3PropertyValue( TransformId id, TransformManagerProperty property, const Vector3& value )
 452 {
 453   unsigned int index( mIds[id] );
 454   mComponentDirty[ index ] = true;
 455
 456   switch( property )
 457   {
 458     case TRANSFORM_PROPERTY_POSITION:
 459     {
 460       mTxComponentAnimatable[ index ].mPosition = value;
 461       break;
 462     }
 463     case TRANSFORM_PROPERTY_SCALE:
 464     {
 465       mTxComponentAnimatable[ index ].mScale = value;
 466       break;
 467     }
 468     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 469     {
 470       mTxComponentStatic[ index ].mParentOrigin = value;
 471       break;
 472     }
 473     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 474     {
 475       mTxComponentStatic[ index ].mAnchorPoint = value;
 476       break;
 477     }
 478     case TRANSFORM_PROPERTY_SIZE:
 479     {
 480       mSize[ index ] = value;
 481       break;
 482     }
 483     default:
 484     {
 485       DALI_ASSERT_ALWAYS(false);
 486     }
 487   }
 488 }
 489
 490 void TransformManager::SetVector3PropertyComponentValue( TransformId id, TransformManagerProperty property, float value, unsigned int component )
 491 {
 492   unsigned int index( mIds[id] );
 493   mComponentDirty[ index ] = true;
 494
 495   switch( property )
 496   {
 497     case TRANSFORM_PROPERTY_POSITION:
 498     {
 499       mTxComponentAnimatable[ index ].mPosition[component] = value;
 500       break;
 501     }
 502     case TRANSFORM_PROPERTY_SCALE:
 503     {
 504       mTxComponentAnimatable[ index ].mScale[component] = value;
 505       break;
 506     }
 507     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 508     {
 509       mTxComponentStatic[ index ].mParentOrigin[component] = value;
 510       break;
 511     }
 512     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 513     {
 514       mTxComponentStatic[ index ].mAnchorPoint[component] = value;
 515       break;
 516     }
 517     case TRANSFORM_PROPERTY_SIZE:
 518     {
 519       mSize[ index ][component] = value;
 520       break;
 521     }
 522     default:
 523     {
 524       DALI_ASSERT_ALWAYS(false);
 525     }
 526   }
 527 }
 528
 529 void TransformManager::BakeVector3PropertyValue( TransformId id, TransformManagerProperty property, const Vector3& value )
 530 {
 531   unsigned int index( mIds[id] );
 532   mComponentDirty[ index ] = true;
 533
 534   switch( property )
 535   {
 536     case TRANSFORM_PROPERTY_POSITION:
 537     {
 538       mTxComponentAnimatable[ index ].mPosition = mTxComponentAnimatableBaseValue[index].mPosition = value;
 539       break;
 540     }
 541     case TRANSFORM_PROPERTY_SCALE:
 542     {
 543       mTxComponentAnimatable[ index ].mScale = mTxComponentAnimatableBaseValue[index].mScale = value;
 544       break;
 545     }
 546     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 547     {
 548       mTxComponentStatic[ index ].mParentOrigin = value;
 549       break;
 550     }
 551     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 552     {
 553       mTxComponentStatic[ index ].mAnchorPoint = value;
 554       break;
 555     }
 556     case TRANSFORM_PROPERTY_SIZE:
 557     {
 558       mSize[ index ] = mSizeBase[index] = value;
 559       break;
 560     }
 561     default:
 562     {
 563       DALI_ASSERT_ALWAYS(false);
 564     }
 565   }
 566 }
 567
 568 void TransformManager::BakeRelativeVector3PropertyValue( TransformId id, TransformManagerProperty property, const Vector3& value )
 569 {
 570   unsigned int index( mIds[id] );
 571   mComponentDirty[ index ] = true;
 572
 573   switch( property )
 574   {
 575     case TRANSFORM_PROPERTY_POSITION:
 576     {
 577       mTxComponentAnimatable[ index ].mPosition = mTxComponentAnimatableBaseValue[index].mPosition = mTxComponentAnimatable[ index ].mPosition + value;
 578       break;
 579     }
 580     case TRANSFORM_PROPERTY_SCALE:
 581     {
 582       mTxComponentAnimatable[ index ].mScale = mTxComponentAnimatableBaseValue[index].mScale = mTxComponentAnimatable[ index ].mScale + value;
 583       break;
 584     }
 585     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 586     {
 587       mTxComponentStatic[ index ].mParentOrigin = mTxComponentStatic[ index ].mParentOrigin + value;
 588       break;
 589     }
 590     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 591     {
 592       mTxComponentStatic[ index ].mAnchorPoint = mTxComponentStatic[ index ].mAnchorPoint + value;
 593       break;
 594     }
 595     case TRANSFORM_PROPERTY_SIZE:
 596     {
 597       mSize[ index ] = mSizeBase[index] = mSize[ index ] + value;
 598       break;
 599     }
 600     default:
 601     {
 602       DALI_ASSERT_ALWAYS(false);
 603     }
 604   }
 605 }
 606
 607 void TransformManager::BakeMultiplyVector3PropertyValue( TransformId id, TransformManagerProperty property, const Vector3& value )
 608 {
 609   unsigned int index( mIds[id] );
 610   mComponentDirty[ index ] = true;
 611
 612   switch( property )
 613   {
 614     case TRANSFORM_PROPERTY_POSITION:
 615     {
 616       mTxComponentAnimatable[ index ].mPosition = mTxComponentAnimatableBaseValue[index].mPosition = mTxComponentAnimatable[ index ].mPosition * value;
 617       break;
 618     }
 619     case TRANSFORM_PROPERTY_SCALE:
 620     {
 621       mTxComponentAnimatable[ index ].mScale = mTxComponentAnimatableBaseValue[index].mScale = mTxComponentAnimatable[ index ].mScale * value;
 622       break;
 623     }
 624     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 625     {
 626       mTxComponentStatic[ index ].mParentOrigin = mTxComponentStatic[ index ].mParentOrigin * value;
 627       break;
 628     }
 629     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 630     {
 631       mTxComponentStatic[ index ].mAnchorPoint = mTxComponentStatic[ index ].mAnchorPoint * value;
 632       break;
 633     }
 634     case TRANSFORM_PROPERTY_SIZE:
 635     {
 636       mSize[ index ] = mSizeBase[index] = mSize[ index ] * value;
 637       break;
 638     }
 639     default:
 640     {
 641       DALI_ASSERT_ALWAYS(false);
 642     }
 643   }
 644 }
 645
 646 void TransformManager::BakeVector3PropertyComponentValue( TransformId id, TransformManagerProperty property, float value, unsigned int component )
 647 {
 648   unsigned int index( mIds[id] );
 649   mComponentDirty[ index ] = true;
 650
 651   switch( property )
 652   {
 653     case TRANSFORM_PROPERTY_POSITION:
 654     {
 655       mTxComponentAnimatable[ index ].mPosition[component] = mTxComponentAnimatableBaseValue[index].mPosition[component] = value;
 656       break;
 657     }
 658     case TRANSFORM_PROPERTY_SCALE:
 659     {
 660       mTxComponentAnimatable[ index ].mScale[component] = mTxComponentAnimatableBaseValue[index].mScale[component] = value;
 661       break;
 662     }
 663     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 664     {
 665       mTxComponentStatic[ index ].mParentOrigin[component] = value;
 666       break;
 667     }
 668     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 669     {
 670       mTxComponentStatic[ index ].mAnchorPoint[component] = value;
 671       break;
 672     }
 673     case TRANSFORM_PROPERTY_SIZE:
 674     {
 675       mSize[ index ][component] = mSizeBase[index][component] = value;
 676       break;
 677     }
 678     default:
 679     {
 680       DALI_ASSERT_ALWAYS(false);
 681     }
 682   }
 683 }
 684
 685 void TransformManager::BakeXVector3PropertyValue( TransformId id, TransformManagerProperty property, float value )
 686 {
 687   unsigned int index( mIds[id] );
 688   mComponentDirty[ index ] = true;
 689
 690   switch( property )
 691   {
 692     case TRANSFORM_PROPERTY_POSITION:
 693     {
 694       mTxComponentAnimatable[ index ].mPosition.x = mTxComponentAnimatableBaseValue[index].mPosition.x = value;
 695       break;
 696     }
 697     case TRANSFORM_PROPERTY_SCALE:
 698     {
 699       mTxComponentAnimatable[ index ].mScale.x = mTxComponentAnimatableBaseValue[index].mScale.x = value;
 700       break;
 701     }
 702     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 703     {
 704       mTxComponentStatic[ index ].mParentOrigin.x = value;
 705       break;
 706     }
 707     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 708     {
 709       mTxComponentStatic[ index ].mAnchorPoint.x = value;
 710       break;
 711     }
 712     case TRANSFORM_PROPERTY_SIZE:
 713     {
 714       mSize[ index ].x = mSizeBase[index].x = value;
 715       break;
 716     }
 717     default:
 718     {
 719       DALI_ASSERT_ALWAYS(false);
 720     }
 721   }
 722 }
 723
 724 void TransformManager::BakeYVector3PropertyValue( TransformId id, TransformManagerProperty property, float value )
 725 {
 726   unsigned int index( mIds[id] );
 727   mComponentDirty[ index ] = true;
 728
 729   switch( property )
 730   {
 731     case TRANSFORM_PROPERTY_POSITION:
 732     {
 733       mTxComponentAnimatable[ index ].mPosition.y = mTxComponentAnimatableBaseValue[index].mPosition.y = value;
 734       break;
 735     }
 736     case TRANSFORM_PROPERTY_SCALE:
 737     {
 738       mTxComponentAnimatable[ index ].mScale.y = mTxComponentAnimatableBaseValue[index].mScale.y = value;
 739       break;
 740     }
 741     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 742     {
 743       mTxComponentStatic[ index ].mParentOrigin.y = value;
 744       break;
 745     }
 746     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 747     {
 748       mTxComponentStatic[ index ].mAnchorPoint.y = value;
 749       break;
 750     }
 751     case TRANSFORM_PROPERTY_SIZE:
 752     {
 753       mSize[ index ].y = mSizeBase[index].y = value;
 754       break;
 755     }
 756     default:
 757     {
 758       DALI_ASSERT_ALWAYS(false);
 759     }
 760   }
 761 }
 762
 763 void TransformManager::BakeZVector3PropertyValue( TransformId id, TransformManagerProperty property, float value )
 764 {
 765   unsigned int index( mIds[id] );
 766   mComponentDirty[ index ] = true;
 767
 768   switch( property )
 769   {
 770     case TRANSFORM_PROPERTY_POSITION:
 771     {
 772       mTxComponentAnimatable[ index ].mPosition.z = mTxComponentAnimatableBaseValue[index].mPosition.z = value;
 773       break;
 774     }
 775     case TRANSFORM_PROPERTY_SCALE:
 776     {
 777       mTxComponentAnimatable[ index ].mScale.z = mTxComponentAnimatableBaseValue[index].mScale.z = value;
 778       break;
 779     }
 780     case TRANSFORM_PROPERTY_PARENT_ORIGIN:
 781     {
 782       mTxComponentStatic[ index ].mParentOrigin.z = value;
 783       break;
 784     }
 785     case TRANSFORM_PROPERTY_ANCHOR_POINT:
 786     {
 787       mTxComponentStatic[ index ].mAnchorPoint.z = value;
 788       break;
 789     }
 790     case TRANSFORM_PROPERTY_SIZE:
 791     {
 792       mSize[ index ].z = mSizeBase[index].z = value;
 793       break;
 794     }
 795     default:
 796     {
 797       DALI_ASSERT_ALWAYS(false);
 798     }
 799   }
 800 }
 801
 802 Quaternion& TransformManager::GetQuaternionPropertyValue( TransformId id )
 803 {
 804   unsigned int index( mIds[id] );
 805   mComponentDirty[ index ] = true;
 806   return mTxComponentAnimatable[ index ].mOrientation;
 807 }
 808
 809 const Quaternion& TransformManager::GetQuaternionPropertyValue( TransformId id ) const
 810 {
 811   return mTxComponentAnimatable[ mIds[id] ].mOrientation;
 812 }
 813
 814 void TransformManager::SetQuaternionPropertyValue( TransformId id, const Quaternion& q )
 815 {
 816   unsigned int index( mIds[id] );
 817   mTxComponentAnimatable[ index ].mOrientation = q;
 818   mComponentDirty[ index ] = true;
 819 }
 820
 821 void TransformManager::BakeQuaternionPropertyValue( TransformId id, const Quaternion& q )
 822 {
 823   unsigned int index( mIds[id] );
 824   mTxComponentAnimatable[ index ].mOrientation = mTxComponentAnimatableBaseValue[index].mOrientation = q;
 825   mComponentDirty[ index ] = true;
 826 }
 827
 828 void TransformManager::BakeRelativeQuaternionPropertyValue( TransformId id, const Quaternion& q )
 829 {
 830   unsigned int index( mIds[id] );
 831   mTxComponentAnimatable[ index ].mOrientation = mTxComponentAnimatableBaseValue[index].mOrientation = mTxComponentAnimatable[ index ].mOrientation * q;
 832   mComponentDirty[ index ] = true;
 833 }
 834
 835 const Vector4& TransformManager::GetBoundingSphere( TransformId id ) const
 836 {
 837   return mBoundingSpheres[ mIds[id] ];
 838 }
 839
 840 void TransformManager::GetWorldMatrixAndSize( TransformId id, Matrix& worldMatrix, Vector3& size ) const
 841 {
 842   unsigned int index = mIds[id];
 843   worldMatrix = mWorld[index];
 844   size = mSize[index];
 845 }
 846
 847 } //namespace SceneGraph
 848 } //namespace Internal
 849 } //namespace Dali