X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Factors%2Fcamera-actor-impl.cpp;h=715781e2b621322896ecacc5b59d64003d8035c8;hb=779d85a983817171b05c865f5a609340347beab0;hp=7ee2ef145b5c969a013d6d751991f5fdfbff0cc9;hpb=1e5abb331d5925b4c2d85e21855695df0142e649;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..715781e 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) 2019 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,15 @@ // INTERNAL INCLUDES #include #include -#include +#include #include #include +#include #include #include #include -#include +#include +#include namespace Dali { @@ -51,20 +53,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 +81,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 +114,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 +142,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,123 +157,231 @@ 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( &GetNode() ); + + 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::SetInvertYAxis(bool invertYAxis) +void CameraActor::SetTopClippingPlane( float topClippingPlane ) { - mCameraAttachment->SetInvertYAxis(invertYAxis); + if( ! Equals( topClippingPlane, mTopClippingPlane ) ) + { + mTopClippingPlane = topClippingPlane; + + // sceneObject is being used in a separate thread; queue a message to set + SetTopClippingPlaneMessage( GetEventThreadServices(), *mSceneObject, mTopClippingPlane ); + } } -bool CameraActor::GetInvertYAxis() const +void CameraActor::SetBottomClippingPlane( float bottomClippingPlane ) { - return mCameraAttachment->GetInvertYAxis(); + 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::SetPerspectiveProjection( const Size& size, const Vector2& stereoBias /* = Vector2::ZERO */ ) +void CameraActor::SetInvertYAxis(bool invertYAxis) { - float width = size.width; - float height = size.height; - - if( Size::ZERO == size ) + if( invertYAxis != mInvertYAxis ) { - StagePtr stage = Stage::GetCurrent(); - if( stage ) - { - const Size& stageSize = stage->GetSize(); + mInvertYAxis = invertYAxis; - width = stageSize.width; - height = stageSize.height; - } + // sceneObject is being used in a separate thread; queue a message to set + SetInvertYAxisMessage( GetEventThreadServices(), *mSceneObject, mInvertYAxis ); } +} + +bool CameraActor::GetInvertYAxis() const +{ + return mInvertYAxis; +} - if( ( width < Math::MACHINE_EPSILON_1000 ) || ( height < Math::MACHINE_EPSILON_1000 ) ) +void CameraActor::SetPerspectiveProjection( const Size& size ) +{ + if( ( size.width < Math::MACHINE_EPSILON_1000 ) || ( size.height < Math::MACHINE_EPSILON_1000 ) ) { - // On the stage initialization this method is called but the size has not been set. - // There is no point to set any value if width or height is zero. + // Not allowed to set the canvas size to be 0. + DALI_LOG_ERROR( "Canvas size can not be 0\n" ); return; } + float width = size.width; + float height = size.height; + float nearClippingPlane; float farClippingPlane; float cameraZ; @@ -294,12 +399,12 @@ void CameraActor::SetPerspectiveProjection( const Size& size, const Vector2& ste const float aspectRatio = width / height; + // sceneObject is being used in a separate thread; queue a message to set SetProjectionMode(Dali::Camera::PERSPECTIVE_PROJECTION); SetFieldOfView( fieldOfView ); SetNearClippingPlane( nearClippingPlane ); SetFarClippingPlane( farClippingPlane ); SetAspectRatio( aspectRatio ); - mCameraAttachment->SetStereoBias( stereoBias ); SetZ( cameraZ ); } @@ -318,13 +423,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 +438,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 = GetNode().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 +478,7 @@ const Matrix& CameraActor::GetViewMatrix() const { if ( OnStage() ) { - return mCameraAttachment->GetViewMatrix(); + return mSceneObject->GetViewMatrix( GetEventThreadServices().GetEventBufferIndex() ); } else { @@ -386,123 +490,22 @@ 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 +const SceneGraph::Camera* CameraActor::GetCamera() 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; + return mSceneObject; } -bool CameraActor::IsDefaultPropertyAConstraintInput( Property::Index index ) const +void CameraActor::RotateProjection( int rotationAngle ) { - 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 -{ - 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; + // sceneObject is being used in a separate thread; queue a message to set + RotateProjectionMessage( GetEventThreadServices(), *mSceneObject, rotationAngle ); } void CameraActor::SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) @@ -513,7 +516,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 +523,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 +617,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,66 +715,47 @@ Property::Value CameraActor::GetDefaultProperty( Property::Index index ) const return ret; } -const SceneGraph::PropertyBase* CameraActor::GetSceneObjectAnimatableProperty( Property::Index index ) const +Property::Value CameraActor::GetDefaultPropertyCurrentValue( Property::Index index ) const { - DALI_ASSERT_ALWAYS( IsPropertyAnimatable(index) && "Property is not animatable" ); - - const SceneGraph::PropertyBase* property( NULL ); - - // This method should only return a property of an object connected to the scene-graph - if ( !OnStage() ) + Property::Value ret; + if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT ) { - return property; + ret = Actor::GetDefaultPropertyCurrentValue(index); } - - // let actor handle animatable properties, we have no animatable properties - if( index < DEFAULT_ACTOR_PROPERTY_MAX_COUNT ) + else { - property = Actor::GetSceneObjectAnimatableProperty(index); + ret = GetDefaultProperty( index ); // Most are event-side properties, the scene-graph properties are only on the scene-graph } - return property; + return ret; } const PropertyInputImpl* CameraActor::GetSceneObjectInputProperty( Property::Index index ) const { const PropertyInputImpl* property( NULL ); - // This method should only return a property of an object connected to the scene-graph - if ( !OnStage() ) + switch( index ) { - return property; - } - - // 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); - } - else - { - switch( index ) + case Dali::CameraActor::Property::PROJECTION_MATRIX: { - case Dali::CameraActor::Property::PROJECTION_MATRIX: - { - property = mCameraAttachment->GetProjectionMatrixProperty(); - break; - } - case Dali::CameraActor::Property::VIEW_MATRIX: - { - property = mCameraAttachment->GetViewMatrixProperty(); - break; - } - default: - DALI_LOG_WARNING("Not an input property (%d)\n", index); - break; + property = mSceneObject->GetProjectionMatrix(); + break; } + case Dali::CameraActor::Property::VIEW_MATRIX: + { + property = mSceneObject->GetViewMatrix(); + break; + } + // no default on purpose as we chain method up to actor + } + if( !property ) + { + property = Actor::GetSceneObjectInputProperty( index ); } return property; } - } // namespace Internal } // namespace Dali