X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Factors%2Fcamera-actor-impl.cpp;h=3383f007a309fc4c3e7eed6046ce3b011f952b97;hb=9697546f6395000a500259997c415d9ff3c2e337;hp=7ee2ef145b5c969a013d6d751991f5fdfbff0cc9;hpb=c3769f74185371208285cc135ea288ceb001e08c;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/actors/camera-actor-impl.cpp b/dali/internal/event/actors/camera-actor-impl.cpp index 7ee2ef1..3383f00 100644 --- a/dali/internal/event/actors/camera-actor-impl.cpp +++ b/dali/internal/event/actors/camera-actor-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2018 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. @@ -25,13 +25,13 @@ // INTERNAL INCLUDES #include #include -#include +#include #include #include #include #include #include -#include +#include namespace Dali { @@ -51,20 +51,20 @@ namespace */ DALI_PROPERTY_TABLE_BEGIN DALI_PROPERTY( "type", STRING, true, false, true, Dali::CameraActor::Property::TYPE ) -DALI_PROPERTY( "projection-mode", STRING, true, false, true, Dali::CameraActor::Property::PROJECTION_MODE ) -DALI_PROPERTY( "field-of-view", FLOAT, true, false, true, Dali::CameraActor::Property::FIELD_OF_VIEW ) -DALI_PROPERTY( "aspect-ratio", FLOAT, true, false, true, Dali::CameraActor::Property::ASPECT_RATIO ) -DALI_PROPERTY( "near-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::NEAR_PLANE_DISTANCE ) -DALI_PROPERTY( "far-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::FAR_PLANE_DISTANCE ) -DALI_PROPERTY( "left-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::LEFT_PLANE_DISTANCE ) -DALI_PROPERTY( "right-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE ) -DALI_PROPERTY( "top-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::TOP_PLANE_DISTANCE ) -DALI_PROPERTY( "bottom-plane-distance", FLOAT, true, false, true, Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE ) -DALI_PROPERTY( "target-position", VECTOR3, true, false, true, Dali::CameraActor::Property::TARGET_POSITION ) -DALI_PROPERTY( "projection-matrix", MATRIX, false, false, true, Dali::CameraActor::Property::PROJECTION_MATRIX ) -DALI_PROPERTY( "view-matrix", MATRIX, false, false, true, Dali::CameraActor::Property::VIEW_MATRIX ) -DALI_PROPERTY( "invert-y-axis", BOOLEAN, true, false, true, Dali::CameraActor::Property::INVERT_Y_AXIS ) -DALI_PROPERTY_TABLE_END( DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX ) +DALI_PROPERTY( "projectionMode", STRING, 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 ) +DALI_PROPERTY( "farPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::FAR_PLANE_DISTANCE ) +DALI_PROPERTY( "leftPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::LEFT_PLANE_DISTANCE ) +DALI_PROPERTY( "rightPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE ) +DALI_PROPERTY( "topPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::TOP_PLANE_DISTANCE ) +DALI_PROPERTY( "bottomPlaneDistance", FLOAT, true, false, true, Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE ) +DALI_PROPERTY( "targetPosition", VECTOR3, true, false, true, Dali::CameraActor::Property::TARGET_POSITION ) +DALI_PROPERTY( "projectionMatrix", MATRIX, false, false, true, Dali::CameraActor::Property::PROJECTION_MATRIX ) +DALI_PROPERTY( "viewMatrix", MATRIX, false, false, true, Dali::CameraActor::Property::VIEW_MATRIX ) +DALI_PROPERTY( "invertYAxis", BOOLEAN, true, false, true, Dali::CameraActor::Property::INVERT_Y_AXIS ) +DALI_PROPERTY_TABLE_END( DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, CameraDefaultProperties ) // calculate the far plane distance for a 16bit depth buffer with 4 bits per unit precision void CalculateClippingAndZ( float width, float height, float& nearClippingPlane, float& farClippingPlane, float& cameraZ ) @@ -79,7 +79,7 @@ BaseHandle Create() return Dali::CameraActor::New(); } -TypeRegistration mType( typeid( Dali::CameraActor ), typeid( Dali::Actor ), Create ); +TypeRegistration mType( typeid( Dali::CameraActor ), typeid( Dali::Actor ), Create, CameraDefaultProperties ); /** * Builds the picking ray in the world reference system from an orthographic camera @@ -112,8 +112,10 @@ void BuildOrthoPickingRay( const Matrix& viewMatrix, DALI_ASSERT_DEBUG( false ); } - Vector4 near( screenX - viewport.x, viewport.height - (screenY - viewport.y), 0.f, 1.f ); - if( !Unproject( near, invViewProjection, viewport.width, viewport.height, rayOrigin ) ) + Vector4 near( screenX - static_cast( viewport.x ), + static_cast( viewport.height ) - (screenY - static_cast( viewport.y ) ), + 0.f, 1.f ); + if( !Unproject( near, invViewProjection, static_cast( viewport.width ), static_cast( viewport.height ), rayOrigin ) ) { DALI_ASSERT_DEBUG( false ); } @@ -138,19 +140,12 @@ void BuildOrthoPickingRay( const Matrix& viewMatrix, CameraActorPtr CameraActor::New( const Size& size ) { - CameraActorPtr actor(new CameraActor()); + CameraActorPtr actor( new CameraActor( *CreateNode() ) ); // Second-phase construction - actor->Initialize(); - actor->SetName("DefaultCamera"); - - // Create the attachment - actor->mCameraAttachment = CameraAttachment::New( actor->GetEventThreadServices(), *actor->mNode ); - - actor->Attach(*actor->mCameraAttachment); - + actor->SetName( "DefaultCamera" ); actor->SetPerspectiveProjection( size ); // By default Actors face in the positive Z direction in world space @@ -160,97 +155,217 @@ CameraActorPtr CameraActor::New( const Size& size ) return actor; } +CameraActor::CameraActor( const SceneGraph::Node& node ) +: Actor( Actor::BASIC, node ), + mSceneObject( NULL ), + mTarget( SceneGraph::Camera::DEFAULT_TARGET_POSITION ), + mType( SceneGraph::Camera::DEFAULT_TYPE ), + mProjectionMode( SceneGraph::Camera::DEFAULT_MODE ), + mFieldOfView( SceneGraph::Camera::DEFAULT_FIELD_OF_VIEW ), + mAspectRatio( SceneGraph::Camera::DEFAULT_ASPECT_RATIO ), + mNearClippingPlane( SceneGraph::Camera::DEFAULT_NEAR_CLIPPING_PLANE ), + mFarClippingPlane( SceneGraph::Camera::DEFAULT_FAR_CLIPPING_PLANE ), + mLeftClippingPlane( SceneGraph::Camera::DEFAULT_LEFT_CLIPPING_PLANE ), + 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 ) +{ +} + +CameraActor::~CameraActor() +{ + if( EventThreadServices::IsCoreRunning() ) + { + // Create scene-object and transfer ownership through message + RemoveCameraMessage( GetEventThreadServices().GetUpdateManager(), mSceneObject ); + } +} + void CameraActor::OnInitialize() { + // Create scene-object and keep raw pointer for message passing. + SceneGraph::Camera* sceneGraphCamera = SceneGraph::Camera::New(); + + // Store a pointer to this camera node inside the scene-graph camera. + sceneGraphCamera->SetNode( &mNode ); + + mSceneObject = sceneGraphCamera; + OwnerPointer< SceneGraph::Camera > sceneGraphCameraOwner( sceneGraphCamera ); + + // Send message to inform update of this camera (and move ownership). + AddCameraMessage( GetEventThreadServices().GetUpdateManager(), sceneGraphCameraOwner ); } -CameraActor::CameraActor() -: Actor( Actor::BASIC ) +void CameraActor::SetTarget( const Vector3& target ) { + if( target != mTarget ) // using range epsilon + { + mTarget = target; + + SetTargetPositionMessage( GetEventThreadServices(), *mSceneObject, mTarget ); + } } -CameraActor::~CameraActor() +Vector3 CameraActor::GetTarget() const { + return mTarget; } void CameraActor::SetType( Dali::Camera::Type type ) { - mCameraAttachment->SetType(type); + if( type != mType ) + { + mType = type; + + // sceneObject is being used in a separate thread; queue a message to set + SetTypeMessage( GetEventThreadServices(), *mSceneObject, mType ); + } } Dali::Camera::Type CameraActor::GetType() const { - return mCameraAttachment->GetType(); + return mType; } void CameraActor::SetProjectionMode( Dali::Camera::ProjectionMode mode ) { - mCameraAttachment->SetProjectionMode(mode); + if( mode != mProjectionMode ) + { + mProjectionMode = mode; + + // sceneObject is being used in a separate thread; queue a message to set + SetProjectionModeMessage( GetEventThreadServices(), *mSceneObject, mProjectionMode ); + } } Dali::Camera::ProjectionMode CameraActor::GetProjectionMode() const { - return mCameraAttachment->GetProjectionMode(); + return mProjectionMode; } void CameraActor::SetFieldOfView( float fieldOfView ) { - mCameraAttachment->SetFieldOfView(fieldOfView); + if( ! Equals( fieldOfView, mFieldOfView ) ) + { + mFieldOfView = fieldOfView; + + // sceneObject is being used in a separate thread; queue a message to set + SetFieldOfViewMessage( GetEventThreadServices(), *mSceneObject, mFieldOfView ); + } } -float CameraActor::GetFieldOfView( ) const +float CameraActor::GetFieldOfView() const { - return mCameraAttachment->GetFieldOfView(); + return mFieldOfView; } void CameraActor::SetAspectRatio( float aspectRatio ) { - mCameraAttachment->SetAspectRatio(aspectRatio); + if( ! Equals( aspectRatio, mAspectRatio ) ) + { + mAspectRatio = aspectRatio; + + // sceneObject is being used in a separate thread; queue a message to set + SetAspectRatioMessage( GetEventThreadServices(), *mSceneObject, mAspectRatio ); + } } -float CameraActor::GetAspectRatio( ) const +float CameraActor::GetAspectRatio() const { - return mCameraAttachment->GetAspectRatio(); + return mAspectRatio; } void CameraActor::SetNearClippingPlane( float nearClippingPlane ) { - mCameraAttachment->SetNearClippingPlane(nearClippingPlane); + if( ! Equals( nearClippingPlane, mNearClippingPlane ) ) + { + mNearClippingPlane = nearClippingPlane; + + // sceneObject is being used in a separate thread; queue a message to set + SetNearClippingPlaneMessage( GetEventThreadServices(), *mSceneObject, mNearClippingPlane ); + } } -float CameraActor::GetNearClippingPlane( ) const +float CameraActor::GetNearClippingPlane() const { - return mCameraAttachment->GetNearClippingPlane(); + return mNearClippingPlane; } void CameraActor::SetFarClippingPlane( float farClippingPlane ) { - mCameraAttachment->SetFarClippingPlane(farClippingPlane); + if( ! Equals( farClippingPlane, mFarClippingPlane ) ) + { + mFarClippingPlane = farClippingPlane; + + // sceneObject is being used in a separate thread; queue a message to set + SetFarClippingPlaneMessage( GetEventThreadServices(), *mSceneObject, mFarClippingPlane ); + } } -float CameraActor::GetFarClippingPlane( ) const +float CameraActor::GetFarClippingPlane() const { - return mCameraAttachment->GetFarClippingPlane(); + return mFarClippingPlane; } -void CameraActor::SetTargetPosition(const Vector3& target) +void CameraActor::SetLeftClippingPlane( float leftClippingPlane ) { - mCameraAttachment->SetTargetPosition(target); + if( ! Equals( leftClippingPlane, mLeftClippingPlane ) ) + { + mLeftClippingPlane = leftClippingPlane; + + // sceneObject is being used in a separate thread; queue a message to set + SetLeftClippingPlaneMessage( GetEventThreadServices(), *mSceneObject, mLeftClippingPlane ); + } } -Vector3 CameraActor::GetTargetPosition() const +void CameraActor::SetRightClippingPlane( float rightClippingPlane ) { - return mCameraAttachment->GetTargetPosition(); + if( ! Equals( rightClippingPlane, mRightClippingPlane ) ) + { + mRightClippingPlane = rightClippingPlane; + + // sceneObject is being used in a separate thread; queue a message to set + SetRightClippingPlaneMessage( GetEventThreadServices(), *mSceneObject, mRightClippingPlane ); + } +} + +void CameraActor::SetTopClippingPlane( float topClippingPlane ) +{ + if( ! Equals( topClippingPlane, mTopClippingPlane ) ) + { + mTopClippingPlane = topClippingPlane; + + // sceneObject is being used in a separate thread; queue a message to set + SetTopClippingPlaneMessage( GetEventThreadServices(), *mSceneObject, mTopClippingPlane ); + } +} + +void CameraActor::SetBottomClippingPlane( float bottomClippingPlane ) +{ + if( ! Equals( bottomClippingPlane, mBottomClippingPlane ) ) + { + mBottomClippingPlane = bottomClippingPlane; + + // sceneObject is being used in a separate thread; queue a message to set + SetBottomClippingPlaneMessage( GetEventThreadServices(), *mSceneObject, mBottomClippingPlane ); + } } void CameraActor::SetInvertYAxis(bool invertYAxis) { - mCameraAttachment->SetInvertYAxis(invertYAxis); + if( invertYAxis != mInvertYAxis ) + { + mInvertYAxis = invertYAxis; + + // sceneObject is being used in a separate thread; queue a message to set + SetInvertYAxisMessage( GetEventThreadServices(), *mSceneObject, mInvertYAxis ); + } } bool CameraActor::GetInvertYAxis() const { - return mCameraAttachment->GetInvertYAxis(); + return mInvertYAxis; } void CameraActor::SetPerspectiveProjection( const Size& size, const Vector2& stereoBias /* = Vector2::ZERO */ ) @@ -299,7 +414,8 @@ void CameraActor::SetPerspectiveProjection( const Size& size, const Vector2& ste SetNearClippingPlane( nearClippingPlane ); SetFarClippingPlane( farClippingPlane ); SetAspectRatio( aspectRatio ); - mCameraAttachment->SetStereoBias( stereoBias ); + // sceneObject is being used in a separate thread; queue a message to set + SetStereoBiasMessage( GetEventThreadServices(), *mSceneObject, stereoBias ); SetZ( cameraZ ); } @@ -318,13 +434,13 @@ void CameraActor::SetOrthographicProjection( const Vector2& size ) void CameraActor::SetOrthographicProjection( float left, float right, float top, float bottom, float near, float far ) { - mCameraAttachment->SetLeftClippingPlane(left); - mCameraAttachment->SetRightClippingPlane(right); - mCameraAttachment->SetTopClippingPlane(top); - mCameraAttachment->SetBottomClippingPlane(bottom); + SetLeftClippingPlane( left ); + SetRightClippingPlane( right ); + SetTopClippingPlane( top ); + SetBottomClippingPlane( bottom ); SetNearClippingPlane( near ); SetFarClippingPlane( far ); - SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION); + SetProjectionMode( Dali::Camera::ORTHOGRAPHIC_PROJECTION ); } bool CameraActor::BuildPickingRay( const Vector2& screenCoordinates, @@ -333,20 +449,19 @@ bool CameraActor::BuildPickingRay( const Vector2& screenCoordinates, Vector4& rayDirection ) { bool success = true; - if( GetProjectionMode() == Dali::Camera::PERSPECTIVE_PROJECTION ) + if( mProjectionMode == Dali::Camera::PERSPECTIVE_PROJECTION ) { // Build a picking ray in the world reference system. // ray starts from the camera world position - rayOrigin = mNode->GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() ); + rayOrigin = mNode.GetWorldMatrix(0).GetTranslation(); rayOrigin.w = 1.0f; // Transform the touch point from the screen coordinate system to the world coordinates system. - Vector4 near( screenCoordinates.x - viewport.x, viewport.height - (screenCoordinates.y - viewport.y), 0.f, 1.f ); - if( !Unproject( near, mCameraAttachment->GetInverseViewProjectionMatrix(), viewport.width, viewport.height, near ) ) - { - // unproject failed so no picking ray possible - success = false; - } + Vector4 near( screenCoordinates.x - static_cast(viewport.x), + static_cast( viewport.height ) - (screenCoordinates.y - static_cast( viewport.y ) ), + 0.f, 1.f ); + const Matrix& inverseViewProjection = mSceneObject->GetInverseViewProjectionMatrix( GetEventThreadServices().GetEventBufferIndex() ); + success = Unproject( near, inverseViewProjection, static_cast( viewport.width ), static_cast( viewport.height ), near ); // Compute the ray's director vector. rayDirection.x = near.x - rayOrigin.x; @@ -374,7 +489,7 @@ const Matrix& CameraActor::GetViewMatrix() const { if ( OnStage() ) { - return mCameraAttachment->GetViewMatrix(); + return mSceneObject->GetViewMatrix( GetEventThreadServices().GetEventBufferIndex() ); } else { @@ -386,123 +501,16 @@ const Matrix& CameraActor::GetProjectionMatrix() const { if ( OnStage() ) { - return mCameraAttachment->GetProjectionMatrix(); + return mSceneObject->GetProjectionMatrix( GetEventThreadServices().GetEventBufferIndex() ); } else { return Matrix::IDENTITY; } } - -unsigned int CameraActor::GetDefaultPropertyCount() const -{ - return Actor::GetDefaultPropertyCount() + DEFAULT_PROPERTY_COUNT; -} - -void CameraActor::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const -{ - Actor::GetDefaultPropertyIndices( indices ); // Actor class properties - - indices.Reserve( indices.Size() + DEFAULT_PROPERTY_COUNT ); - - int index = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX; - for ( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i, ++index ) - { - indices.PushBack( index ); - } -} - -bool CameraActor::IsDefaultPropertyWritable( Property::Index index ) const -{ - if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT ) - { - return Actor::IsDefaultPropertyWritable( index ); - } - - return DEFAULT_PROPERTY_DETAILS[index - DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX].writable; -} - -bool CameraActor::IsDefaultPropertyAnimatable( Property::Index index ) const -{ - if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT ) - { - return Actor::IsDefaultPropertyAnimatable( index ); - } - - return DEFAULT_PROPERTY_DETAILS[index - DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX].animatable; -} - -bool CameraActor::IsDefaultPropertyAConstraintInput( Property::Index index ) const -{ - if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT ) - { - return Actor::IsDefaultPropertyAConstraintInput( index ); - } - - return DEFAULT_PROPERTY_DETAILS[index - DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX].constraintInput; -} - -Property::Type CameraActor::GetDefaultPropertyType( Property::Index index ) const -{ - if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT ) - { - return Actor::GetDefaultPropertyType( index ); - } - else - { - index -= DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX; - - if ( ( index >= 0 ) && ( index < DEFAULT_PROPERTY_COUNT ) ) - { - return DEFAULT_PROPERTY_DETAILS[index].type; - } - else - { - // index out-of-bounds - return Property::NONE; - } - } -} - -const char* CameraActor::GetDefaultPropertyName( Property::Index index ) const -{ - if(index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT) - { - return Actor::GetDefaultPropertyName(index); - } - else - { - index -= DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX; - - if ( ( index >= 0 ) && ( index < DEFAULT_PROPERTY_COUNT ) ) - { - return DEFAULT_PROPERTY_DETAILS[index].name; - } - return NULL; - } -} - -Property::Index CameraActor::GetDefaultPropertyIndex(const std::string& name) const +const SceneGraph::Camera* CameraActor::GetCamera() const { - Property::Index index = Property::INVALID_INDEX; - - // Look for name in current class' default properties - for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i ) - { - if( 0 == strcmp( name.c_str(), DEFAULT_PROPERTY_DETAILS[i].name ) ) // dont want to convert rhs to string - { - index = i + DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX; - break; - } - } - - // If not found, check in base class - if( Property::INVALID_INDEX == index ) - { - index = Actor::GetDefaultPropertyIndex( name ); - } - - return index; + return mSceneObject; } void CameraActor::SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) @@ -513,7 +521,6 @@ void CameraActor::SetDefaultProperty( Property::Index index, const Property::Val } else { - DALI_ASSERT_DEBUG(mCameraAttachment && "where is the camera?"); switch(index) { case Dali::CameraActor::Property::TYPE: @@ -521,98 +528,90 @@ void CameraActor::SetDefaultProperty( Property::Index index, const Property::Val std::string s( propertyValue.Get() ); if(s == "LOOK_AT_TARGET") { - mCameraAttachment->SetType(Dali::Camera::LOOK_AT_TARGET); + SetType( Dali::Camera::LOOK_AT_TARGET ); } else if(s == "FREE_LOOK") { - mCameraAttachment->SetType(Dali::Camera::FREE_LOOK); - } - else - { - DALI_LOG_WARNING("Unknown camera type\n"); + SetType( Dali::Camera::FREE_LOOK ); } break; } case Dali::CameraActor::Property::PROJECTION_MODE: { - std::string s(propertyValue.Get()); - if(s == "PERSPECTIVE_PROJECTION") - { - mCameraAttachment->SetProjectionMode(Dali::Camera::PERSPECTIVE_PROJECTION); - } - else if(s == "ORTHOGRAPHIC_PROJECTION") + std::string s( propertyValue.Get() ); + if( s == "PERSPECTIVE_PROJECTION" ) { - mCameraAttachment->SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION); + SetProjectionMode( Dali::Camera::PERSPECTIVE_PROJECTION ); } - else + else if( s == "ORTHOGRAPHIC_PROJECTION" ) { - DALI_LOG_WARNING("Unknown projection mode\n"); + SetProjectionMode( Dali::Camera::ORTHOGRAPHIC_PROJECTION ); } break; } case Dali::CameraActor::Property::FIELD_OF_VIEW: { - mCameraAttachment->SetFieldOfView(propertyValue.Get()); + SetFieldOfView( propertyValue.Get() ); // set to 0 in case property is not float break; } case Dali::CameraActor::Property::ASPECT_RATIO: { - mCameraAttachment->SetAspectRatio(propertyValue.Get()); + SetAspectRatio( propertyValue.Get() ); // set to 0 in case property is not float break; } - case Dali::CameraActor::Property::LEFT_PLANE_DISTANCE: + case Dali::CameraActor::Property::NEAR_PLANE_DISTANCE: { - mCameraAttachment->SetLeftClippingPlane(propertyValue.Get()); + SetNearClippingPlane( propertyValue.Get() ); // set to 0 in case property is not float break; } - case Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE: + case Dali::CameraActor::Property::FAR_PLANE_DISTANCE: { - mCameraAttachment->SetRightClippingPlane(propertyValue.Get()); + SetFarClippingPlane( propertyValue.Get() ); // set to 0 in case property is not float break; } - case Dali::CameraActor::Property::TOP_PLANE_DISTANCE: + case Dali::CameraActor::Property::LEFT_PLANE_DISTANCE: { - mCameraAttachment->SetTopClippingPlane(propertyValue.Get()); + SetLeftClippingPlane( propertyValue.Get() ); // set to 0 in case property is not float break; } - case Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE: + case Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE: { - mCameraAttachment->SetBottomClippingPlane(propertyValue.Get()); + SetRightClippingPlane( propertyValue.Get() ); // set to 0 in case property is not float break; } - case Dali::CameraActor::Property::NEAR_PLANE_DISTANCE: + case Dali::CameraActor::Property::TOP_PLANE_DISTANCE: { - mCameraAttachment->SetNearClippingPlane(propertyValue.Get()); + SetTopClippingPlane( propertyValue.Get() ); // set to 0 in case property is not float break; } - case Dali::CameraActor::Property::FAR_PLANE_DISTANCE: + case Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE: { - mCameraAttachment->SetFarClippingPlane(propertyValue.Get()); + SetBottomClippingPlane( propertyValue.Get() ); // set to 0 in case property is not float break; } case Dali::CameraActor::Property::TARGET_POSITION: { - mCameraAttachment->SetTargetPosition(propertyValue.Get()); + SetTarget( propertyValue.Get() ); // set to 0 in case property is not Vector3 break; } case Dali::CameraActor::Property::PROJECTION_MATRIX: { - DALI_LOG_WARNING("projection-matrix property is not animatable \n"); + DALI_LOG_WARNING( "projection-matrix is read-only\n" ); break; } case Dali::CameraActor::Property::VIEW_MATRIX: { - DALI_LOG_WARNING("view-matrix property is not animatable \n"); + DALI_LOG_WARNING( "view-matrix is read-only\n" ); break; } case Dali::CameraActor::Property::INVERT_Y_AXIS: { - mCameraAttachment->SetInvertYAxis(propertyValue.Get()); + SetInvertYAxis( propertyValue.Get() ); // set to false in case property is not bool break; } default: { - DALI_LOG_WARNING("Unknown property (%d)\n", index); + DALI_LOG_WARNING( "Unknown property (%d)\n", index ); break; } } // switch(index) @@ -623,112 +622,96 @@ void CameraActor::SetDefaultProperty( Property::Index index, const Property::Val Property::Value CameraActor::GetDefaultProperty( Property::Index index ) const { Property::Value ret; - if(index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT) + if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT ) { ret = Actor::GetDefaultProperty(index); } else { - DALI_ASSERT_DEBUG(mCameraAttachment && "where is the camera?"); switch(index) { case Dali::CameraActor::Property::TYPE: { - if(mCameraAttachment->GetType() == Dali::Camera::LOOK_AT_TARGET) + if( Dali::Camera::LOOK_AT_TARGET == mType ) { ret = "LOOK_AT_TARGET"; } - else if(mCameraAttachment->GetType() == Dali::Camera::FREE_LOOK) + else if( Dali::Camera::FREE_LOOK == mType ) { ret = "FREE_LOOK"; } - else - { - ret = ""; - DALI_ASSERT_DEBUG("Unknown camera type\n"); - } break; } case Dali::CameraActor::Property::PROJECTION_MODE: { - if(mCameraAttachment->GetProjectionMode() == Dali::Camera::PERSPECTIVE_PROJECTION) + if( Dali::Camera::PERSPECTIVE_PROJECTION == mProjectionMode ) { ret = "PERSPECTIVE_PROJECTION"; } - else if(mCameraAttachment->GetProjectionMode() == Dali::Camera::ORTHOGRAPHIC_PROJECTION) + else if( Dali::Camera::ORTHOGRAPHIC_PROJECTION == mProjectionMode ) { ret = "ORTHOGRAPHIC_PROJECTION"; } - else - { - ret = ""; - DALI_ASSERT_DEBUG("Unknown projection mode\n"); - } break; } case Dali::CameraActor::Property::FIELD_OF_VIEW: { - ret = mCameraAttachment->GetFieldOfView(); + ret = mFieldOfView; break; } case Dali::CameraActor::Property::ASPECT_RATIO: { - ret = mCameraAttachment->GetAspectRatio(); + ret = mAspectRatio; break; } - case Dali::CameraActor::Property::LEFT_PLANE_DISTANCE: + case Dali::CameraActor::Property::NEAR_PLANE_DISTANCE: { - ret = mCameraAttachment->GetLeftClippingPlane(); + ret = mNearClippingPlane; break; } - case Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE: + case Dali::CameraActor::Property::FAR_PLANE_DISTANCE: { - ret = mCameraAttachment->GetRightClippingPlane(); + ret = mFarClippingPlane; break; } - case Dali::CameraActor::Property::TOP_PLANE_DISTANCE: + case Dali::CameraActor::Property::LEFT_PLANE_DISTANCE: { - ret = mCameraAttachment->GetTopClippingPlane(); + ret = mLeftClippingPlane; break; } - case Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE: + case Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE: { - ret = mCameraAttachment->GetBottomClippingPlane(); + ret = mRightClippingPlane; break; } - case Dali::CameraActor::Property::NEAR_PLANE_DISTANCE: + case Dali::CameraActor::Property::TOP_PLANE_DISTANCE: { - ret = mCameraAttachment->GetNearClippingPlane(); + ret = mTopClippingPlane; break; } - case Dali::CameraActor::Property::FAR_PLANE_DISTANCE: + case Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE: { - ret = mCameraAttachment->GetFarClippingPlane(); + ret = mBottomClippingPlane; break; } case Dali::CameraActor::Property::TARGET_POSITION: { - ret = mCameraAttachment->GetTargetPosition(); + ret = mTarget; break; } case Dali::CameraActor::Property::PROJECTION_MATRIX: { - ret = mCameraAttachment->GetProjectionMatrix(); + ret = GetProjectionMatrix(); // Only on scene-graph break; } case Dali::CameraActor::Property::VIEW_MATRIX: { - ret = mCameraAttachment->GetViewMatrix(); + ret = GetViewMatrix(); // Only on scene-graph break; } case Dali::CameraActor::Property::INVERT_Y_AXIS: { - ret = mCameraAttachment->GetInvertYAxis(); - break; - } - default: - { - DALI_LOG_WARNING("Unknown property (%d)\n", index); + ret = mInvertYAxis; break; } } // switch(index) @@ -737,6 +720,21 @@ Property::Value CameraActor::GetDefaultProperty( Property::Index index ) const return ret; } +Property::Value CameraActor::GetDefaultPropertyCurrentValue( Property::Index index ) const +{ + Property::Value ret; + if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT ) + { + ret = Actor::GetDefaultPropertyCurrentValue(index); + } + else + { + ret = GetDefaultProperty( index ); // Most are event-side properties, the scene-graph properties are only on the scene-graph + } + + return ret; +} + const SceneGraph::PropertyBase* CameraActor::GetSceneObjectAnimatableProperty( Property::Index index ) const { DALI_ASSERT_ALWAYS( IsPropertyAnimatable(index) && "Property is not animatable" ); @@ -771,7 +769,7 @@ const PropertyInputImpl* CameraActor::GetSceneObjectInputProperty( Property::Ind // if its an actor default property or a custom property (actor already handles custom properties) if( ( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT ) || ( index >= DEFAULT_PROPERTY_MAX_COUNT ) ) { - property = Actor::GetSceneObjectInputProperty(index); + property = Actor::GetSceneObjectInputProperty( index ); } else { @@ -779,12 +777,12 @@ const PropertyInputImpl* CameraActor::GetSceneObjectInputProperty( Property::Ind { case Dali::CameraActor::Property::PROJECTION_MATRIX: { - property = mCameraAttachment->GetProjectionMatrixProperty(); + property = mSceneObject->GetProjectionMatrix(); break; } case Dali::CameraActor::Property::VIEW_MATRIX: { - property = mCameraAttachment->GetViewMatrixProperty(); + property = mSceneObject->GetViewMatrix(); break; } default: @@ -796,7 +794,6 @@ const PropertyInputImpl* CameraActor::GetSceneObjectInputProperty( Property::Ind return property; } - } // namespace Internal } // namespace Dali