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;
}
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;
}
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;
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;
}
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);
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);
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);
{"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},
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;
+}
*/
// 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 )
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)
{
}
{
// 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)
{
void CameraActor::SetTarget(const Vector3& target)
{
+ mPropertyChanged = true;
if(target != mTarget) // using range epsilon
{
mTarget = target;
void CameraActor::SetFieldOfView(float fieldOfView)
{
+ mPropertyChanged = true;
if(!Equals(fieldOfView, mFieldOfView))
{
mFieldOfView = fieldOfView;
void CameraActor::SetAspectRatio(float aspectRatio)
{
+ mPropertyChanged = true;
if(!Equals(aspectRatio, mAspectRatio))
{
mAspectRatio = aspectRatio;
void CameraActor::SetNearClippingPlane(float nearClippingPlane)
{
+ mPropertyChanged = true;
if(!Equals(nearClippingPlane, mNearClippingPlane))
{
mNearClippingPlane = nearClippingPlane;
void CameraActor::SetFarClippingPlane(float farClippingPlane)
{
+ mPropertyChanged = true;
if(!Equals(farClippingPlane, mFarClippingPlane))
{
mFarClippingPlane = farClippingPlane;
void CameraActor::SetLeftClippingPlane(float leftClippingPlane)
{
+ mPropertyChanged = true;
if(!Equals(leftClippingPlane, mLeftClippingPlane))
{
mLeftClippingPlane = leftClippingPlane;
void CameraActor::SetRightClippingPlane(float rightClippingPlane)
{
+ mPropertyChanged = true;
if(!Equals(rightClippingPlane, mRightClippingPlane))
{
mRightClippingPlane = rightClippingPlane;
void CameraActor::SetTopClippingPlane(float topClippingPlane)
{
+ mPropertyChanged = true;
if(!Equals(topClippingPlane, mTopClippingPlane))
{
mTopClippingPlane = topClippingPlane;
void CameraActor::SetBottomClippingPlane(float bottomClippingPlane)
{
+ mPropertyChanged = true;
if(!Equals(bottomClippingPlane, mBottomClippingPlane))
{
mBottomClippingPlane = bottomClippingPlane;
{
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:
{
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:
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