Do not reset properties when properties are explicitly set

 + Change property type of Camera::Type, Camera::ProjectionMode from string to integer

Change-Id: I312d5b2a29b7dcbe3c683189a8b5aa519b928933
Signed-off-by: seungho <sbsh.baek@samsung.com>

diff --git a/automated-tests/src/dali/utc-Dali-CameraActor.cpp b/automated-tests/src/dali/utc-Dali-CameraActor.cpp
index 0ec0ccb..7063dca 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-CameraActor.cpp
+++ b/automated-tests/src/dali/utc-Dali-CameraActor.cpp
@@ -275,8 +275,10 @@ int UtcDaliCameraActorSetGetTypeP(void)
   actor.SetType(Dali::Camera::LOOK_AT_TARGET);
   DALI_TEST_EQUALS(actor.GetType(), Dali::Camera::LOOK_AT_TARGET, TEST_LOCATION);
 
-  DALI_TEST_EQUALS("LOOK_AT_TARGET", actor.GetProperty<std::string>(CameraActor::Property::TYPE), TEST_LOCATION);
-  DALI_TEST_EQUALS("LOOK_AT_TARGET", actor.GetCurrentProperty<std::string>(CameraActor::Property::TYPE), TEST_LOCATION);
+  Dali::Camera::Type cameraType = actor.GetProperty<Dali::Camera::Type>(CameraActor::Property::TYPE);
+  Dali::Camera::Type currentCameraType = actor.GetCurrentProperty<Dali::Camera::Type>(CameraActor::Property::TYPE);
+  DALI_TEST_EQUALS(Camera::LOOK_AT_TARGET, cameraType, TEST_LOCATION);
+  DALI_TEST_EQUALS(Camera::LOOK_AT_TARGET, currentCameraType, TEST_LOCATION);
   END_TEST;
 }
 
@@ -1055,9 +1057,9 @@ int UtcDaliCameraActorSetOrthographicProjectionP3(void)
   DALI_TEST_EQUALS(500.0f, value, FLOAT_EPSILON, TEST_LOCATION);
 
   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
-  std::string stringValue;
-  actor.GetProperty(CameraActor::Property::PROJECTION_MODE).Get(stringValue);
-  DALI_TEST_EQUALS(stringValue, "ORTHOGRAPHIC_PROJECTION", TEST_LOCATION);
+
+  Dali::Camera::ProjectionMode projectionMode = actor.GetProperty<Dali::Camera::ProjectionMode>(CameraActor::Property::PROJECTION_MODE);
+  DALI_TEST_EQUALS(projectionMode, Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
   END_TEST;
 }
 
@@ -1085,7 +1087,7 @@ int UtcDaliCameraActorSetProjectionModeP(void)
   DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION);
 
   // Check setting the property.
-  Property::Value setValue = "PERSPECTIVE_PROJECTION";
+  Property::Value setValue = Dali::Camera::PERSPECTIVE_PROJECTION;
   actor.SetProperty(CameraActor::Property::PROJECTION_MODE, setValue);
   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
   END_TEST;
@@ -1127,9 +1129,8 @@ int UtcDaliCameraActorGetProjectionModeP(void)
   DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
 
   // Check getting the property.
-  std::string stringValue;
-  actor.GetProperty(CameraActor::Property::PROJECTION_MODE).Get(stringValue);
-  DALI_TEST_EQUALS(stringValue, "PERSPECTIVE_PROJECTION", TEST_LOCATION);
+  Dali::Camera::ProjectionMode projectionMode = actor.GetProperty<Dali::Camera::ProjectionMode>(CameraActor::Property::PROJECTION_MODE);
+  DALI_TEST_EQUALS(projectionMode, Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
   END_TEST;
 }
 
@@ -1188,8 +1189,9 @@ int UtcDaliCameraActorSetCameraOffScene(void)
   DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION);
   actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
   DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION);
-  actor.GetProperty(CameraActor::Property::PROJECTION_MODE).Get(sValue);
-  DALI_TEST_EQUALS("PERSPECTIVE_PROJECTION", sValue, TEST_LOCATION);
+
+  Dali::Camera::ProjectionMode projectionMode = actor.GetProperty<Dali::Camera::ProjectionMode>(CameraActor::Property::PROJECTION_MODE);
+  DALI_TEST_EQUALS(Dali::Camera::PERSPECTIVE_PROJECTION, projectionMode, TEST_LOCATION);
   bool bValue;
   actor.GetProperty(CameraActor::Property::INVERT_Y_AXIS).Get(bValue);
   DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
@@ -1227,9 +1229,9 @@ int UtcDaliCameraActorSetCameraOnScene(void)
   DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
   DALI_TEST_EQUALS(false, actor.GetInvertYAxis(), TEST_LOCATION);
 
-  std::string sValue;
-  actor.GetProperty(CameraActor::Property::TYPE).Get(sValue);
-  DALI_TEST_EQUALS(sValue, "LOOK_AT_TARGET", TEST_LOCATION);
+
+  Dali::Camera::Type cameraType = actor.GetProperty<Dali::Camera::Type>(CameraActor::Property::TYPE);
+  DALI_TEST_EQUALS(cameraType, Camera::LOOK_AT_TARGET, TEST_LOCATION);
 
   float value;
   actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
@@ -1258,7 +1260,7 @@ int UtcDaliCameraActorGetCamera(void)
 
   DALI_TEST_EQUALS(actor.GetAspectRatio(), TEST_ASPECT_RATIO, FLOAT_EPSILON, TEST_LOCATION);
 
-  actor.SetProperty(CameraActor::Property::TYPE, "FREE_LOOK");
+  actor.SetProperty(CameraActor::Property::TYPE, Camera::FREE_LOOK);
   actor.SetProperty(CameraActor::Property::ASPECT_RATIO, TEST_ASPECT_RATIO);
   actor.SetProperty(CameraActor::Property::FIELD_OF_VIEW, TEST_FIELD_OF_VIEW);
   actor.SetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE, TEST_NEAR_PLANE_DISTANCE);
@@ -1432,8 +1434,8 @@ int UtcDaliCameraActorDefaultPropertiesInherited(void)
       {"keyboardFocusable", Property::BOOLEAN, true, false, false, Dali::Actor::Property::KEYBOARD_FOCUSABLE},
       {"siblingOrder", Property::INTEGER, true, false, false, Dali::DevelActor::Property::SIBLING_ORDER},
       // camera own
-      {"type", Property::STRING, true, false, true, Dali::CameraActor::Property::TYPE},
-      {"projectionMode", Property::STRING, true, false, true, Dali::CameraActor::Property::PROJECTION_MODE},
+      {"type", Property::INTEGER, true, false, true, Dali::CameraActor::Property::TYPE},
+      {"projectionMode", Property::INTEGER, true, false, true, Dali::CameraActor::Property::PROJECTION_MODE},
       {"fieldOfView", Property::FLOAT, true, false, true, Dali::CameraActor::Property::FIELD_OF_VIEW},
       {"aspectRatio", Property::FLOAT, true, false, true, Dali::CameraActor::Property::ASPECT_RATIO},
       {"nearPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::NEAR_PLANE_DISTANCE},
@@ -2233,3 +2235,104 @@ int UtcDaliCameraActorCulling01(void)
 
   END_TEST;
 }
+
+
+int UtcDaliCameraActorSetProperty(void)
+{
+  TestApplication application;
+
+  tet_infoline("Test the CameraActor reset properties when On Scene, if user set property explicitly.");
+
+  CameraActor camera = CameraActor::New();
+  camera.SetFieldOfView(1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetFieldOfView(), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetAspectRatio(1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetAspectRatio(), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetNearClippingPlane(1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetNearClippingPlane(), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetFarClippingPlane(1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetFarClippingPlane(), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetProperty(Dali::CameraActor::Property::LEFT_PLANE_DISTANCE, 1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetProperty<float>(Dali::CameraActor::Property::LEFT_PLANE_DISTANCE), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetProperty(Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE, 1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetProperty<float>(Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetProperty(Dali::CameraActor::Property::TOP_PLANE_DISTANCE, 1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetProperty<float>(Dali::CameraActor::Property::TOP_PLANE_DISTANCE), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetProperty(Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE, 1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetProperty<float>(Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetProperty(Dali::Actor::Property::POSITION, Vector3(100.0f, 100.0f, 100.0f));
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(Vector3(100.0f, 100.0f, 100.0f), camera.GetProperty<Vector3>(Dali::Actor::Property::POSITION), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetProperty(Dali::Actor::Property::POSITION_X, 1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetProperty<float>(Dali::Actor::Property::POSITION_X), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetProperty(Dali::Actor::Property::POSITION_Y, 1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetProperty<float>(Dali::Actor::Property::POSITION_Y), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetProperty(Dali::Actor::Property::POSITION_Z, 1.0f);
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(1.0f, camera.GetProperty<float>(Dali::Actor::Property::POSITION_Z), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  camera = CameraActor::New();
+  camera.SetProperty(Dali::Actor::Property::ORIENTATION, Quaternion(Radian(Degree(90.0f)), Vector3::XAXIS));
+  application.GetScene().Add(camera);
+  DALI_TEST_EQUALS(Quaternion(Radian(Degree(90.0f)), Vector3::XAXIS), camera.GetProperty<Quaternion>(Dali::Actor::Property::ORIENTATION), TEST_LOCATION);
+  camera.Unparent();
+  camera.Reset();
+
+  END_TEST;
+}

diff --git a/dali/internal/event/actors/camera-actor-impl.cpp b/dali/internal/event/actors/camera-actor-impl.cpp
index d69462a..79971ff 100644 (file)
--- a/dali/internal/event/actors/camera-actor-impl.cpp
+++ b/dali/internal/event/actors/camera-actor-impl.cpp
@@ -46,8 +46,8 @@ namespace
  */
 // clang-format off
 DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "type",                   STRING,   true,    false,   true,   Dali::CameraActor::Property::TYPE                  )
-DALI_PROPERTY( "projectionMode",         STRING,   true,    false,   true,   Dali::CameraActor::Property::PROJECTION_MODE       )
+DALI_PROPERTY( "type",                   INTEGER,  true,    false,   true,   Dali::CameraActor::Property::TYPE                  )
+DALI_PROPERTY( "projectionMode",         INTEGER,  true,    false,   true,   Dali::CameraActor::Property::PROJECTION_MODE       )
 DALI_PROPERTY( "fieldOfView",            FLOAT,    true,    false,   true,   Dali::CameraActor::Property::FIELD_OF_VIEW         )
 DALI_PROPERTY( "aspectRatio",            FLOAT,    true,    false,   true,   Dali::CameraActor::Property::ASPECT_RATIO          )
 DALI_PROPERTY( "nearPlaneDistance",      FLOAT,    true,    false,   true,   Dali::CameraActor::Property::NEAR_PLANE_DISTANCE   )
@@ -167,7 +167,8 @@ CameraActor::CameraActor(const SceneGraph::Node& node)
   mRightClippingPlane(SceneGraph::Camera::DEFAULT_RIGHT_CLIPPING_PLANE),
   mTopClippingPlane(SceneGraph::Camera::DEFAULT_TOP_CLIPPING_PLANE),
   mBottomClippingPlane(SceneGraph::Camera::DEFAULT_BOTTOM_CLIPPING_PLANE),
-  mInvertYAxis(SceneGraph::Camera::DEFAULT_INVERT_Y_AXIS)
+  mInvertYAxis(SceneGraph::Camera::DEFAULT_INVERT_Y_AXIS),
+  mPropertyChanged(false)
 {
 }
 
@@ -199,7 +200,7 @@ void CameraActor::OnSceneConnectionInternal()
 {
   // If the canvas size has not been set, then use the size of the scene to which we've been added
   // in order to set up the current projection
-  if((mCanvasSize.width < Math::MACHINE_EPSILON_1000) || (mCanvasSize.height < Math::MACHINE_EPSILON_1000))
+  if(!mPropertyChanged && ((mCanvasSize.width < Math::MACHINE_EPSILON_1000) || (mCanvasSize.height < Math::MACHINE_EPSILON_1000)))
   {
     if(mProjectionMode == Dali::Camera::ORTHOGRAPHIC_PROJECTION)
     {
@@ -222,6 +223,7 @@ void CameraActor::SetReflectByPlane(const Vector4& plane)
 
 void CameraActor::SetTarget(const Vector3& target)
 {
+  mPropertyChanged = true;
   if(target != mTarget) // using range epsilon
   {
     mTarget = target;
@@ -269,6 +271,7 @@ Dali::Camera::ProjectionMode CameraActor::GetProjectionMode() const
 
 void CameraActor::SetFieldOfView(float fieldOfView)
 {
+  mPropertyChanged = true;
   if(!Equals(fieldOfView, mFieldOfView))
   {
     mFieldOfView = fieldOfView;
@@ -285,6 +288,7 @@ float CameraActor::GetFieldOfView() const
 
 void CameraActor::SetAspectRatio(float aspectRatio)
 {
+  mPropertyChanged = true;
   if(!Equals(aspectRatio, mAspectRatio))
   {
     mAspectRatio = aspectRatio;
@@ -301,6 +305,7 @@ float CameraActor::GetAspectRatio() const
 
 void CameraActor::SetNearClippingPlane(float nearClippingPlane)
 {
+  mPropertyChanged = true;
   if(!Equals(nearClippingPlane, mNearClippingPlane))
   {
     mNearClippingPlane = nearClippingPlane;
@@ -317,6 +322,7 @@ float CameraActor::GetNearClippingPlane() const
 
 void CameraActor::SetFarClippingPlane(float farClippingPlane)
 {
+  mPropertyChanged = true;
   if(!Equals(farClippingPlane, mFarClippingPlane))
   {
     mFarClippingPlane = farClippingPlane;
@@ -333,6 +339,7 @@ float CameraActor::GetFarClippingPlane() const
 
 void CameraActor::SetLeftClippingPlane(float leftClippingPlane)
 {
+  mPropertyChanged = true;
   if(!Equals(leftClippingPlane, mLeftClippingPlane))
   {
     mLeftClippingPlane = leftClippingPlane;
@@ -344,6 +351,7 @@ void CameraActor::SetLeftClippingPlane(float leftClippingPlane)
 
 void CameraActor::SetRightClippingPlane(float rightClippingPlane)
 {
+  mPropertyChanged = true;
   if(!Equals(rightClippingPlane, mRightClippingPlane))
   {
     mRightClippingPlane = rightClippingPlane;
@@ -355,6 +363,7 @@ void CameraActor::SetRightClippingPlane(float rightClippingPlane)
 
 void CameraActor::SetTopClippingPlane(float topClippingPlane)
 {
+  mPropertyChanged = true;
   if(!Equals(topClippingPlane, mTopClippingPlane))
   {
     mTopClippingPlane = topClippingPlane;
@@ -366,6 +375,7 @@ void CameraActor::SetTopClippingPlane(float topClippingPlane)
 
 void CameraActor::SetBottomClippingPlane(float bottomClippingPlane)
 {
+  mPropertyChanged = true;
   if(!Equals(bottomClippingPlane, mBottomClippingPlane))
   {
     mBottomClippingPlane = bottomClippingPlane;
@@ -575,28 +585,14 @@ void CameraActor::SetDefaultProperty(Property::Index index, const Property::Valu
     {
       case Dali::CameraActor::Property::TYPE:
       {
-        std::string s(propertyValue.Get<std::string>());
-        if(s == "LOOK_AT_TARGET")
-        {
-          SetType(Dali::Camera::LOOK_AT_TARGET);
-        }
-        else if(s == "FREE_LOOK")
-        {
-          SetType(Dali::Camera::FREE_LOOK);
-        }
+        Dali::Camera::Type cameraType = Dali::Camera::Type(propertyValue.Get<int>());
+        SetType(cameraType);
         break;
       }
       case Dali::CameraActor::Property::PROJECTION_MODE:
       {
-        std::string s(propertyValue.Get<std::string>());
-        if(s == "PERSPECTIVE_PROJECTION")
-        {
-          SetProjectionMode(Dali::Camera::PERSPECTIVE_PROJECTION);
-        }
-        else if(s == "ORTHOGRAPHIC_PROJECTION")
-        {
-          SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION);
-        }
+        Dali::Camera::ProjectionMode projectionMode = Dali::Camera::ProjectionMode(propertyValue.Get<int>());
+        SetProjectionMode(projectionMode);
         break;
       }
       case Dali::CameraActor::Property::FIELD_OF_VIEW:
@@ -688,26 +684,12 @@ Property::Value CameraActor::GetDefaultProperty(Property::Index index) const
     {
       case Dali::CameraActor::Property::TYPE:
       {
-        if(Dali::Camera::LOOK_AT_TARGET == mType)
-        {
-          ret = "LOOK_AT_TARGET";
-        }
-        else if(Dali::Camera::FREE_LOOK == mType)
-        {
-          ret = "FREE_LOOK";
-        }
+        ret = mType;
         break;
       }
       case Dali::CameraActor::Property::PROJECTION_MODE:
       {
-        if(Dali::Camera::PERSPECTIVE_PROJECTION == mProjectionMode)
-        {
-          ret = "PERSPECTIVE_PROJECTION";
-        }
-        else if(Dali::Camera::ORTHOGRAPHIC_PROJECTION == mProjectionMode)
-        {
-          ret = "ORTHOGRAPHIC_PROJECTION";
-        }
+        ret = mProjectionMode;
         break;
       }
       case Dali::CameraActor::Property::FIELD_OF_VIEW:
@@ -817,6 +799,19 @@ const PropertyInputImpl* CameraActor::GetSceneObjectInputProperty(Property::Inde
   return property;
 }
 
+void CameraActor::OnPropertySet(Property::Index index, const Property::Value& propertyValue)
+{
+  // If Position or Orientation are explicitly set, make mPropertyChanged flag true.
+  if(index == Dali::Actor::Property::POSITION ||
+     index == Dali::Actor::Property::POSITION_X ||
+     index == Dali::Actor::Property::POSITION_Y ||
+     index == Dali::Actor::Property::POSITION_Z ||
+     index == Dali::Actor::Property::ORIENTATION)
+  {
+    mPropertyChanged = true;
+  }
+}
+
 } // namespace Internal
 
 } // namespace Dali

diff --git a/dali/internal/event/actors/camera-actor-impl.h b/dali/internal/event/actors/camera-actor-impl.h
index 6d0bb17..2869b59 100644 (file)
--- a/dali/internal/event/actors/camera-actor-impl.h
+++ b/dali/internal/event/actors/camera-actor-impl.h
@@ -251,6 +251,11 @@ private:
    */
   void OnSceneConnectionInternal() override;
 
+  /**
+   * @copydoc Internal::Object::OnPropertySet
+   */
+  void OnPropertySet(Property::Index index, const Property::Value& propertyValue) override;
+
 private:                                  // Data
   const SceneGraph::Camera* mSceneObject; ///< Not owned
 
@@ -267,6 +272,7 @@ private:                                  // Data
   float                        mTopClippingPlane;
   float                        mBottomClippingPlane;
   bool                         mInvertYAxis;
+  bool                         mPropertyChanged;
 };
 
 } // namespace Internal