/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <stdlib.h>
#include <cmath>
#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/object/handle-devel.h>
+#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/devel-api/actors/camera-actor-devel.h>
#include "dali-test-suite-utils/dali-test-suite-utils.h"
" gl_FragColor = vec4(uShadowColor.rgb, uShadowColor.a * alpha);\n"
"}\n";
+struct PropertyDetails
+{
+ std::string name; ///< The name of the property.
+ Property::Type type; ///< The property type.
+ bool writable; ///< Whether the property is writable
+ bool animatable; ///< Whether the property is animatable.
+ bool constraintInput; ///< Whether the property can be used as an input to a constraint.
+ Property::Index enumIndex; ///< Used to check the index is correct within a debug build.
+};
+
} // Anonymous namespace
END_TEST;
}
+int UtcDaliCameraActorNewDefaultPerspectiveProjection(void)
+{
+ TestApplication application;
+ tet_infoline( "Test the perspective projection of a camera actor is set appropriately when not passing in a size" );
+
+ CameraActor actor = CameraActor::New();
+ DALI_TEST_CHECK( actor );
+
+ // All the properties should still be the default values
+ // Defaults taken from scene-graph-camera.cpp
+ DALI_TEST_EQUALS( 4.0f/3.0f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 45.0f*(Math::PI/180.0f), actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 3.0f * 800.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 0.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+
+ // Add it to the stage, then the values should be updated to reflect a 480.0f by 800.0f scene (default stage size)
+ application.GetScene().Add( actor );
+
+ DALI_TEST_EQUALS( 0.6f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 0.489957f, actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 4895.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 1600.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+
+ // Ensure the values stay the same after update/render
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS( 0.6f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 0.489957f, actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 4895.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 1600.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+
+ END_TEST;
+}
+
// Note: No negative test for UtcDaliCameraActorNew.
int UtcDaliCameraActorDownCastP(void)
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", DevelHandle::GetCurrentProperty< std::string >( actor, CameraActor::Property::TYPE ), TEST_LOCATION );
+ DALI_TEST_EQUALS( "LOOK_AT_TARGET", actor.GetCurrentProperty< std::string >( CameraActor::Property::TYPE ), TEST_LOCATION );
END_TEST;
}
CameraActor defaultCamera = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
const float defaultFieldOfView = defaultCamera.GetFieldOfView();
- CameraActor actor = CameraActor::New();
+ CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
DALI_TEST_EQUALS( actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION );
float fieldOfView = Math::PI / 3.0f;
CameraActor defaultCamera = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
const float defaultFieldOfView = defaultCamera.GetFieldOfView();
- CameraActor actor = CameraActor::New();
+ CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
DALI_TEST_EQUALS( actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION );
float fieldOfView = Math::PI / 3.0f;
const float cameraZ = 2.0f * std::max( size.width, size.height );
const float expectedFieldOfView = 2.0f * std::atan( size.height * 0.5f / cameraZ );
- CameraActor actor = CameraActor::New();
+ CameraActor actor = CameraActor::New( size );
DALI_TEST_EQUALS( actor.GetFieldOfView(), expectedFieldOfView, TEST_LOCATION );
float value;
TestApplication application;
tet_infoline( "Testing Dali::CameraActor Set Aspect Ratio (P)" );
- CameraActor actor = CameraActor::New();
+ CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
DALI_TEST_EQUALS( actor.GetAspectRatio(), static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ) / static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT ), TEST_LOCATION );
// Set an initial value to confirm a further set changes it.
TestApplication application;
tet_infoline("Testing Dali::CameraActor Get Aspect Ratio");
- CameraActor actor = CameraActor::New();
+ CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
float defaultAspect = static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ) / static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT );
DALI_TEST_EQUALS( actor.GetAspectRatio(), defaultAspect, TEST_LOCATION );
TestApplication application;
tet_infoline( "Testing Dali::CameraActor Get Far clipping plane (P)" );
- CameraActor actor = CameraActor::New();
+ CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
float defaultValue = 800.0f + ( 0xFFFF >> 4 );
DALI_TEST_EQUALS( actor.GetFarClippingPlane(), defaultValue, TEST_LOCATION );
DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+ // Ensure these values persist after adding to the stage and an update/render pass
+ application.GetScene().Add( actor );
+ application.SendNotification();
+ application.Render();
+
+ actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
+ DALI_TEST_EQUALS( 0.666666f, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
+ DALI_TEST_EQUALS( 0.489957f, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
+ DALI_TEST_EQUALS( 150.f, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
+ DALI_TEST_EQUALS( 4245.f, value, FLOAT_EPSILON, TEST_LOCATION );
+
+ // Call method with a ZERO size, this should reset the perspective projection using the size of the scene we've been added to
+ actor.SetPerspectiveProjection( Vector2::ZERO );
+
+ DALI_TEST_EQUALS( 0.6f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 0.489957f, actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 4895.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( 1600.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+
END_TEST;
}
TestApplication application;
tet_infoline( "Testing Dali::CameraActor::SetPerspectiveProjection (N)" );
- Stage stage = Stage::GetCurrent();
- Vector2 stageSize = stage.GetSize();
-
CameraActor actor = CameraActor::New();
- // Check that setting perspective projection without a size (using zero size) uses the stages size.
+ // Check that setting perspective projection without a size does not do anything.
actor.SetPerspectiveProjection( Size::ZERO );
- float nearClippingPlane = std::max( stageSize.width, stageSize.height );
- float farClippingPlane = nearClippingPlane + static_cast<float>( 0xFFFF >> 4 );
+ // So the default values should be the same as defined in CameraActor
+ float nearClippingPlane = 800.0f;
+ float farClippingPlane = nearClippingPlane + 2.0f * nearClippingPlane;
DALI_TEST_EQUALS( nearClippingPlane, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
DALI_TEST_EQUALS( farClippingPlane, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
CameraActor actor = CameraActor::New( Size( 1080.0f, 1920.0f ) );
DALI_TEST_CHECK( actor );
- Stage::GetCurrent().Add( actor );
+ application.GetScene().Add( actor );
actor.SetOrthographicProjection( Size( 1080.0f, 1920.0f ) );
application.SendNotification();
actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
- Vector3 defaultPos = actor.GetCurrentPosition();
+ Vector3 defaultPos = actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
actor.SetOrthographicProjection( Size( 1080.0f, 1920.0f ) );
actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
DALI_TEST_EQUALS( -960.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- Vector3 pos = actor.GetCurrentPosition();
+ Vector3 pos = actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
DALI_TEST_EQUALS( defaultPos.z, pos.z, 0.001f, TEST_LOCATION );
DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
tet_infoline( "Testing Dali::CameraActor::SetCamera()" );
CameraActor actor = CameraActor::New();
- Stage::GetCurrent().Add( actor );
+ application.GetScene().Add( actor );
application.Render( 0 );
application.SendNotification();
tet_infoline( "Testing Dali::CameraActor DefaultProperties" );
CameraActor actor = CameraActor::New();
- Stage stage = Stage::GetCurrent();
+ Integration::Scene stage = application.GetScene();
stage.Add(actor);
stage.GetRenderTaskList().GetTask(0).SetCameraActor( actor );
actor.SetAspectRatio( TEST_ASPECT_RATIO );
- Stage::GetCurrent().Add( actor );
+ application.GetScene().Add( actor );
application.Render( 0 );
application.SendNotification();
bool bValue;
END_TEST;
}
+template< typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
+void TEST_CAMERA_PROPERTY( P1 camera, P2 stringName, P3 type, P4 isWriteable, P5 isAnimateable, P6 isConstraintInput, P7 enumName, P8 LOCATION )
+{
+ DALI_TEST_EQUALS( camera.GetPropertyName( enumName ), stringName, LOCATION );
+ DALI_TEST_EQUALS( camera.GetPropertyIndex( stringName ), static_cast<Property::Index>(enumName), LOCATION );
+ DALI_TEST_EQUALS( camera.GetPropertyType( enumName ), type, LOCATION );
+ DALI_TEST_EQUALS( camera.IsPropertyWritable( enumName ), isWriteable, LOCATION );
+ DALI_TEST_EQUALS( camera.IsPropertyAnimatable( enumName ), isAnimateable, LOCATION );
+ DALI_TEST_EQUALS( camera.IsPropertyAConstraintInput( enumName ), isConstraintInput, LOCATION );
+}
+int UtcDaliCameraActorDefaultPropertiesInherited(void)
+{
+ TestApplication application;
+
+ CameraActor actor = CameraActor::New();
+ Integration::Scene stage = application.GetScene();
+ stage.Add(actor);
+ stage.GetRenderTaskList().GetTask(0).SetCameraActor( actor );
+
+ application.GetScene().Add( actor );
+ application.Render( 0 );
+ application.SendNotification();
+
+ const PropertyDetails CAMERA_DEFAULT_PROPERTY[] =
+ {
+// actor
+ { "parentOrigin", Property::VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN },
+ { "parentOriginX", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X },
+ { "parentOriginY", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y },
+ { "parentOriginZ", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z },
+ { "anchorPoint", Property::VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT },
+ { "anchorPointX", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X },
+ { "anchorPointY", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y },
+ { "anchorPointZ", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z },
+ { "size", Property::VECTOR3, true, true, true, Dali::Actor::Property::SIZE },
+ { "sizeWidth", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH },
+ { "sizeHeight", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT },
+ { "sizeDepth", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH },
+ { "position", Property::VECTOR3, true, true, true, Dali::Actor::Property::POSITION },
+ { "positionX", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_X },
+ { "positionY", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y },
+ { "positionZ", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z },
+ { "worldPosition", Property::VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION },
+ { "worldPositionX", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X },
+ { "worldPositionY", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y },
+ { "worldPositionZ", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z },
+ { "orientation", Property::ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION },
+ { "worldOrientation", Property::ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION },
+ { "scale", Property::VECTOR3, true, true, true, Dali::Actor::Property::SCALE },
+ { "scaleX", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_X },
+ { "scaleY", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y },
+ { "scaleZ", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z },
+ { "worldScale", Property::VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE },
+ { "visible", Property::BOOLEAN, true, true, true, Dali::Actor::Property::VISIBLE },
+ { "color", Property::VECTOR4, true, true, true, Dali::Actor::Property::COLOR },
+ { "colorRed", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED },
+ { "colorGreen", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN },
+ { "colorBlue", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE },
+ { "colorAlpha", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA },
+ { "worldColor", Property::VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR },
+ { "worldMatrix", Property::MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX },
+ { "name", Property::STRING, true, false, false, Dali::Actor::Property::NAME },
+ { "sensitive", Property::BOOLEAN, true, false, false, Dali::Actor::Property::SENSITIVE },
+ { "leaveRequired", Property::BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED },
+ { "inheritOrientation", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION },
+ { "inheritScale", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE },
+ { "colorMode", Property::INTEGER, true, false, false, Dali::Actor::Property::COLOR_MODE },
+ { "drawMode", Property::INTEGER, true, false, false, Dali::Actor::Property::DRAW_MODE },
+ { "sizeModeFactor", Property::VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR },
+ { "widthResizePolicy", Property::STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY },
+ { "heightResizePolicy", Property::STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY },
+ { "sizeScalePolicy", Property::INTEGER, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY },
+ { "widthForHeight", Property::BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT },
+ { "heightForWidth", Property::BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH },
+ { "padding", Property::VECTOR4, true, false, false, Dali::Actor::Property::PADDING },
+ { "minimumSize", Property::VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE },
+ { "maximumSize", Property::VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE },
+ { "inheritPosition", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_POSITION },
+ { "clippingMode", Property::STRING, true, false, false, Dali::Actor::Property::CLIPPING_MODE },
+ { "layoutDirection", Property::STRING, true, false, false, Dali::Actor::Property::LAYOUT_DIRECTION },
+ { "inheritLayoutDirection", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION },
+ { "opacity", Property::FLOAT, true, true, true, Dali::Actor::Property::OPACITY },
+ { "screenPosition", Property::VECTOR2, false, false, false, Dali::Actor::Property::SCREEN_POSITION },
+ { "positionUsesAnchorPoint",Property::BOOLEAN, true, false, false, Dali::Actor::Property::POSITION_USES_ANCHOR_POINT },
+ { "culled", Property::BOOLEAN, false, false, true, Dali::Actor::Property::CULLED },
+ { "id", Property::INTEGER, false, false, false, Dali::Actor::Property::ID },
+ { "hierarchyDepth", Property::INTEGER, false, false, false, Dali::Actor::Property::HIERARCHY_DEPTH },
+ { "isRoot", Property::BOOLEAN, false, false, false, Dali::Actor::Property::IS_ROOT },
+ { "isLayer", Property::BOOLEAN, false, false, false, Dali::Actor::Property::IS_LAYER },
+ { "connectedToScene", Property::BOOLEAN, false, false, false, Dali::Actor::Property::CONNECTED_TO_SCENE },
+ { "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 },
+ { "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 },
+ { "farPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::FAR_PLANE_DISTANCE },
+ { "leftPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::LEFT_PLANE_DISTANCE },
+ { "rightPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE },
+ { "topPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::TOP_PLANE_DISTANCE },
+ { "bottomPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE },
+ { "targetPosition", Property::VECTOR3, true, false, true, Dali::CameraActor::Property::TARGET_POSITION },
+ { "projectionMatrix", Property::MATRIX, false, false, true, Dali::CameraActor::Property::PROJECTION_MATRIX },
+ { "viewMatrix", Property::MATRIX, false, false, true, Dali::CameraActor::Property::VIEW_MATRIX },
+ { "invertYAxis", Property::BOOLEAN, true, false, true, Dali::CameraActor::Property::INVERT_Y_AXIS }
+ };
+
+ for( uint32_t index = 0; index < (sizeof(CAMERA_DEFAULT_PROPERTY)/sizeof(PropertyDetails)); ++index )
+ {
+ TEST_CAMERA_PROPERTY( actor,
+ CAMERA_DEFAULT_PROPERTY[ index ].name,
+ CAMERA_DEFAULT_PROPERTY[ index ].type,
+ CAMERA_DEFAULT_PROPERTY[ index ].writable,
+ CAMERA_DEFAULT_PROPERTY[ index ].animatable,
+ CAMERA_DEFAULT_PROPERTY[ index ].constraintInput,
+ CAMERA_DEFAULT_PROPERTY[ index ].enumIndex,
+ TEST_LOCATION );
+ }
+ END_TEST;
+}
+
int UtcDaliCameraActorModelView(void)
{
TestApplication application;
tet_infoline( "Testing Dali::CameraActor Test view application" );
- BufferImage image = CreateBufferImage();
-
- Actor actor = CreateRenderableActor(image);
- actor.SetSize( 100.0f, 100.0f );
- actor.SetPosition( 20.0f, 30.0f, 40.0f );
- actor.SetParentOrigin( ParentOrigin::CENTER );
- Stage::GetCurrent().Add( actor );
+ Actor actor = CreateRenderableActor();
+ actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+ actor.SetProperty( Actor::Property::POSITION, Vector3( 20.0f, 30.0f, 40.0f ));
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ application.GetScene().Add( actor );
application.SendNotification();
application.Render( 0 );
application.SendNotification();
Matrix resultMatrix( true );
- resultMatrix.SetTransformComponents( Vector3::ONE, Quaternion::IDENTITY, actor.GetCurrentPosition() );
+ resultMatrix.SetTransformComponents( Vector3::ONE, Quaternion::IDENTITY, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ) );
- RenderTask task = Stage::GetCurrent().GetRenderTaskList().GetTask( 0 );
+ RenderTask task = application.GetScene().GetRenderTaskList().GetTask( 0 );
CameraActor cameraActor = task.GetCameraActor();
Matrix viewMatrix( false );
TestApplication application;
tet_infoline( "Testing Dali::CameraActor::ReadProjectionMatrix()" );
- CameraActor camera = Stage::GetCurrent().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
+ CameraActor camera = application.GetScene().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
application.SendNotification();
application.Render( 0 );
application.Render();
application.SendNotification();
- Image image = CreateBufferImage();
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 4u, 4u);
Actor actor = CreateRenderableActor( image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE );
- actor.SetSize( 100.0f, 100.0f );
- Stage::GetCurrent().Add( actor );
+ actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+ application.GetScene().Add( actor );
Matrix projectionMatrix;
Matrix viewMatrix;
TestApplication application;
tet_infoline( "Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()" );
- CameraActor camera = Stage::GetCurrent().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
+ CameraActor camera = application.GetScene().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
Actor actor = Actor::New();
- actor.SetSize( 100.0f, 100.0f );
- Stage::GetCurrent().Add( actor );
+ actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+ application.GetScene().Add( actor );
Constraint constraint = Constraint::New<Dali::Vector3>( actor, Actor::Property::POSITION, EqualToConstraint() );
constraint.AddSource( Source( camera, Actor::Property::POSITION ) );
constraint.Apply();
- camera.SetPosition( 100.0f, 200.0f, 300.0f );
+ camera.SetProperty( Actor::Property::POSITION, Vector3( 100.0f, 200.0f, 300.0f ));
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3( 100.0f, 200.0f, 300.0f ), TEST_LOCATION);
+ DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 100.0f, 200.0f, 300.0f ), TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorPropertyIndices(void)
{
TestApplication application;
- CameraActor camera = Stage::GetCurrent().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
+ CameraActor camera = application.GetScene().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
Actor basicActor = Actor::New();
Property::IndexContainer indices;
int UtcDaliCameraActorCheckLookAtAndFreeLookViews01(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Integration::Scene stage = application.GetScene();
Vector2 stageSize = stage.GetSize();
CameraActor freeLookCameraActor = CameraActor::New( stageSize );
- freeLookCameraActor.SetParentOrigin( ParentOrigin::CENTER );
+ freeLookCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
freeLookCameraActor.SetType( Camera::FREE_LOOK );
Vector3 targetPosition( 30.0f, 240.0f, -256.0f );
Actor target = Actor::New();
- target.SetParentOrigin( ParentOrigin::CENTER );
- target.SetPosition( targetPosition );
+ target.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ target.SetProperty( Actor::Property::POSITION, targetPosition );
Constraint cameraOrientationConstraint = Constraint::New<Quaternion> ( freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt );
cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_POSITION ) );
CameraActor lookAtCameraActor = CameraActor::New( stageSize );
lookAtCameraActor.SetType( Camera::LOOK_AT_TARGET );
lookAtCameraActor.SetTargetPosition( targetPosition );
- lookAtCameraActor.SetParentOrigin( ParentOrigin::CENTER );
+ lookAtCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
stage.Add( target );
stage.Add( freeLookCameraActor );
position.Normalize();
position *= 200.0f;
- freeLookCameraActor.SetPosition( position );
- lookAtCameraActor.SetPosition( position );
+ freeLookCameraActor.SetProperty( Actor::Property::POSITION, position );
+ lookAtCameraActor.SetProperty( Actor::Property::POSITION, position );
application.SendNotification();
application.Render();
int UtcDaliCameraActorCheckLookAtAndFreeLookViews02(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Integration::Scene stage = application.GetScene();
Vector2 stageSize = stage.GetSize();
CameraActor freeLookCameraActor = CameraActor::New( stageSize );
- freeLookCameraActor.SetParentOrigin( ParentOrigin::CENTER );
+ freeLookCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
freeLookCameraActor.SetType( Camera::FREE_LOOK );
Vector3 targetPosition( 30.0f, 240.0f, -256.0f );
Actor target = Actor::New();
- target.SetParentOrigin( ParentOrigin::CENTER );
- target.SetPosition( targetPosition );
+ target.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ target.SetProperty( Actor::Property::POSITION, targetPosition );
Constraint cameraOrientationConstraint = Constraint::New<Quaternion> ( freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt );
cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_POSITION ) );
CameraActor lookAtCameraActor = CameraActor::New( stageSize );
lookAtCameraActor.SetType( Camera::LOOK_AT_TARGET );
lookAtCameraActor.SetTargetPosition( targetPosition );
- lookAtCameraActor.SetParentOrigin( ParentOrigin::CENTER );
+ lookAtCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
stage.Add( target );
stage.Add( freeLookCameraActor );
position.Normalize();
position *= 200.0f;
- freeLookCameraActor.SetPosition( position );
- lookAtCameraActor.SetPosition( position );
+ freeLookCameraActor.SetProperty( Actor::Property::POSITION, position );
+ lookAtCameraActor.SetProperty( Actor::Property::POSITION, position );
application.SendNotification();
application.Render();
Matrix freeLookViewMatrix;
freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
- Matrix freeLookWorld = freeLookCameraActor.GetCurrentWorldMatrix();
+ Matrix freeLookWorld = freeLookCameraActor.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
Matrix freeLookTest( false );
Matrix::Multiply( freeLookTest, freeLookViewMatrix, freeLookWorld );
int UtcDaliCameraActorCheckLookAtAndFreeLookViews03(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Integration::Scene stage = application.GetScene();
Vector2 stageSize = stage.GetSize();
Vector3 targetPosition( Vector3::ZERO );
CameraActor freeLookCameraActor = CameraActor::New( stageSize );
freeLookCameraActor.SetType( Camera::FREE_LOOK );
- freeLookCameraActor.SetParentOrigin( ParentOrigin::CENTER );
+ freeLookCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
Quaternion cameraOrientation( Radian( Degree( 180.0f ) ), Vector3::YAXIS );
- freeLookCameraActor.SetPosition( cameraOffset );
- freeLookCameraActor.SetOrientation( cameraOrientation );
+ freeLookCameraActor.SetProperty( Actor::Property::POSITION, cameraOffset );
+ freeLookCameraActor.SetProperty( Actor::Property::ORIENTATION, cameraOrientation );
Actor cameraAnchor = Actor::New();
cameraAnchor.Add( freeLookCameraActor );
{
Quaternion rotation( Radian( Degree( angle ) ), Vector3::YAXIS );
- freeLookCameraActor.SetPosition( rotation.Rotate( cameraOffset ) );
- cameraAnchor.SetOrientation( rotation );
+ freeLookCameraActor.SetProperty( Actor::Property::POSITION, rotation.Rotate( cameraOffset ) );
+ cameraAnchor.SetProperty( Actor::Property::ORIENTATION, rotation );
application.SendNotification();
application.Render();
Matrix freeLookViewMatrix;
freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
- Matrix freeLookWorld = freeLookCameraActor.GetCurrentWorldMatrix();
+ Matrix freeLookWorld = freeLookCameraActor.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
Matrix freeLookTest( false );
Matrix::Multiply( freeLookTest, freeLookViewMatrix, freeLookWorld );
}
END_TEST;
}
+
+int UtcDaliCameraActorReflectionByPlane(void)
+{
+ TestApplication application;
+
+ Integration::Scene stage = application.GetScene();
+
+ Vector3 targetPosition( Vector3::ZERO );
+ Vector3 cameraOffset( 0.0f, 100.0f, 100.0f );
+
+ CameraActor freeLookCameraActor = stage.GetRenderTaskList().GetTask(0).GetCameraActor();
+ freeLookCameraActor.SetType(Camera::LOOK_AT_TARGET);
+ freeLookCameraActor.SetTargetPosition( targetPosition );
+ freeLookCameraActor.SetProperty( Actor::Property::POSITION, cameraOffset );
+
+ stage.GetRootLayer().SetProperty( Actor::Property::POSITION, Vector2( 1, 0 ));
+
+ application.SendNotification();
+ application.Render();
+ application.SendNotification();
+ application.Render();
+
+ Matrix matrixBefore, matrixAfter;
+ freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( matrixBefore );
+ freeLookCameraActor.SetProperty( Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4( 0.0f, 1.0f, 0.0f, 0.0f));
+ stage.GetRootLayer().SetProperty( Actor::Property::POSITION, Vector2( 0, 0 ));
+ application.SendNotification();
+ application.Render();
+ application.SendNotification();
+ application.Render();
+
+ freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( matrixAfter );
+
+ Vector3 position, scale;
+ Quaternion rotation;
+ matrixAfter.GetTransformComponents( position, rotation, scale );
+
+ Quaternion reflected( 0, 0, 1, 0 );
+
+ DALI_TEST_EQUALS( reflected, rotation, 0.01f, TEST_LOCATION );
+
+ // Test Free Look camera
+ freeLookCameraActor.SetType(Camera::FREE_LOOK);
+
+ // Make sure the recalculation will take place
+ freeLookCameraActor.SetProperty( Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4( 0.0f, 1.0f, 0.0f, 0.0f));
+
+ application.SendNotification();
+ application.Render();
+ application.SendNotification();
+ application.Render();
+
+ // Nothing should change despite of different camera type
+ matrixAfter.GetTransformComponents( position, rotation, scale );
+ DALI_TEST_EQUALS( reflected, rotation, 0.01f, TEST_LOCATION );
+
+ END_TEST;
+}
projects / platform / core / uifw / dali-core.git / blobdiff