[Tizen] (FrameCallback) All values now local & baking of the value supported

- Callback now called before world matrix is calculated so removed the world matrix methods
  (as they will be a frame behind now)
- All values now in local actor space.
- Scale added.
- Added bake methods to save the values if required.

Change-Id: I76318fcf77c0ae6e7a217ee9169db71aeda9aa75

diff --git a/automated-tests/src/dali/utc-Dali-FrameCallbackInterface.cpp b/automated-tests/src/dali/utc-Dali-FrameCallbackInterface.cpp
index 0a3afb2..694cb43 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-FrameCallbackInterface.cpp
+++ b/automated-tests/src/dali/utc-Dali-FrameCallbackInterface.cpp
@@ -72,24 +72,21 @@ public:
   virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds )
   {
     FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
-    updateProxy.GetWorldMatrixAndSize( mActorId, mWorldMatrix, mSize );
-    mWorldMatrixGetWorldMatrixCall = updateProxy.GetWorldMatrix( mActorId );
     mSizeGetSizeCall = updateProxy.GetSize( mActorId );
     mPositionGetPositionCall = updateProxy.GetPosition( mActorId );
     updateProxy.GetPositionAndSize( mActorId, mPositionGetPositionAndSizeCall, mSizeGetPositionAndSizeCall );
-    mWorldColor = updateProxy.GetWorldColor( mActorId );
+    mColor = updateProxy.GetColor( mActorId );
+    mScale = updateProxy.GetScale( mActorId );
   }
 
   const unsigned int mActorId;
 
-  Matrix mWorldMatrix;
-  Matrix mWorldMatrixGetWorldMatrixCall;
-  Vector3 mSize;
   Vector3 mSizeGetSizeCall;
   Vector3 mPositionGetPositionCall;
   Vector3 mPositionGetPositionAndSizeCall;
   Vector3 mSizeGetPositionAndSizeCall;
-  Vector4 mWorldColor;
+  Vector4 mColor;
+  Vector3 mScale;
 };
 
 class FrameCallbackSetter : public FrameCallbackBasic
@@ -98,42 +95,87 @@ public:
 
   FrameCallbackSetter(
       unsigned int actorId,
-      const Matrix& matrixToSet,
       const Vector3& sizeToSet,
       const Vector3& positionToSet,
-      const Vector4& colorToSet )
+      const Vector4& colorToSet,
+      const Vector3& scaleToSet )
   : mActorId( actorId ),
-    mMatrixToSet( matrixToSet ),
     mSizeToSet( sizeToSet ),
     mPositionToSet( positionToSet ),
-    mColorToSet( colorToSet )
+    mColorToSet( colorToSet ),
+    mScaleToSet( scaleToSet )
   {
   }
 
   virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds )
   {
     FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
-    updateProxy.SetWorldMatrix( mActorId, mMatrixToSet );
     updateProxy.SetSize( mActorId, mSizeToSet );
-    updateProxy.GetWorldMatrixAndSize( mActorId, mWorldMatrixAfterSetting, mSizeAfterSetting );
     updateProxy.SetPosition( mActorId, mPositionToSet );
+    updateProxy.SetColor( mActorId, mColorToSet );
+    updateProxy.SetScale( mActorId, mScaleToSet );
+    mSizeAfterSetting = updateProxy.GetSize( mActorId );
     mPositionAfterSetting = updateProxy.GetPosition( mActorId );
-    updateProxy.SetWorldColor( mActorId, mColorToSet );
-    mColorAfterSetting = updateProxy.GetWorldColor( mActorId );
+    mColorAfterSetting = updateProxy.GetColor( mActorId );
+    mScaleAfterSetting = updateProxy.GetScale( mActorId );
   }
 
   const unsigned int mActorId;
-  const Matrix& mMatrixToSet;
   const Vector3& mSizeToSet;
   const Vector3& mPositionToSet;
   const Vector4& mColorToSet;
+  const Vector3& mScaleToSet;
 
-  Matrix mWorldMatrixAfterSetting;
   Vector3 mSizeAfterSetting;
   Vector3 mPositionAfterSetting;
   Vector4 mColorAfterSetting;
+  Vector3 mScaleAfterSetting;
 };
 
+class FrameCallbackBaker : public FrameCallbackBasic
+{
+public:
+
+  FrameCallbackBaker(
+      unsigned int actorId,
+      const Vector3& sizeToSet,
+      const Vector3& positionToSet,
+      const Vector4& colorToSet,
+      const Vector3& scaleToSet )
+  : mActorId( actorId ),
+    mSizeToSet( sizeToSet ),
+    mPositionToSet( positionToSet ),
+    mColorToSet( colorToSet ),
+    mScaleToSet( scaleToSet )
+  {
+  }
+
+  virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds )
+  {
+    FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
+    updateProxy.BakeSize( mActorId, mSizeToSet );
+    updateProxy.BakePosition( mActorId, mPositionToSet );
+    updateProxy.BakeColor( mActorId, mColorToSet );
+    updateProxy.BakeScale( mActorId, mScaleToSet );
+    mSizeAfterSetting = updateProxy.GetSize( mActorId );
+    mPositionAfterSetting = updateProxy.GetPosition( mActorId );
+    mColorAfterSetting = updateProxy.GetColor( mActorId );
+    mScaleAfterSetting = updateProxy.GetScale( mActorId );
+  }
+
+  const unsigned int mActorId;
+  const Vector3& mSizeToSet;
+  const Vector3& mPositionToSet;
+  const Vector4& mColorToSet;
+  const Vector3& mScaleToSet;
+
+  Vector3 mSizeAfterSetting;
+  Vector3 mPositionAfterSetting;
+  Vector4 mColorAfterSetting;
+  Vector3 mScaleAfterSetting;
+};
+
+
 class FrameCallbackMultipleActors : public FrameCallbackBasic
 {
 public:
@@ -147,17 +189,17 @@ public:
     FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
     for( auto&& i : mActorIds )
     {
-      Matrix matrix( false );
+      Vector3 position;
       Vector3 size;
-      updateProxy.GetWorldMatrixAndSize( i, matrix, size );
-      mWorldMatrices[ i ] = matrix;
+      updateProxy.GetPositionAndSize( i, position, size );
+      mPositions[ i ] = position;
       mSizes[ i ] = size;
     }
   }
 
   Vector< unsigned int > mActorIds;
 
-  std::map< unsigned int, Matrix > mWorldMatrices;
+  std::map< unsigned int, Vector3 > mPositions;
   std::map< unsigned int, Vector3 > mSizes;
 };
 
@@ -195,6 +237,7 @@ int UtcDaliFrameCallbackGetters(void)
   Vector2 actorSize( 200, 300 );
   Vector4 color( 0.5f, 0.6f, 0.7f, 0.8f );
   Vector3 position( 10.0f, 20.0f, 30.0f );
+  Vector3 scale( 2.0f, 4.0f, 6.0f );
 
   Actor actor = Actor::New();
   actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
@@ -202,10 +245,10 @@ int UtcDaliFrameCallbackGetters(void)
   actor.SetSize( actorSize );
   actor.SetColor( color );
   actor.SetPosition( position );
+  actor.SetScale( scale );
 
   Stage stage = Stage::GetCurrent();
   stage.Add( actor );
-  Vector2 stageSize = stage.GetSize();
 
   FrameCallbackOneActor frameCallback( actor.GetId() );
   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
@@ -213,23 +256,13 @@ int UtcDaliFrameCallbackGetters(void)
   application.SendNotification();
   application.Render();
 
-  Vector3 expectedPosition( -stageSize.width * 0.5f + actorSize.width * 0.5f + position.x,
-                            -stageSize.height * 0.5f + actorSize.height * 0.5f + position.y,
-                            0.0f + position.z );
-
-  Matrix expectedWorldMatrix( false );
-  expectedWorldMatrix.SetIdentity();
-  expectedWorldMatrix.SetTranslation( expectedPosition );
-
   DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mWorldMatrix, expectedWorldMatrix, TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mWorldMatrixGetWorldMatrixCall, expectedWorldMatrix, TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mSize, Vector3( actorSize.width, actorSize.height, 0.0f ), TEST_LOCATION );
   DALI_TEST_EQUALS( frameCallback.mSizeGetSizeCall, Vector3( actorSize.width, actorSize.height, 0.0f ), TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mPositionGetPositionCall, expectedPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mPositionGetPositionAndSizeCall, expectedPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mPositionGetPositionCall, position, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mPositionGetPositionAndSizeCall, position, TEST_LOCATION );
   DALI_TEST_EQUALS( frameCallback.mSizeGetPositionAndSizeCall, Vector3( actorSize.width, actorSize.height, 0.0f ), TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mWorldColor, color, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mColor, color, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mScale, scale, TEST_LOCATION );
 
   END_TEST;
 }
@@ -246,36 +279,83 @@ int UtcDaliFrameCallbackSetters(void)
 
   Stage stage = Stage::GetCurrent();
   stage.Add( actor );
-  Vector2 stageSize = stage.GetSize();
 
-  Matrix matrixToSet( Matrix::IDENTITY );
-  matrixToSet.SetTranslation( Vector3( 100.0f, 500.0f, 50.0f ) );
   Vector3 sizeToSet( 1.0f, 2.0f, 3.0f );
   Vector3 positionToSet( 10.0f, 20.0f, 30.0f );
   Vector4 colorToSet( Color::MAGENTA );
+  Vector3 scaleToSet( 1.0f, 3.0f, 5.0f );
 
-  FrameCallbackSetter frameCallback( actor.GetId(), matrixToSet, sizeToSet, positionToSet, colorToSet );
+  FrameCallbackSetter frameCallback( actor.GetId(), sizeToSet, positionToSet, colorToSet, scaleToSet );
   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
 
   application.SendNotification();
   application.Render();
 
-  Matrix expectedWorldMatrix( false );
-  expectedWorldMatrix.SetIdentity();
-  expectedWorldMatrix.SetTranslation( Vector3( -stageSize.width * 0.5f + actorSize.width * 0.5f,
-                                               -stageSize.height * 0.5f + actorSize.height * 0.5f,
-                                               0.0f ) );
+  DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mSizeAfterSetting, sizeToSet, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mPositionAfterSetting, positionToSet, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mColorAfterSetting, colorToSet, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mScaleAfterSetting, scaleToSet, TEST_LOCATION );
+
+  // Ensure the actual actor values haven't changed as we didn't bake the values after removing the callback
+  DevelStage::RemoveFrameCallback( stage, frameCallback );
+
+  application.SendNotification();
+  application.Render();
+
+  DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), Vector3::ZERO, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >(), Vector3( actorSize ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::COLOR ).Get< Vector4 >(), Color::WHITE, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SCALE ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliFrameCallbackBake(void)
+{
+  TestApplication application;
+  Vector2 actorSize( 200, 300 );
+
+  Actor actor = Actor::New();
+  actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
+  actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  actor.SetSize( actorSize );
+
+  Stage stage = Stage::GetCurrent();
+  stage.Add( actor );
+
+  Vector3 sizeToSet( 1.0f, 2.0f, 3.0f );
+  Vector3 positionToSet( 10.0f, 20.0f, 30.0f );
+  Vector4 colorToSet( Color::MAGENTA );
+  Vector3 scaleToSet( 1.0f, 3.0f, 5.0f );
+
+  FrameCallbackBaker frameCallback( actor.GetId(), sizeToSet, positionToSet, colorToSet, scaleToSet );
+  DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
+
+  application.SendNotification();
+  application.Render();
 
   DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
-  DALI_TEST_CHECK( expectedWorldMatrix != matrixToSet );
-  DALI_TEST_EQUALS( frameCallback.mWorldMatrixAfterSetting, matrixToSet, TEST_LOCATION );
   DALI_TEST_EQUALS( frameCallback.mSizeAfterSetting, sizeToSet, TEST_LOCATION );
   DALI_TEST_EQUALS( frameCallback.mPositionAfterSetting, positionToSet, TEST_LOCATION );
   DALI_TEST_EQUALS( frameCallback.mColorAfterSetting, colorToSet, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mScaleAfterSetting, scaleToSet, TEST_LOCATION );
+
+  // Ensure the new values are saved after removing the callback
+  DevelStage::RemoveFrameCallback( stage, frameCallback );
+
+  application.SendNotification();
+  application.Render();
+
+  DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), positionToSet, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >(), sizeToSet, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::COLOR ).Get< Vector4 >(), colorToSet, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SCALE ).Get< Vector3 >(), scaleToSet, TEST_LOCATION );
 
   END_TEST;
 }
 
+
 int UtcDaliFrameCallbackMultipleActors(void)
 {
   /**
@@ -292,7 +372,7 @@ int UtcDaliFrameCallbackMultipleActors(void)
    *      /                        \
    *   actorC                     actorH
    *
-   *  Screen positions:
+   *  Screen positions (with minor alterations due to local position):
    *  -----------------------
    *  |actorA|actorD        |
    *  |      actorB         |
@@ -309,7 +389,6 @@ int UtcDaliFrameCallbackMultipleActors(void)
 
   TestApplication application;
   Stage stage = Stage::GetCurrent();
-  const Vector2 stageSize = stage.GetSize();
 
   std::map< char, Vector3 > sizes;
   sizes['A'] = Vector3(  50.0f,  50.0f, 0.0f );
@@ -321,81 +400,70 @@ int UtcDaliFrameCallbackMultipleActors(void)
   sizes['G'] = Vector3( 350.0f, 350.0f, 0.0f );
   sizes['H'] = Vector3( 400.0f, 350.0f, 0.0f );
 
-  std::map< char, Matrix > matrices;
-  for( char i = 'A'; i <= 'H'; ++i )
-  {
-    matrices[i] = Matrix::IDENTITY;
-  }
-
-  matrices['A'].SetTranslation( Vector3( -stageSize.width * 0.5f + sizes['A'].width * 0.5f,
-                                         -stageSize.height * 0.5f + sizes['A'].height * 0.5f,
-                                         0.0f ) );
-  matrices['B'].SetTranslation( Vector3( matrices['A'].GetTranslation3() + sizes['A'] * 0.5f + sizes['B'] * 0.5f ) );
-  matrices['C'].SetTranslation( Vector3( matrices['B'].GetTranslation3().x,
-                                         matrices['B'].GetTranslation3().y + sizes['B'].height * 0.5f + sizes['C'].height * 0.5f,
-                                         0.0f ) );
-  matrices['D'].SetTranslation( Vector3( matrices['A'].GetTranslation3().x + sizes['A'].width * 0.5f + sizes['D'].width * 0.5f,
-                                         matrices['A'].GetTranslation3().y,
-                                         0.0f ) );
-  matrices['E'].SetTranslation( Vector3( -stageSize.width * 0.5f + sizes['E'].width * 0.5f,
-                                         stageSize.height * 0.5f - sizes['E'].height * 0.5f,
-                                         0.0f ) );
-  matrices['F'].SetTranslation( Vector3( matrices['E'].GetTranslation3().x,
-                                         matrices['E'].GetTranslation3().y - sizes['E'].height * 0.5f - sizes['F'].height * 0.5f,
-                                         0.0f ) );
-  matrices['G'].SetTranslation( Vector3( matrices['E'].GetTranslation3().x + sizes['E'].width * 0.5f + sizes['G'].width * 0.5f,
-                                         matrices['E'].GetTranslation3().y,
-                                         0.0f ) );
-  matrices['H'].SetTranslation( Vector3( matrices['G'].GetTranslation3().x + sizes['G'].width * 0.5f + sizes['H'].width * 0.5f,
-                                         matrices['G'].GetTranslation3().y - sizes['G'].height * 0.5f - sizes['H'].height * 0.5f,
-                                         0.0f ) );
+  std::map< char, Vector3 > positions;
+  positions['A'] = Vector3(  0.0f,  1.0f,  2.0f );
+  positions['B'] = Vector3(  2.0f,  3.0f,  4.0f );
+  positions['C'] = Vector3(  5.0f,  6.0f,  7.0f );
+  positions['D'] = Vector3(  8.0f,  9.0f, 10.0f );
+  positions['E'] = Vector3( 11.0f, 12.0f, 13.0f );
+  positions['F'] = Vector3( 14.0f, 15.0f, 16.0f );
+  positions['G'] = Vector3( 17.0f, 18.0f, 19.0f );
+  positions['H'] = Vector3( 20.0f, 21.0f, 22.0f );
 
   Actor actorA = Actor::New();
   actorA.SetParentOrigin( ParentOrigin::TOP_LEFT );
   actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
   actorA.SetSize( sizes['A'] );
+  actorA.SetPosition( positions['A'] );
   stage.Add( actorA );
 
   Actor actorB = Actor::New();
   actorB.SetParentOrigin( ParentOrigin::BOTTOM_RIGHT );
   actorB.SetAnchorPoint( AnchorPoint::TOP_LEFT );
   actorB.SetSize( sizes['B'] );
+  actorB.SetPosition( positions['B'] );
   actorA.Add( actorB );
 
   Actor actorC = Actor::New();
   actorC.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
   actorC.SetAnchorPoint( AnchorPoint::TOP_CENTER );
   actorC.SetSize( sizes['C'] );
+  actorC.SetPosition( positions['C'] );
   actorB.Add( actorC );
 
   Actor actorD = Actor::New();
   actorD.SetParentOrigin( ParentOrigin::CENTER_RIGHT );
   actorD.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
   actorD.SetSize( sizes['D'] );
+  actorD.SetPosition( positions['D'] );
   actorA.Add( actorD );
 
   Actor actorE = Actor::New();
   actorE.SetParentOrigin( ParentOrigin::BOTTOM_LEFT );
   actorE.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
   actorE.SetSize( sizes['E'] );
+  actorE.SetPosition( positions['E'] );
   stage.Add( actorE );
 
   Actor actorF = Actor::New();
   actorF.SetParentOrigin( ParentOrigin::TOP_CENTER );
   actorF.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
   actorF.SetSize( sizes['F'] );
+  actorF.SetPosition( positions['F'] );
   actorE.Add( actorF );
 
   Actor actorG = Actor::New();
   actorG.SetParentOrigin( ParentOrigin::CENTER_RIGHT );
   actorG.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
   actorG.SetSize( sizes['G'] );
+  actorG.SetPosition( positions['G'] );
   actorE.Add( actorG );
 
   Actor actorH = Actor::New();
   actorH.SetParentOrigin( ParentOrigin::TOP_RIGHT );
   actorH.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
   actorH.SetSize( sizes['H'] );
+  actorH.SetPosition( positions['H'] );
   actorG.Add( actorH );
 
   std::map< char, unsigned int > actorIds;
@@ -423,7 +491,7 @@ int UtcDaliFrameCallbackMultipleActors(void)
 
   for( char i = 'A'; i <= 'H'; ++i )
   {
-    DALI_TEST_EQUALS( frameCallback.mWorldMatrices[ actorIds[ i ] ], matrices[ i ], TEST_LOCATION );
+    DALI_TEST_EQUALS( frameCallback.mPositions[ actorIds[ i ] ], positions[ i ], TEST_LOCATION );
     DALI_TEST_EQUALS( frameCallback.mSizes[ actorIds[ i ] ], sizes[ i ], TEST_LOCATION );
   }
 
@@ -437,7 +505,7 @@ int UtcDaliFrameCallbackMultipleActors(void)
 
   for( char i = 'A'; i <= 'H'; ++i )
   {
-    DALI_TEST_EQUALS( frameCallback.mWorldMatrices[ actorIds[ i ] ], matrices[ i ], TEST_LOCATION );
+    DALI_TEST_EQUALS( frameCallback.mPositions[ actorIds[ i ] ], positions[ i ], TEST_LOCATION );
     DALI_TEST_EQUALS( frameCallback.mSizes[ actorIds[ i ] ], sizes[ i ], TEST_LOCATION );
   }
 
@@ -460,11 +528,12 @@ int UtcDaliFrameCallbackCheckActorNotAdded(void)
   application.SendNotification();
   application.Render();
 
+  // All should be default constructed objects
   DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mWorldMatrix, Matrix(true) /* Unchanged Matrix */, TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mWorldMatrixGetWorldMatrixCall, Matrix::IDENTITY, TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mSize, Vector3::ZERO, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mPositionGetPositionCall, Vector3::ZERO, TEST_LOCATION );
   DALI_TEST_EQUALS( frameCallback.mSizeGetSizeCall, Vector3::ZERO, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mColor, Vector4::ZERO, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mScale, Vector3::ZERO, TEST_LOCATION );
 
   END_TEST;
 }

diff --git a/dali/devel-api/update/update-proxy.cpp b/dali/devel-api/update/update-proxy.cpp
index 67511b4..f336106 100644 (file)
--- a/dali/devel-api/update/update-proxy.cpp
+++ b/dali/devel-api/update/update-proxy.cpp
@@ -34,6 +34,11 @@ void UpdateProxy::SetPosition( unsigned int id, const Vector3& position )
   mImpl.SetPosition( id, position );
 }
 
+void UpdateProxy::BakePosition( unsigned int id, const Vector3& position )
+{
+  mImpl.BakePosition( id, position );
+}
+
 const Vector3& UpdateProxy::GetSize( unsigned int id ) const
 {
   return mImpl.GetSize( id );
@@ -44,34 +49,44 @@ void UpdateProxy::SetSize( unsigned int id, const Vector3& size )
   mImpl.SetSize( id, size );
 }
 
+void UpdateProxy::BakeSize( unsigned int id, const Vector3& size )
+{
+  mImpl.BakeSize( id, size );
+}
+
 void UpdateProxy::GetPositionAndSize( unsigned int id, Vector3& position, Vector3& size ) const
 {
   mImpl.GetPositionAndSize( id, position, size );
 }
 
-Vector4 UpdateProxy::GetWorldColor( unsigned int id ) const
+Vector3 UpdateProxy::GetScale( unsigned int id ) const
+{
+  return mImpl.GetScale( id );
+}
+
+void UpdateProxy::SetScale( unsigned int id, const Vector3& scale )
 {
-  return mImpl.GetWorldColor( id );
+  mImpl.SetScale( id, scale );
 }
 
-void UpdateProxy::SetWorldColor( unsigned int id, const Vector4& color ) const
+void UpdateProxy::BakeScale( unsigned int id, const Vector3& scale )
 {
-  mImpl.SetWorldColor( id, color );
+  mImpl.BakeScale( id, scale );
 }
 
-void UpdateProxy::GetWorldMatrixAndSize( unsigned int id, Matrix& worldMatrix, Vector3& size ) const
+Vector4 UpdateProxy::GetColor( unsigned int id ) const
 {
-  mImpl.GetWorldMatrixAndSize( id, worldMatrix, size );
+  return mImpl.GetColor( id );
 }
 
-const Matrix& UpdateProxy::GetWorldMatrix( unsigned int id ) const
+void UpdateProxy::SetColor( unsigned int id, const Vector4& color ) const
 {
-  return mImpl.GetWorldMatrix( id );
+  mImpl.SetColor( id, color );
 }
 
-void UpdateProxy::SetWorldMatrix( unsigned int id, const Matrix& worldMatrix )
+void UpdateProxy::BakeColor( unsigned int id, const Vector4& color ) const
 {
-  mImpl.SetWorldMatrix( id, worldMatrix );
+  mImpl.BakeColor( id, color );
 }
 
 UpdateProxy::UpdateProxy( Internal::UpdateProxy& impl )

diff --git a/dali/devel-api/update/update-proxy.h b/dali/devel-api/update/update-proxy.h
index 2ea1194..adb76b6 100644 (file)
--- a/dali/devel-api/update/update-proxy.h
+++ b/dali/devel-api/update/update-proxy.h
@@ -45,21 +45,29 @@ class DALI_CORE_API UpdateProxy
 public:
 
   /**
-   * @brief Given the Actor ID, this retrieves that Actor's position.
+   * @brief Given the Actor ID, this retrieves that Actor's local position.
    * @param[in]  id  The Actor ID
    * @return If valid Actor ID, then the Actor's position is returned.
    */
   Vector3 GetPosition( unsigned int id ) const;
 
   /**
-   * @brief Allows setting an Actor's position from the Frame callback function.
+   * @brief Allows setting an Actor's local position from the Frame callback function for the current frame only.
    * @param[in]  id        The Actor ID
    * @param[in]  position  The position to set.
-   * @note This will get reset to the internally calculated value in the next frame, so will have to be set again.
+   * @note This will get reset to the internally calculated or previously baked value in the next frame, so will have to be set again.
    */
   void SetPosition( unsigned int id, const Vector3& position );
 
   /**
+   * @brief Allows baking an Actor's local position from the Frame callback function.
+   * @param[in]  id        The Actor ID
+   * @param[in]  position  The position to set.
+   * @note The value is saved so will cause undesired effects if this property is being animated.
+   */
+  void BakePosition( unsigned int id, const Vector3& position );
+
+  /**
    * @brief Given the Actor ID, this retrieves that Actor's size.
    * @param[in]  id  The Actor ID
    * @return If valid Actor ID, then Actor's size is returned, otherwise Vector3::ZERO.
@@ -67,15 +75,23 @@ public:
   const Vector3& GetSize( unsigned int id ) const;
 
   /**
-   * @brief Allows setting an Actor's size from the Frame callback function.
+   * @brief Allows setting an Actor's size from the Frame callback function for the current frame only.
    * @param[in]  id    The Actor ID
    * @param[in]  size  The size to set.
-   * @note This will get reset to the internally calculated value in the next frame, so will have to be set again.
+   * @note This will get reset to the internally calculated or previously baked value in the next frame, so will have to be set again.
    */
   void SetSize( unsigned int id, const Vector3& size );
 
   /**
-   * @brief Given the Actor ID, this retrieves that Actor's position and size.
+   * @brief Allows baking an Actor's size from the Frame callback function.
+   * @param[in]  id    The Actor ID
+   * @param[in]  size  The size to set.
+   * @note The value is saved so will cause undesired effects if this property is being animated.
+   */
+  void BakeSize( unsigned int id, const Vector3& size );
+
+  /**
+   * @brief Given the Actor ID, this retrieves that Actor's local position and size.
    * @param[in]   id        The Actor ID
    * @param[out]  position  If valid Actor ID, then Actor's position is set
    * @param[out]  size      If valid Actor ID, then Actor's size is set
@@ -83,45 +99,50 @@ public:
   void GetPositionAndSize( unsigned int id, Vector3& position, Vector3& size ) const;
 
   /**
-   * @brief Given the Actor ID, this retrieves that Actor's color.
-   * @param[in]   id        The Actor ID
-   * @return If valid Actor ID, then Actor's color is returned, otherwise Vector4::ZERO.
+   * @brief Given the Actor ID, this retrieves that Actor's local scale.
+   * @param[in]  id  The Actor ID
+   * @return If valid Actor ID, then the Actor's scale is returned.
    */
-  Vector4 GetWorldColor( unsigned int id ) const;
+  Vector3 GetScale( unsigned int id ) const;
 
   /**
-   * @brief Allows setting an Actor's color from the Frame callback function.
+   * @brief Allows setting an Actor's local scale from the Frame callback function for the current frame only.
    * @param[in]  id     The Actor ID
-   * @param[in]  color  The color to set
-   * @note This will get reset to the internally calculated value in the next frame, so will have to be set again.
+   * @param[in]  scale  The scale to set.
+   * @note This will get reset to the internally calculated or previously baked value in the next frame, so will have to be set again.
    */
-  void SetWorldColor( unsigned int id, const Vector4& color ) const;
+  void SetScale( unsigned int id, const Vector3& scale );
 
   /**
-   * @brief Given the Actor ID, this retrieves that Actor's world-matrix and size.
-   * @param[in]   id           The Actor ID
-   * @param[out]  worldMatrix  If valid Actor ID, then Actor's world matrix is set
-   * @param[out]  size         If valid Actor ID, then Actor's size is set
+   * @brief Allows baking an Actor's local scale from the Frame callback function.
+   * @param[in]  id     The Actor ID
+   * @param[in]  scale  The scale to set.
+   * @note The value is saved so will cause undesired effects if this property is being animated.
    */
-  void GetWorldMatrixAndSize( unsigned int id, Matrix& worldMatrix, Vector3& size ) const;
+  void BakeScale( unsigned int id, const Vector3& scale );
 
   /**
-   * @brief Given the Actor ID, this retrieves that Actor's world-matrix.
-   * @param[in]  id  The Actor ID
-   * @return If valid Actor ID, then Actor's world matrix is returned, otherwise Matrix::IDENTITY.
+   * @brief Given the Actor ID, this retrieves that Actor's local color.
+   * @param[in]   id        The Actor ID
+   * @return If valid Actor ID, then Actor's color is returned, otherwise Vector4::ZERO.
+   */
+  Vector4 GetColor( unsigned int id ) const;
+
+  /**
+   * @brief Allows setting an Actor's local color from the Frame callback function for the current frame only.
+   * @param[in]  id     The Actor ID
+   * @param[in]  color  The color to set
+   * @note This will get reset to the internally calculated or previously baked value in the next frame, so will have to be set again.
    */
-  const Matrix& GetWorldMatrix( unsigned int id ) const;
+  void SetColor( unsigned int id, const Vector4& color ) const;
 
   /**
-   * @brief Allows the setting an Actor's world-matrix from the Frame callback function.
-   * @param[in]  id           The Actor ID
-   * @param[in]  worldMatrix  The world matrix to set.
-   * @note This will get reset to the internally calculated value in the next frame, so will have to be set again.
-   * @note This will only set the world matrix for that particular actor.
-   *       The world matrices of the children will not change and will have to be manually changed in the callback
-   *       as well (if required).
+   * @brief Allows baking an Actor's local color from the Frame callback function.
+   * @param[in]  id     The Actor ID
+   * @param[in]  color  The color to set
+   * @note The value is saved so will cause undesired effects if this property is being animated.
    */
-  void SetWorldMatrix( unsigned int id, const Matrix& worldMatrix );
+  void BakeColor( unsigned int id, const Vector4& color ) const;
 
 public: // Not intended for application developers
 

diff --git a/dali/internal/update/manager/update-manager.cpp b/dali/internal/update/manager/update-manager.cpp
index 10f290f..52848d4 100644 (file)
--- a/dali/internal/update/manager/update-manager.cpp
+++ b/dali/internal/update/manager/update-manager.cpp
@@ -892,15 +892,15 @@ unsigned int UpdateManager::Update( float elapsedSeconds,
     //Update renderers and apply constraints
     UpdateRenderers( bufferIndex );
 
-    //Update the transformations of all the nodes
-    mImpl->transformManager.Update();
-
     // Call the frame-callback-processor if set
     if( mImpl->frameCallbackProcessor )
     {
       mImpl->frameCallbackProcessor->Update( bufferIndex, elapsedSeconds );
     }
 
+    //Update the transformations of all the nodes
+    mImpl->transformManager.Update();
+
     //Process Property Notifications
     ProcessPropertyNotifications( bufferIndex );
 

diff --git a/dali/internal/update/manager/update-proxy-impl.cpp b/dali/internal/update/manager/update-proxy-impl.cpp
index 85404a9..07d13a3 100644 (file)
--- a/dali/internal/update/manager/update-proxy-impl.cpp
+++ b/dali/internal/update/manager/update-proxy-impl.cpp
@@ -67,17 +67,31 @@ UpdateProxy::~UpdateProxy()
 
 Vector3 UpdateProxy::GetPosition( unsigned int id ) const
 {
-  const Dali::Matrix& matrix = GetWorldMatrix( id );
-  return matrix.GetTranslation3();
+  Vector3 position;
+  const SceneGraph::Node* node = GetNodeWithId( id );
+  if( node )
+  {
+    position = mTransformManager.GetVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_POSITION );
+  }
+
+  return position;
 }
 
 void UpdateProxy::SetPosition( unsigned int id, const Vector3& position )
 {
-  const SceneGraph::Node* node = GetNodeWithId( id );
+  SceneGraph::Node* node = GetNodeWithId( id );
+  if( node )
+  {
+    mTransformManager.SetVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_POSITION, position );
+  }
+}
+
+void UpdateProxy::BakePosition( unsigned int id, const Vector3& position )
+{
+  SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    Matrix& matrix = mTransformManager.GetWorldMatrix( node->mTransformId );
-    matrix.SetTranslation( position );
+    mTransformManager.BakeVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_POSITION, position );
   }
 }
 
@@ -101,61 +115,81 @@ void UpdateProxy::SetSize( unsigned int id, const Vector3& size )
   }
 }
 
+void UpdateProxy::BakeSize( unsigned int id, const Vector3& size )
+{
+  SceneGraph::Node* node = GetNodeWithId( id );
+  if( node )
+  {
+    mTransformManager.BakeVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_SIZE, size );
+  }
+}
+
 void UpdateProxy::GetPositionAndSize( unsigned int id, Vector3& position, Vector3& size ) const
 {
-  Matrix worldMatrix( false );
-  GetWorldMatrixAndSize( id, worldMatrix, size );
-  position = worldMatrix.GetTranslation3();
+  const SceneGraph::Node* node = GetNodeWithId( id );
+  if( node )
+  {
+    position = mTransformManager.GetVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_POSITION );
+    size = mTransformManager.GetVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_SIZE );
+  }
 }
 
-Vector4 UpdateProxy::GetWorldColor( unsigned int id ) const
+Vector3 UpdateProxy::GetScale( unsigned int id ) const
 {
-  SceneGraph::Node* node = GetNodeWithId( id );
+  Vector3 scale;
+  const SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    return node->mWorldColor.Get( mCurrentBufferIndex );
+    scale = mTransformManager.GetVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_SCALE );
   }
 
-  return Vector4::ZERO;
+  return scale;
 }
 
-void UpdateProxy::SetWorldColor( unsigned int id, const Vector4& color ) const
+void UpdateProxy::SetScale( unsigned int id, const Vector3& scale )
 {
   SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    Vector4& currentColor = node->mWorldColor.Get( mCurrentBufferIndex );
-    currentColor = color;
+    mTransformManager.SetVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_SCALE, scale );
   }
 }
 
-void UpdateProxy::GetWorldMatrixAndSize( unsigned int id, Matrix& worldMatrix, Vector3& size ) const
+void UpdateProxy::BakeScale( unsigned int id, const Vector3& scale )
 {
-  const SceneGraph::Node* node = GetNodeWithId( id );
+  SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    mTransformManager.GetWorldMatrixAndSize( node->mTransformId, worldMatrix, size );
+    mTransformManager.BakeVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_SCALE, scale );
   }
 }
 
-const Matrix& UpdateProxy::GetWorldMatrix( unsigned int id ) const
+Vector4 UpdateProxy::GetColor( unsigned int id ) const
 {
-  const SceneGraph::Node* node = GetNodeWithId( id );
+  SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    return mTransformManager.GetWorldMatrix( node->mTransformId );
+    return node->mColor.Get( mCurrentBufferIndex );
   }
 
-  return Matrix::IDENTITY;
+  return Vector4::ZERO;
+}
+
+void UpdateProxy::SetColor( unsigned int id, const Vector4& color ) const
+{
+  SceneGraph::Node* node = GetNodeWithId( id );
+  if( node )
+  {
+    node->mColor.Set( mCurrentBufferIndex, color );
+  }
 }
 
-void UpdateProxy::SetWorldMatrix( unsigned int id, const Matrix& worldMatrix )
+void UpdateProxy::BakeColor( unsigned int id, const Vector4& color ) const
 {
   SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    Matrix& currentMatrix = mTransformManager.GetWorldMatrix( node->mTransformId );
-    currentMatrix = worldMatrix;
+    node->mColor.Bake( mCurrentBufferIndex, color );
   }
 }
 

diff --git a/dali/internal/update/manager/update-proxy-impl.h b/dali/internal/update/manager/update-proxy-impl.h
index f730a75..9d93b76 100644 (file)
--- a/dali/internal/update/manager/update-proxy-impl.h
+++ b/dali/internal/update/manager/update-proxy-impl.h
@@ -75,6 +75,11 @@ public:
   void SetPosition( unsigned int id, const Vector3& position );
 
   /**
+   * @copydoc Dali::UpdateProxy::BakePosition()
+   */
+  void BakePosition( unsigned int id, const Vector3& position );
+
+  /**
    * @copydoc Dali::UpdateProxy::GetSize()
    */
   const Vector3& GetSize( unsigned int id ) const;
@@ -85,34 +90,44 @@ public:
   void SetSize( unsigned int id, const Vector3& size );
 
   /**
+   * @copydoc Dali::UpdateProxy::BakeSize()
+   */
+  void BakeSize( unsigned int id, const Vector3& size );
+
+  /**
    * @copydoc Dali::UpdateProxy::GetPositionAndSize()
    */
   void GetPositionAndSize( unsigned int id, Vector3& position, Vector3& size ) const;
 
   /**
-   * @copydoc Dali::UpdateProxy::GetColor()
+   * @copydoc Dali::UpdateProxy::GetScale()
    */
-  Vector4 GetWorldColor( unsigned int id ) const;
+  Vector3 GetScale( unsigned int id ) const;
 
   /**
-   * @copydoc Dali::UpdateProxy::SetColor()
+   * @copydoc Dali::UpdateProxy::SetScale()
+   */
+  void SetScale( unsigned int id, const Vector3& scale );
+
+  /**
+   * @copydoc Dali::UpdateProxy::BakeScale()
    */
-  void SetWorldColor( unsigned int id, const Vector4& color ) const;
+  void BakeScale( unsigned int id, const Vector3& scale );
 
   /**
-   * @copydoc Dali::UpdateProxy::GetWorldMatrixAndSize()
+   * @copydoc Dali::UpdateProxy::GetColor()
    */
-  void GetWorldMatrixAndSize( unsigned int id, Matrix& worldMatrix, Vector3& size ) const;
+  Vector4 GetColor( unsigned int id ) const;
 
   /**
-   * @copydoc Dali::UpdateProxy::GetWorldMatrix()
+   * @copydoc Dali::UpdateProxy::SetColor()
    */
-  const Matrix& GetWorldMatrix( unsigned int id ) const;
+  void SetColor( unsigned int id, const Vector4& color ) const;
 
   /**
-   * @copydoc Dali::UpdateProxy::SetWorldMatrix()
+   * @copydoc Dali::UpdateProxy::BakeColor()
    */
-  void SetWorldMatrix( unsigned int id, const Matrix& worldMatrix );
+  void BakeColor( unsigned int id, const Vector4& color ) const;
 
   /**
    * @brief Retrieves the root-node used by this class
@@ -151,7 +166,7 @@ private:
 
   mutable std::vector< IdNodePair > mNodeContainer; ///< Used to store cached pointers to already searched for Nodes.
   mutable IdNodePair mLastCachedIdNodePair; ///< Used to cache the last retrieved id-node pair.
-  unsigned int mCurrentBufferIndex;
+  BufferIndex mCurrentBufferIndex;
 
   SceneGraph::TransformManager& mTransformManager; ///< Reference to the Transform Manager.
   SceneGraph::Node& mRootNode; ///< The root node of this update proxy.