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

This reverts commit 1349eaca8b52876f6917345ab50db609c1c28adc.

Change-Id: I1a7dea78c797d918f9837fcd5f33d307facd71fe

diff --git a/automated-tests/src/dali/utc-Dali-FrameCallbackInterface.cpp b/automated-tests/src/dali/utc-Dali-FrameCallbackInterface.cpp
index 694cb43..0a3afb2 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-FrameCallbackInterface.cpp
+++ b/automated-tests/src/dali/utc-Dali-FrameCallbackInterface.cpp
@@ -72,21 +72,24 @@ 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 );
-    mColor = updateProxy.GetColor( mActorId );
-    mScale = updateProxy.GetScale( mActorId );
+    mWorldColor = updateProxy.GetWorldColor( mActorId );
   }
 
   const unsigned int mActorId;
 
+  Matrix mWorldMatrix;
+  Matrix mWorldMatrixGetWorldMatrixCall;
+  Vector3 mSize;
   Vector3 mSizeGetSizeCall;
   Vector3 mPositionGetPositionCall;
   Vector3 mPositionGetPositionAndSizeCall;
   Vector3 mSizeGetPositionAndSizeCall;
-  Vector4 mColor;
-  Vector3 mScale;
+  Vector4 mWorldColor;
 };
 
 class FrameCallbackSetter : public FrameCallbackBasic
@@ -95,87 +98,42 @@ public:
 
   FrameCallbackSetter(
       unsigned int actorId,
+      const Matrix& matrixToSet,
       const Vector3& sizeToSet,
       const Vector3& positionToSet,
-      const Vector4& colorToSet,
-      const Vector3& scaleToSet )
+      const Vector4& colorToSet )
   : mActorId( actorId ),
+    mMatrixToSet( matrixToSet ),
     mSizeToSet( sizeToSet ),
     mPositionToSet( positionToSet ),
-    mColorToSet( colorToSet ),
-    mScaleToSet( scaleToSet )
+    mColorToSet( colorToSet )
   {
   }
 
   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 );
-    mColorAfterSetting = updateProxy.GetColor( mActorId );
-    mScaleAfterSetting = updateProxy.GetScale( mActorId );
+    updateProxy.SetWorldColor( mActorId, mColorToSet );
+    mColorAfterSetting = updateProxy.GetWorldColor( 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:
@@ -189,17 +147,17 @@ public:
     FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
     for( auto&& i : mActorIds )
     {
-      Vector3 position;
+      Matrix matrix( false );
       Vector3 size;
-      updateProxy.GetPositionAndSize( i, position, size );
-      mPositions[ i ] = position;
+      updateProxy.GetWorldMatrixAndSize( i, matrix, size );
+      mWorldMatrices[ i ] = matrix;
       mSizes[ i ] = size;
     }
   }
 
   Vector< unsigned int > mActorIds;
 
-  std::map< unsigned int, Vector3 > mPositions;
+  std::map< unsigned int, Matrix > mWorldMatrices;
   std::map< unsigned int, Vector3 > mSizes;
 };
 
@@ -237,7 +195,6 @@ 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 );
@@ -245,10 +202,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() );
@@ -256,13 +213,23 @@ 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, position, TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mPositionGetPositionAndSizeCall, position, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mPositionGetPositionCall, expectedPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mPositionGetPositionAndSizeCall, expectedPosition, TEST_LOCATION );
   DALI_TEST_EQUALS( frameCallback.mSizeGetPositionAndSizeCall, Vector3( actorSize.width, actorSize.height, 0.0f ), TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mColor, color, TEST_LOCATION );
-  DALI_TEST_EQUALS( frameCallback.mScale, scale, TEST_LOCATION );
+  DALI_TEST_EQUALS( frameCallback.mWorldColor, color, TEST_LOCATION );
 
   END_TEST;
 }
@@ -279,83 +246,36 @@ 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(), sizeToSet, positionToSet, colorToSet, scaleToSet );
+  FrameCallbackSetter frameCallback( actor.GetId(), matrixToSet, sizeToSet, positionToSet, colorToSet );
   DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
 
   application.SendNotification();
   application.Render();
 
-  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();
+  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_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)
 {
   /**
@@ -372,7 +292,7 @@ int UtcDaliFrameCallbackMultipleActors(void)
    *      /                        \
    *   actorC                     actorH
    *
-   *  Screen positions (with minor alterations due to local position):
+   *  Screen positions:
    *  -----------------------
    *  |actorA|actorD        |
    *  |      actorB         |
@@ -389,6 +309,7 @@ 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 );
@@ -400,70 +321,81 @@ int UtcDaliFrameCallbackMultipleActors(void)
   sizes['G'] = Vector3( 350.0f, 350.0f, 0.0f );
   sizes['H'] = Vector3( 400.0f, 350.0f, 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 );
+  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 ) );
 
   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;
@@ -491,7 +423,7 @@ int UtcDaliFrameCallbackMultipleActors(void)
 
   for( char i = 'A'; i <= 'H'; ++i )
   {
-    DALI_TEST_EQUALS( frameCallback.mPositions[ actorIds[ i ] ], positions[ i ], TEST_LOCATION );
+    DALI_TEST_EQUALS( frameCallback.mWorldMatrices[ actorIds[ i ] ], matrices[ i ], TEST_LOCATION );
     DALI_TEST_EQUALS( frameCallback.mSizes[ actorIds[ i ] ], sizes[ i ], TEST_LOCATION );
   }
 
@@ -505,7 +437,7 @@ int UtcDaliFrameCallbackMultipleActors(void)
 
   for( char i = 'A'; i <= 'H'; ++i )
   {
-    DALI_TEST_EQUALS( frameCallback.mPositions[ actorIds[ i ] ], positions[ i ], TEST_LOCATION );
+    DALI_TEST_EQUALS( frameCallback.mWorldMatrices[ actorIds[ i ] ], matrices[ i ], TEST_LOCATION );
     DALI_TEST_EQUALS( frameCallback.mSizes[ actorIds[ i ] ], sizes[ i ], TEST_LOCATION );
   }
 
@@ -528,12 +460,11 @@ 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.mPositionGetPositionCall, Vector3::ZERO, 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.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 f336106..67511b4 100644 (file)
--- a/dali/devel-api/update/update-proxy.cpp
+++ b/dali/devel-api/update/update-proxy.cpp
@@ -34,11 +34,6 @@ 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 );
@@ -49,44 +44,34 @@ 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 );
 }
 
-Vector3 UpdateProxy::GetScale( unsigned int id ) const
-{
-  return mImpl.GetScale( id );
-}
-
-void UpdateProxy::SetScale( unsigned int id, const Vector3& scale )
+Vector4 UpdateProxy::GetWorldColor( unsigned int id ) const
 {
-  mImpl.SetScale( id, scale );
+  return mImpl.GetWorldColor( id );
 }
 
-void UpdateProxy::BakeScale( unsigned int id, const Vector3& scale )
+void UpdateProxy::SetWorldColor( unsigned int id, const Vector4& color ) const
 {
-  mImpl.BakeScale( id, scale );
+  mImpl.SetWorldColor( id, color );
 }
 
-Vector4 UpdateProxy::GetColor( unsigned int id ) const
+void UpdateProxy::GetWorldMatrixAndSize( unsigned int id, Matrix& worldMatrix, Vector3& size ) const
 {
-  return mImpl.GetColor( id );
+  mImpl.GetWorldMatrixAndSize( id, worldMatrix, size );
 }
 
-void UpdateProxy::SetColor( unsigned int id, const Vector4& color ) const
+const Matrix& UpdateProxy::GetWorldMatrix( unsigned int id ) const
 {
-  mImpl.SetColor( id, color );
+  return mImpl.GetWorldMatrix( id );
 }
 
-void UpdateProxy::BakeColor( unsigned int id, const Vector4& color ) const
+void UpdateProxy::SetWorldMatrix( unsigned int id, const Matrix& worldMatrix )
 {
-  mImpl.BakeColor( id, color );
+  mImpl.SetWorldMatrix( id, worldMatrix );
 }
 
 UpdateProxy::UpdateProxy( Internal::UpdateProxy& impl )

diff --git a/dali/devel-api/update/update-proxy.h b/dali/devel-api/update/update-proxy.h
index adb76b6..2ea1194 100644 (file)
--- a/dali/devel-api/update/update-proxy.h
+++ b/dali/devel-api/update/update-proxy.h
@@ -45,29 +45,21 @@ class DALI_CORE_API UpdateProxy
 public:
 
   /**
-   * @brief Given the Actor ID, this retrieves that Actor's local position.
+   * @brief Given the Actor ID, this retrieves that Actor's 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 local position from the Frame callback function for the current frame only.
+   * @brief Allows setting an Actor's position from the Frame callback function.
    * @param[in]  id        The Actor ID
    * @param[in]  position  The position 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.
+   * @note This will get reset to the internally calculated 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.
@@ -75,23 +67,15 @@ public:
   const Vector3& GetSize( unsigned int id ) const;
 
   /**
-   * @brief Allows setting an Actor's size from the Frame callback function for the current frame only.
+   * @brief Allows setting an Actor's size from the Frame callback function.
    * @param[in]  id    The Actor ID
    * @param[in]  size  The size 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.
+   * @note This will get reset to the internally calculated value in the next frame, so will have to be set again.
    */
   void SetSize( unsigned int id, const Vector3& 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.
+   * @brief Given the Actor ID, this retrieves that Actor's 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
@@ -99,50 +83,45 @@ public:
   void GetPositionAndSize( unsigned int id, Vector3& position, Vector3& size ) const;
 
   /**
-   * @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.
-   */
-  Vector3 GetScale( unsigned int id ) const;
-
-  /**
-   * @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]  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.
+   * @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.
    */
-  void SetScale( unsigned int id, const Vector3& scale );
+  Vector4 GetWorldColor( unsigned int id ) const;
 
   /**
-   * @brief Allows baking an Actor's local scale from the Frame callback function.
+   * @brief Allows setting an Actor's color 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.
+   * @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.
    */
-  void BakeScale( unsigned int id, const Vector3& scale );
+  void SetWorldColor( unsigned int id, const Vector4& color ) const;
 
   /**
-   * @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.
+   * @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
    */
-  Vector4 GetColor( unsigned int id ) const;
+  void GetWorldMatrixAndSize( unsigned int id, Matrix& worldMatrix, Vector3& size ) 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.
+   * @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.
    */
-  void SetColor( unsigned int id, const Vector4& color ) const;
+  const Matrix& GetWorldMatrix( unsigned int id ) const;
 
   /**
-   * @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.
+   * @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).
    */
-  void BakeColor( unsigned int id, const Vector4& color ) const;
+  void SetWorldMatrix( unsigned int id, const Matrix& worldMatrix );
 
 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 52848d4..10f290f 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 07d13a3..85404a9 100644 (file)
--- a/dali/internal/update/manager/update-proxy-impl.cpp
+++ b/dali/internal/update/manager/update-proxy-impl.cpp
@@ -67,31 +67,17 @@ UpdateProxy::~UpdateProxy()
 
 Vector3 UpdateProxy::GetPosition( unsigned int id ) const
 {
-  Vector3 position;
-  const SceneGraph::Node* node = GetNodeWithId( id );
-  if( node )
-  {
-    position = mTransformManager.GetVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_POSITION );
-  }
-
-  return position;
+  const Dali::Matrix& matrix = GetWorldMatrix( id );
+  return matrix.GetTranslation3();
 }
 
 void UpdateProxy::SetPosition( unsigned int id, const Vector3& position )
 {
-  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 );
+  const SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    mTransformManager.BakeVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_POSITION, position );
+    Matrix& matrix = mTransformManager.GetWorldMatrix( node->mTransformId );
+    matrix.SetTranslation( position );
   }
 }
 
@@ -115,81 +101,61 @@ 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
 {
-  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 );
-  }
+  Matrix worldMatrix( false );
+  GetWorldMatrixAndSize( id, worldMatrix, size );
+  position = worldMatrix.GetTranslation3();
 }
 
-Vector3 UpdateProxy::GetScale( unsigned int id ) const
+Vector4 UpdateProxy::GetWorldColor( unsigned int id ) const
 {
-  Vector3 scale;
-  const SceneGraph::Node* node = GetNodeWithId( id );
+  SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    scale = mTransformManager.GetVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_SCALE );
+    return node->mWorldColor.Get( mCurrentBufferIndex );
   }
 
-  return scale;
+  return Vector4::ZERO;
 }
 
-void UpdateProxy::SetScale( unsigned int id, const Vector3& scale )
+void UpdateProxy::SetWorldColor( unsigned int id, const Vector4& color ) const
 {
   SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    mTransformManager.SetVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_SCALE, scale );
+    Vector4& currentColor = node->mWorldColor.Get( mCurrentBufferIndex );
+    currentColor = color;
   }
 }
 
-void UpdateProxy::BakeScale( unsigned int id, const Vector3& scale )
+void UpdateProxy::GetWorldMatrixAndSize( unsigned int id, Matrix& worldMatrix, Vector3& size ) const
 {
-  SceneGraph::Node* node = GetNodeWithId( id );
+  const SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    mTransformManager.BakeVector3PropertyValue( node->mTransformId, SceneGraph::TRANSFORM_PROPERTY_SCALE, scale );
+    mTransformManager.GetWorldMatrixAndSize( node->mTransformId, worldMatrix, size );
   }
 }
 
-Vector4 UpdateProxy::GetColor( unsigned int id ) const
+const Matrix& UpdateProxy::GetWorldMatrix( unsigned int id ) const
 {
-  SceneGraph::Node* node = GetNodeWithId( id );
+  const SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    return node->mColor.Get( mCurrentBufferIndex );
+    return mTransformManager.GetWorldMatrix( node->mTransformId );
   }
 
-  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 );
-  }
+  return Matrix::IDENTITY;
 }
 
-void UpdateProxy::BakeColor( unsigned int id, const Vector4& color ) const
+void UpdateProxy::SetWorldMatrix( unsigned int id, const Matrix& worldMatrix )
 {
   SceneGraph::Node* node = GetNodeWithId( id );
   if( node )
   {
-    node->mColor.Bake( mCurrentBufferIndex, color );
+    Matrix& currentMatrix = mTransformManager.GetWorldMatrix( node->mTransformId );
+    currentMatrix = worldMatrix;
   }
 }
 

diff --git a/dali/internal/update/manager/update-proxy-impl.h b/dali/internal/update/manager/update-proxy-impl.h
index 9d93b76..f730a75 100644 (file)
--- a/dali/internal/update/manager/update-proxy-impl.h
+++ b/dali/internal/update/manager/update-proxy-impl.h
@@ -75,11 +75,6 @@ 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;
@@ -90,44 +85,34 @@ 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::GetScale()
-   */
-  Vector3 GetScale( unsigned int id ) const;
-
-  /**
-   * @copydoc Dali::UpdateProxy::SetScale()
+   * @copydoc Dali::UpdateProxy::GetColor()
    */
-  void SetScale( unsigned int id, const Vector3& scale );
+  Vector4 GetWorldColor( unsigned int id ) const;
 
   /**
-   * @copydoc Dali::UpdateProxy::BakeScale()
+   * @copydoc Dali::UpdateProxy::SetColor()
    */
-  void BakeScale( unsigned int id, const Vector3& scale );
+  void SetWorldColor( unsigned int id, const Vector4& color ) const;
 
   /**
-   * @copydoc Dali::UpdateProxy::GetColor()
+   * @copydoc Dali::UpdateProxy::GetWorldMatrixAndSize()
    */
-  Vector4 GetColor( unsigned int id ) const;
+  void GetWorldMatrixAndSize( unsigned int id, Matrix& worldMatrix, Vector3& size ) const;
 
   /**
-   * @copydoc Dali::UpdateProxy::SetColor()
+   * @copydoc Dali::UpdateProxy::GetWorldMatrix()
    */
-  void SetColor( unsigned int id, const Vector4& color ) const;
+  const Matrix& GetWorldMatrix( unsigned int id ) const;
 
   /**
-   * @copydoc Dali::UpdateProxy::BakeColor()
+   * @copydoc Dali::UpdateProxy::SetWorldMatrix()
    */
-  void BakeColor( unsigned int id, const Vector4& color ) const;
+  void SetWorldMatrix( unsigned int id, const Matrix& worldMatrix );
 
   /**
    * @brief Retrieves the root-node used by this class
@@ -166,7 +151,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.
-  BufferIndex mCurrentBufferIndex;
+  unsigned int mCurrentBufferIndex;
 
   SceneGraph::TransformManager& mTransformManager; ///< Reference to the Transform Manager.
   SceneGraph::Node& mRootNode; ///< The root node of this update proxy.