X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Frender-tasks%2Frender-task-impl.cpp;h=99b74c7ce11ad23f0be0d526a60ee3c1543173da;hb=refs%2Ftags%2Fsubmit%2Ftizen_5.5%2F20200319.004255;hp=a1ad2b81a34d351ff8e97aca16a44af52774a8cb;hpb=6e8df13ec88b05c87733b75a5e1ced441f229935;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/render-tasks/render-task-impl.cpp b/dali/internal/event/render-tasks/render-task-impl.cpp index a1ad2b8..99b74c7 100644 --- a/dali/internal/event/render-tasks/render-task-impl.cpp +++ b/dali/internal/event/render-tasks/render-task-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016 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. @@ -29,10 +29,10 @@ #include #include #include +#include #include #include #include -#include #include #if defined(DEBUG_ENABLED) @@ -59,38 +59,58 @@ DALI_PROPERTY( "viewportPosition", VECTOR2, true, true, true, Dali DALI_PROPERTY( "viewportSize", VECTOR2, true, true, true, Dali::RenderTask::Property::VIEWPORT_SIZE ) DALI_PROPERTY( "clearColor", VECTOR4, true, true, true, Dali::RenderTask::Property::CLEAR_COLOR ) DALI_PROPERTY( "requiresSync", BOOLEAN, true, false, false, Dali::RenderTask::Property::REQUIRES_SYNC ) -DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX ) +DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX, RenderTaskDefaultProperties ) // Signals const char* const SIGNAL_FINISHED = "finished"; -TypeRegistration mType( typeid( Dali::RenderTask ), typeid( Dali::BaseHandle ), NULL ); +TypeRegistration mType( typeid( Dali::RenderTask ), typeid( Dali::BaseHandle ), NULL, RenderTaskDefaultProperties ); SignalConnectorType signalConnector1( mType, SIGNAL_FINISHED, &RenderTask::DoConnectSignal ); } // Unnamed namespace -RenderTask* RenderTask::New( bool isSystemLevel ) +RenderTaskPtr RenderTask::New( Actor* sourceActor, CameraActor* cameraActor, RenderTaskList& renderTaskList ) { - RenderTask* task( new RenderTask( isSystemLevel ) ); + // create scene object first so it's guaranteed to exist for the event side + auto sceneObject = SceneGraph::RenderTask::New(); + // pass the pointer to base for message passing + RenderTaskPtr task( new RenderTask( sceneObject, renderTaskList ) ); + + // transfer scene object ownership to update manager + const SceneGraph::RenderTaskList& parentSceneObject = renderTaskList.GetSceneObject(); + OwnerPointer< SceneGraph::RenderTask > transferOwnership( sceneObject ); + AddTaskMessage( task->GetEventThreadServices(), parentSceneObject, transferOwnership ); + + // Set the default source & camera actors + task->SetSourceActor( sourceActor ); + task->SetCameraActor( cameraActor ); + + // no need for additional messages as scene objects defaults match ours return task; } void RenderTask::SetSourceActor( Actor* actor ) { - const Stage* stage = Stage::GetCurrent(); - if ( stage ) + mSourceActor.SetActor( actor ); + if ( actor ) + { + SetSourceNodeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), &actor->GetNode() ); + } + else { - stage->GetRenderTaskList().SetExclusive( this, mExclusive ); + SetSourceNodeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), nullptr ); } - mSourceConnector.SetActor( actor ); + + // set the actor on exclusive container for hit testing + mRenderTaskList.SetExclusive( this, mExclusive ); } Actor* RenderTask::GetSourceActor() const { - return mSourceConnector.mActor; + return mSourceActor.GetActor(); } void RenderTask::SetExclusive( bool exclusive ) @@ -99,17 +119,10 @@ void RenderTask::SetExclusive( bool exclusive ) { mExclusive = exclusive; - const Stage* stage = Stage::GetCurrent(); - if ( stage ) - { - stage->GetRenderTaskList().SetExclusive( this, exclusive ); - } + mRenderTaskList.SetExclusive( this, exclusive ); - if ( mSceneObject ) - { - // mSceneObject is being used in a separate thread; queue a message to set the value - SetExclusiveMessage( GetEventThreadServices(), *mSceneObject, mExclusive ); - } + // scene object is being used in a separate thread; queue a message to set the value + SetExclusiveMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), mExclusive ); } } @@ -130,71 +143,51 @@ bool RenderTask::GetInputEnabled() const void RenderTask::SetCameraActor( CameraActor* cameraActor ) { + mCameraActor.SetActor( cameraActor ); if( cameraActor ) { - mCameraConnector.mCamera = cameraActor->GetCamera(); + SetCameraMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), &cameraActor->GetNode(), cameraActor->GetCamera() ); } else { - mCameraConnector.mCamera = NULL; + SetCameraMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), nullptr, nullptr ); } - mCameraConnector.SetActor( cameraActor ); + + // set the actor on exclusive container for hit testing + mRenderTaskList.SetExclusive( this, mExclusive ); } CameraActor* RenderTask::GetCameraActor() const { - // camera connector can only point to camera actor - return static_cast< CameraActor* >( mCameraConnector.mActor ); + if( mCameraActor.GetActor() ) + { + return static_cast< CameraActor* >( mCameraActor.GetActor() ); + } + return nullptr; } -void RenderTask::SetTargetFrameBuffer( Dali::FrameBufferImage image ) +void RenderTask::SetTargetFrameBuffer( FrameBufferImagePtr image ) { - if ( mFrameBufferImage != image ) + mFrameBufferImage = image; + FrameBuffer* frameBufferPtr( NULL ); + if( image ) { - // if we have a scene object we need to track connection status and set frame buffer id as well as updating target frame buffer - if ( mSceneObject ) - { - if(mFrameBufferImage) - { - GetImplementation(mFrameBufferImage).Disconnect(); - } - - // update target frame buffer - mFrameBufferImage = image; - - unsigned int resourceId = 0; - bool isNativeFBO = false; - if( mFrameBufferImage ) - { - Dali::Internal::FrameBufferImage& impl = GetImplementation( mFrameBufferImage ); - impl.Connect(); - resourceId = impl.GetResourceId(); - isNativeFBO = impl.IsNativeFbo(); - } - - // mSceneObject is being used in a separate thread; queue a message to set the value - SetFrameBufferIdMessage( GetEventThreadServices(), *mSceneObject, resourceId, isNativeFBO ); - } - else - { - // update target frame buffer - mFrameBufferImage = image; - } + frameBufferPtr = image->GetFrameBuffer(); } + + SetFrameBuffer( frameBufferPtr ); } -void RenderTask::SetFrameBuffer( Dali::FrameBuffer frameBuffer ) +void RenderTask::SetFrameBuffer( FrameBufferPtr frameBuffer ) { + mFrameBuffer = frameBuffer; + Render::FrameBuffer* renderFrameBufferPtr( NULL ); if( frameBuffer ) { - mFrameBuffer = Internal::FrameBufferPtr( &GetImplementation( frameBuffer ) ); - SetFrameBufferMessage( GetEventThreadServices(), *mSceneObject, mFrameBuffer->GetRenderObject() ); - } - else - { - mFrameBuffer.Reset(); - SetFrameBufferMessage( GetEventThreadServices(), *mSceneObject, NULL ); + renderFrameBufferPtr = mFrameBuffer->GetRenderObject(); } + + SetFrameBufferMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), renderFrameBufferPtr ); } FrameBuffer* RenderTask::GetFrameBuffer() const @@ -202,9 +195,9 @@ FrameBuffer* RenderTask::GetFrameBuffer() const return mFrameBuffer.Get(); } -Dali::FrameBufferImage RenderTask::GetTargetFrameBuffer() const +FrameBufferImage* RenderTask::GetTargetFrameBuffer() const { - return mFrameBufferImage; + return mFrameBufferImage.Get(); } void RenderTask::SetScreenToFrameBufferFunction( ScreenToFrameBufferFunction conversionFunction ) @@ -217,53 +210,57 @@ RenderTask::ScreenToFrameBufferFunction RenderTask::GetScreenToFrameBufferFuncti return mScreenToFrameBufferFunction; } -void RenderTask::SetScreenToFrameBufferMappingActor( Actor* mappingActor ) +void RenderTask::SetScreenToFrameBufferMappingActor( Dali::Actor& mappingActor ) { - mMappingConnector.SetActor( mappingActor ); + mInputMappingActor = WeakHandle( mappingActor ); } -Actor* RenderTask::GetScreenToFrameBufferMappingActor() const +Dali::Actor RenderTask::GetScreenToFrameBufferMappingActor() const { - return mMappingConnector.mActor; + return mInputMappingActor.GetHandle(); } void RenderTask::SetViewportPosition(const Vector2& value) { - BakeViewportPositionMessage( GetEventThreadServices(), *mSceneObject, value ); + mViewportPosition = value; + + BakeViewportPositionMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), value ); } Vector2 RenderTask::GetCurrentViewportPosition() const { - return mSceneObject->GetViewportPosition( GetEventThreadServices().GetEventBufferIndex() ); + return GetRenderTaskSceneObject().GetViewportPosition( GetEventThreadServices().GetEventBufferIndex() ); } void RenderTask::SetViewportSize(const Vector2& value) { - BakeViewportSizeMessage( GetEventThreadServices(), *mSceneObject, value ); + mViewportSize = value; + + BakeViewportSizeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), value ); } Vector2 RenderTask::GetCurrentViewportSize() const { - return mSceneObject->GetViewportSize( GetEventThreadServices().GetEventBufferIndex() ); + return GetRenderTaskSceneObject().GetViewportSize( GetEventThreadServices().GetEventBufferIndex() ); } void RenderTask::SetViewport( const Viewport& viewport ) { - SetViewportPosition(Vector2(viewport.x, viewport.y)); - SetViewportSize(Vector2(viewport.width, viewport.height)); + SetViewportPosition( Vector2( static_cast( viewport.x ), static_cast( viewport.y ) ) ); + SetViewportSize( Vector2( static_cast( viewport.width ), static_cast( viewport.height ) ) ); } void RenderTask::GetViewport( Viewport& viewPort ) const { BufferIndex bufferIndex = GetEventThreadServices().GetEventBufferIndex(); - if(!mSceneObject->GetViewportEnabled( bufferIndex )) + if( !GetRenderTaskSceneObject().GetViewportEnabled( bufferIndex ) ) { if ( mFrameBufferImage ) { viewPort.x = viewPort.y = 0; - viewPort.width = mFrameBufferImage.GetWidth(); - viewPort.height = mFrameBufferImage.GetHeight(); + viewPort.width = mFrameBufferImage->GetWidth(); + viewPort.height = mFrameBufferImage->GetHeight(); } else { @@ -271,20 +268,27 @@ void RenderTask::GetViewport( Viewport& viewPort ) const if ( stage ) { Vector2 size( stage->GetSize() ); + Actor* sourceActor = mSourceActor.GetActor(); + if ( sourceActor && sourceActor->OnStage() ) + { + Scene& scene = sourceActor->GetScene(); + size = scene.GetSize(); + } + viewPort.x = viewPort.y = 0; - viewPort.width = size.width; - viewPort.height = size.height; + viewPort.width = static_cast( size.width ); // truncated + viewPort.height = static_cast( size.height ); // truncated } } } else { - const Vector2& position = mSceneObject->GetViewportPosition(bufferIndex); - const Vector2& size = mSceneObject->GetViewportSize(bufferIndex); - viewPort.x = position.x; - viewPort.y = position.y; - viewPort.width = size.width; - viewPort.height = size.height; + const Vector2& position = GetRenderTaskSceneObject().GetViewportPosition(bufferIndex); + const Vector2& size = GetRenderTaskSceneObject().GetViewportSize(bufferIndex); + viewPort.x = static_cast( position.x ); // truncated + viewPort.y = static_cast( position.y ); // truncated + viewPort.width = static_cast( size.width ); // truncated + viewPort.height = static_cast( size.height ); // truncated } } @@ -294,17 +298,14 @@ void RenderTask::SetClearColor( const Vector4& color ) { mClearColor = color; - if ( mSceneObject ) - { - // mSceneObject is being used in a separate thread; queue a message to set the value - BakeClearColorMessage( GetEventThreadServices(), *mSceneObject, color ); - } + // scene object is being used in a separate thread; queue a message to set the value + BakeClearColorMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), color ); } } const Vector4& RenderTask::GetClearColor() const { - return mSceneObject->GetClearColor( GetEventThreadServices().GetEventBufferIndex() ); + return GetRenderTaskSceneObject().GetClearColor( GetEventThreadServices().GetEventBufferIndex() ); } void RenderTask::SetSyncRequired( bool requiresSync ) @@ -313,11 +314,8 @@ void RenderTask::SetSyncRequired( bool requiresSync ) { mRequiresSync = requiresSync; - if( mSceneObject ) - { - // mSceneObject is being used in a separate thread; queue a message to set the value - SetSyncRequiredMessage( GetEventThreadServices(), *mSceneObject, requiresSync ); - } + // scene object is being used in a separate thread; queue a message to set the value + SetSyncRequiredMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), requiresSync ); } } @@ -332,11 +330,8 @@ void RenderTask::SetClearEnabled( bool enabled ) { mClearEnabled = enabled; - if ( mSceneObject ) - { - // mSceneObject is being used in a separate thread; queue a message to set the value - SetClearEnabledMessage( GetEventThreadServices(), *mSceneObject, mClearEnabled ); - } + // scene object is being used in a separate thread; queue a message to set the value + SetClearEnabledMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), mClearEnabled ); } } @@ -351,11 +346,8 @@ void RenderTask::SetCullMode( bool mode ) { mCullMode = mode; - if ( mSceneObject ) - { - // mSceneObject is being used in a separate thread; queue a message to set the value - SetCullModeMessage( GetEventThreadServices(), *mSceneObject, mCullMode ); - } + // scene object is being used in a separate thread; queue a message to set the value + SetCullModeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), mCullMode ); } } @@ -364,7 +356,7 @@ bool RenderTask::GetCullMode() const return mCullMode; } -void RenderTask::SetRefreshRate( unsigned int refreshRate ) +void RenderTask::SetRefreshRate( uint32_t refreshRate ) { DALI_LOG_TRACE_METHOD_FMT(gLogRender, "this:%p rate:%d\n", this, refreshRate); DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::SetRefreshRate(this:%p, %d)\n", this, refreshRate); @@ -373,14 +365,11 @@ void RenderTask::SetRefreshRate( unsigned int refreshRate ) // Note - even when refreshRate is the same as mRefreshRate, a message should be sent - if ( mSceneObject ) - { - // mSceneObject is being used in a separate thread; queue a message to set the value - SetRefreshRateMessage( GetEventThreadServices(), *mSceneObject, refreshRate ); - } + // sceneObject is being used in a separate thread; queue a message to set the value + SetRefreshRateMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), refreshRate ); } -unsigned int RenderTask::GetRefreshRate() const +uint32_t RenderTask::GetRefreshRate() const { return mRefreshRate; } @@ -394,9 +383,9 @@ bool RenderTask::IsHittable( Vector2& screenCoords ) const CameraActor* cameraActor = GetCameraActor(); if ( mInputEnabled && - NULL != sourceActor && + nullptr != sourceActor && sourceActor->OnStage() && - NULL != cameraActor && + nullptr != cameraActor && cameraActor->OnStage() ) { // If the actors are rendered off-screen, then the screen coordinates must be converted @@ -417,24 +406,35 @@ bool RenderTask::TranslateCoordinates( Vector2& screenCoords ) const bool inside( true ); // If the actors are rendered off-screen, then the screen coordinates must be converted // the function should only be called for offscreen tasks - if( mFrameBufferImage && mMappingConnector.mActor ) + Dali::Actor mappingActor = GetScreenToFrameBufferMappingActor(); + + if( mFrameBufferImage && mappingActor ) { + Internal::Actor* inputMappingActor = &GetImplementation( mappingActor ); CameraActor* localCamera = GetCameraActor(); StagePtr stage = Stage::GetCurrent(); - if( stage ) + if ( stage ) { - CameraActor& defaultCamera = stage->GetDefaultCameraActor(); + Vector2 size( stage->GetSize() ); + CameraActor* defaultCamera( &stage->GetDefaultCameraActor() ); + Actor* sourceActor = mSourceActor.GetActor(); + if ( sourceActor && sourceActor->OnStage() ) + { + Scene& scene = sourceActor->GetScene(); + size = scene.GetSize(); + defaultCamera = &scene.GetDefaultCameraActor(); + } + if( localCamera ) { Viewport viewport; - Vector2 size( stage->GetSize() ); viewport.x = viewport.y = 0; - viewport.width = size.width; - viewport.height = size.height; + viewport.width = static_cast( size.width ); // truncated + viewport.height = static_cast( size.height ); // truncated float localX, localY; - inside = mMappingConnector.mActor->ScreenToLocal(defaultCamera.GetViewMatrix(), defaultCamera.GetProjectionMatrix(), viewport, localX, localY, screenCoords.x, screenCoords.y); - Vector3 actorSize = mMappingConnector.mActor->GetCurrentSize(); + inside = inputMappingActor->ScreenToLocal(defaultCamera->GetViewMatrix(), defaultCamera->GetProjectionMatrix(), viewport, localX, localY, screenCoords.x, screenCoords.y); + Vector3 actorSize = inputMappingActor->GetCurrentSize(); if( inside && localX >= 0.f && localX <= actorSize.x && localY >= 0.f && localY <= actorSize.y) { screenCoords.x = localX; @@ -458,11 +458,6 @@ bool RenderTask::TranslateCoordinates( Vector2& screenCoords ) const return inside; } -bool RenderTask::IsSystemLevel() const -{ - return mIsSystemLevel; -} - bool RenderTask::WorldToViewport(const Vector3 &position, float& viewportX, float& viewportY) const { CameraActor* cam = GetCameraActor(); @@ -478,10 +473,10 @@ bool RenderTask::WorldToViewport(const Vector3 &position, float& viewportX, floa bool ok = ProjectFull(pos, cam->GetViewMatrix(), cam->GetProjectionMatrix(), - viewport.x, - viewport.y, - viewport.width, - viewport.height, + static_cast( viewport.x ), // truncated + static_cast( viewport.y ), // truncated + static_cast( viewport.width ), // truncated + static_cast( viewport.height ), // truncated viewportPosition); if(ok) { @@ -497,169 +492,95 @@ bool RenderTask::ViewportToLocal(Actor* actor, float viewportX, float viewportY, return actor->ScreenToLocal( *this, localX, localY, viewportX, viewportY ); } -SceneGraph::RenderTask* RenderTask::CreateSceneObject() +const SceneGraph::RenderTask& RenderTask::GetRenderTaskSceneObject() const { - // This should only be called once, with no existing scene-object - DALI_ASSERT_DEBUG( NULL == mSceneObject ); - - // Keep the raw-pointer until DiscardSceneObject is called - mSceneObject = SceneGraph::RenderTask::New(); - - // if we have a frame buffer we need to track connection status then send a message to set the frame buffer id in case it has changed since last time we were on stage - unsigned int resourceId = 0; - bool isNativeFBO = false; - if( mFrameBufferImage ) - { - Dali::Internal::FrameBufferImage& impl = GetImplementation( mFrameBufferImage ); - impl.Connect(); - resourceId = impl.GetResourceId(); - isNativeFBO = impl.IsNativeFbo(); - } - - // mSceneObject is being used in a separate thread; queue a message to set the value - SetFrameBufferIdMessage( GetEventThreadServices(), *mSceneObject, resourceId, isNativeFBO ); - - // Send messages to set other properties that may have changed since last time we were on stage - SetExclusiveMessage( GetEventThreadServices(), *mSceneObject, mExclusive ); - SetClearColorMessage( GetEventThreadServices(), *mSceneObject, mClearColor ); - SetClearEnabledMessage( GetEventThreadServices(), *mSceneObject, mClearEnabled ); - SetCullModeMessage( GetEventThreadServices(), *mSceneObject, mCullMode ); - SetRefreshRateMessage( GetEventThreadServices(), *mSceneObject, mRefreshRate ); - - // Caller takes ownership - return mSceneObject; + return *static_cast( mUpdateObject ); } -SceneGraph::RenderTask* RenderTask::GetRenderTaskSceneObject() +RenderTaskList& RenderTask::GetRenderTaskList() const { - return mSceneObject; -} - -void RenderTask::DiscardSceneObject() -{ - // mSceneObject is not owned; throw away the raw-pointer - mSceneObject = NULL; - - // if we have a frame buffer we need to track connection status - if(mFrameBufferImage) - { - GetImplementation(mFrameBufferImage).Disconnect(); - } + return mRenderTaskList; } /******************************************************************************** ******************************** PROPERTY METHODS ************************** ********************************************************************************/ -unsigned int RenderTask::GetDefaultPropertyCount() const -{ - return DEFAULT_PROPERTY_COUNT; -} - -void RenderTask::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const -{ - indices.Reserve( DEFAULT_PROPERTY_COUNT ); - - for ( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i ) - { - indices.PushBack( i ); - } -} - -const char* RenderTask::GetDefaultPropertyName( Property::Index index ) const -{ - if( index < DEFAULT_PROPERTY_COUNT ) - { - return DEFAULT_PROPERTY_DETAILS[index].name; - } - else - { - return NULL; - } -} - -Property::Index RenderTask::GetDefaultPropertyIndex(const std::string& name) const +void RenderTask::SetDefaultProperty( Property::Index index, const Property::Value& property ) { - Property::Index index = Property::INVALID_INDEX; - - // Look for name in default properties - for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i ) + switch ( index ) { - if( 0 == strcmp( name.c_str(), DEFAULT_PROPERTY_DETAILS[i].name ) ) // dont want to convert rhs to string + case Dali::RenderTask::Property::VIEWPORT_POSITION: + { + SetViewportPosition( property.Get() ); + break; + } + case Dali::RenderTask::Property::VIEWPORT_SIZE: + { + SetViewportSize( property.Get() ); + break; + } + case Dali::RenderTask::Property::CLEAR_COLOR: + { + SetClearColor( property.Get() ); + break; + } + case Dali::RenderTask::Property::REQUIRES_SYNC: { - index = i; + SetSyncRequired( property.Get() ); + break; + } + default: + { + // nothing to do break; } } - - return index; -} - -bool RenderTask::IsDefaultPropertyWritable(Property::Index index) const -{ - return DEFAULT_PROPERTY_DETAILS[ index ].writable; -} - -bool RenderTask::IsDefaultPropertyAnimatable(Property::Index index) const -{ - return DEFAULT_PROPERTY_DETAILS[ index ].animatable; } -bool RenderTask::IsDefaultPropertyAConstraintInput( Property::Index index ) const -{ - return DEFAULT_PROPERTY_DETAILS[ index ].constraintInput; -} - -Property::Type RenderTask::GetDefaultPropertyType(Property::Index index) const +Property::Value RenderTask::GetDefaultProperty(Property::Index index) const { - if( index < DEFAULT_PROPERTY_COUNT ) - { - return DEFAULT_PROPERTY_DETAILS[index].type; - } - - // index out of range...return Property::NONE - return Property::NONE; -} + Property::Value value; -void RenderTask::SetDefaultProperty( Property::Index index, const Property::Value& property ) -{ switch ( index ) { case Dali::RenderTask::Property::VIEWPORT_POSITION: { - SetViewportPosition( property.Get() ); + value = mViewportPosition; break; } case Dali::RenderTask::Property::VIEWPORT_SIZE: { - SetViewportSize( property.Get() ); + value = mViewportSize; break; } case Dali::RenderTask::Property::CLEAR_COLOR: { - SetClearColor( property.Get() ); + value = mClearColor; break; } case Dali::RenderTask::Property::REQUIRES_SYNC: { - SetSyncRequired( property.Get() ); + value = IsSyncRequired(); break; } + default: { - // nothing to do + DALI_ASSERT_ALWAYS(false && "RenderTask property index out of range"); // should not come here break; } } + + return value; } -Property::Value RenderTask::GetDefaultProperty(Property::Index index) const +Property::Value RenderTask::GetDefaultPropertyCurrentValue( Property::Index index ) const { Property::Value value; switch ( index ) { - case Dali::RenderTask::Property::VIEWPORT_POSITION: { value = GetCurrentViewportPosition(); @@ -691,37 +612,101 @@ Property::Value RenderTask::GetDefaultProperty(Property::Index index) const return value; } -const SceneGraph::PropertyOwner* RenderTask::GetSceneObject() const +void RenderTask::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) { - return mSceneObject; + switch( animationType ) + { + case Animation::TO: + case Animation::BETWEEN: + { + switch ( index ) + { + case Dali::RenderTask::Property::VIEWPORT_POSITION: + { + value.Get( mViewportPosition ); + break; + } + case Dali::RenderTask::Property::VIEWPORT_SIZE: + { + value.Get( mViewportSize ); + break; + } + case Dali::RenderTask::Property::CLEAR_COLOR: + { + value.Get( mClearColor ); + break; + } + case Dali::RenderTask::Property::REQUIRES_SYNC: + default: + { + // Nothing to do as not animatable + break; + } + } + break; + } + + case Animation::BY: + { + switch ( index ) + { + case Dali::RenderTask::Property::VIEWPORT_POSITION: + { + AdjustValue< Vector2 >( mViewportPosition, value ); + break; + } + case Dali::RenderTask::Property::VIEWPORT_SIZE: + { + AdjustValue< Vector2 >( mViewportSize, value ); + break; + } + case Dali::RenderTask::Property::CLEAR_COLOR: + { + AdjustValue< Vector4 >( mClearColor, value ); + break; + } + case Dali::RenderTask::Property::REQUIRES_SYNC: + default: + { + // Nothing to do as not animatable + break; + } + } + break; + } + } } const SceneGraph::PropertyBase* RenderTask::GetSceneObjectAnimatableProperty( 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 which is part of the scene-graph - if( mSceneObject != NULL ) + switch ( index ) { - switch ( index ) + case Dali::RenderTask::Property::VIEWPORT_POSITION: { - case Dali::RenderTask::Property::VIEWPORT_POSITION: - property = &mSceneObject->mViewportPosition; - break; - - case Dali::RenderTask::Property::VIEWPORT_SIZE: - property = &mSceneObject->mViewportSize; - break; - - case Dali::RenderTask::Property::CLEAR_COLOR: - property = &mSceneObject->mClearColor; - break; - - default: - break; + property = &GetRenderTaskSceneObject().mViewportPosition; + break; + } + case Dali::RenderTask::Property::VIEWPORT_SIZE: + { + property = &GetRenderTaskSceneObject().mViewportSize; + break; } + case Dali::RenderTask::Property::CLEAR_COLOR: + { + property = &GetRenderTaskSceneObject().mClearColor; + break; + } + default: + { + break; + } + } + if( !property ) + { + // not our property, ask base + property = Object::GetSceneObjectAnimatableProperty( index ); } return property; @@ -729,35 +714,14 @@ const SceneGraph::PropertyBase* RenderTask::GetSceneObjectAnimatableProperty( Pr const PropertyInputImpl* RenderTask::GetSceneObjectInputProperty( Property::Index index ) const { - const PropertyInputImpl* property( NULL ); - if( mSceneObject != NULL ) - { - switch ( index ) - { - case Dali::RenderTask::Property::VIEWPORT_POSITION: - property = &mSceneObject->mViewportPosition; - break; - - case Dali::RenderTask::Property::VIEWPORT_SIZE: - property = &mSceneObject->mViewportSize; - break; - - case Dali::RenderTask::Property::CLEAR_COLOR: - property = &mSceneObject->mClearColor; - break; - - default: - break; - } - } - - return property; + // animatable properties are input as well, Object::GetSceneObjectInputProperty does the same so no need to call it + return GetSceneObjectAnimatableProperty( index ); } bool RenderTask::HasFinished() { bool finished = false; - const unsigned int counter = mSceneObject->GetRenderedOnceCounter(); + const uint32_t counter = GetRenderTaskSceneObject().GetRenderedOnceCounter(); if( mRefreshOnceCounter < counter ) { @@ -765,7 +729,7 @@ bool RenderTask::HasFinished() mRefreshOnceCounter = counter; } - DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::HasFinished()=%s SCRT:%p SC\n", finished?"T":"F", mSceneObject); + DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::HasFinished()=%s SCRT:%p SC\n", finished?"T":"F", &GetRenderTaskSceneObject()); return finished; } @@ -804,12 +768,15 @@ bool RenderTask::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface return connected; } -RenderTask::RenderTask( bool isSystemLevel ) -: mSceneObject( NULL ), - mSourceConnector( Connector::SOURCE_CONNECTOR, *this ), - mCameraConnector( Connector::CAMERA_CONNECTOR, *this ), - mMappingConnector( Connector::MAPPING_CONNECTOR, *this ), +RenderTask::RenderTask( const SceneGraph::RenderTask* sceneObject, RenderTaskList& renderTaskList ) +: Object( sceneObject ), + mSourceActor(), + mCameraActor(), + mInputMappingActor(), + mRenderTaskList( renderTaskList ), mClearColor( Dali::RenderTask::DEFAULT_CLEAR_COLOR ), + mViewportPosition( Vector2::ZERO ), + mViewportSize( Vector2::ZERO ), mRefreshRate( Dali::RenderTask::DEFAULT_REFRESH_RATE ), mRefreshOnceCounter( 0u ), mScreenToFrameBufferFunction( Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION ), @@ -817,108 +784,17 @@ RenderTask::RenderTask( bool isSystemLevel ) mInputEnabled( Dali::RenderTask::DEFAULT_INPUT_ENABLED ), mClearEnabled( Dali::RenderTask::DEFAULT_CLEAR_ENABLED ), mCullMode( Dali::RenderTask::DEFAULT_CULL_MODE ), - mIsSystemLevel( isSystemLevel ), mRequiresSync( false ) { DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::RenderTask(this:%p)\n", this); + // scene object handles observation of source and camera } RenderTask::~RenderTask() { DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::~RenderTask(this:%p)\n", this); -} - -// Helper class for connecting Nodes to the scene-graph RenderTask - -RenderTask::Connector::Connector( Type type, RenderTask& renderTask ) -: mType( type ), - mRenderTask( renderTask ), - mActor( NULL ), - mCamera( NULL ) -{ -} - -RenderTask::Connector::~Connector() -{ - SetActor( NULL ); -} - -void RenderTask::Connector::SetActor( Actor* actor ) -{ - if ( mActor != actor ) - { - if ( mActor ) - { - mActor->RemoveObserver( *this ); - } - - mActor = actor; - - if ( mActor ) - { - mActor->AddObserver( *this ); - } - - UpdateRenderTask(); - } -} - -void RenderTask::Connector::SceneObjectAdded( Object& object ) -{ - UpdateRenderTask(); -} - -void RenderTask::Connector::SceneObjectRemoved( Object& object ) -{ - UpdateRenderTask(); -} - -void RenderTask::Connector::ObjectDestroyed( Object& object ) -{ - if ( SOURCE_CONNECTOR == mType ) - { - const Stage* stage = Stage::GetCurrent(); - if ( stage ) - { - stage->GetRenderTaskList().SetExclusive( &mRenderTask, false ); - } - } - - mActor = NULL; - mCamera = NULL; // only meaningful for the camera connector but no simple way to distinguish - - UpdateRenderTask(); -} - -void RenderTask::Connector::UpdateRenderTask() -{ - // Guard to allow handle destruction after Core has been destroyed - if( Internal::Stage::IsInstalled() && - mRenderTask.mSceneObject ) - { - const SceneGraph::Node* node( NULL ); - - // Check whether a Node exists in the scene-graph - if ( NULL != mActor ) - { - const SceneGraph::PropertyOwner* object = mActor->GetSceneObject(); - if ( NULL != object ) - { - // actors only point to nodes as their scene objects - node = static_cast< const SceneGraph::Node* >( object ); - } - } - - //the mapping node is not used in the scene graph - if ( SOURCE_CONNECTOR == mType ) - { - SetSourceNodeMessage( mRenderTask.GetEventThreadServices(), *(mRenderTask.mSceneObject), node ); - } - else if( CAMERA_CONNECTOR == mType ) - { - SetCameraMessage( mRenderTask.GetEventThreadServices(), *(mRenderTask.mSceneObject), node, mCamera ); - } - } + // scene object deletion is handled by our parent + // scene object handles observation of source and camera } } // namespace Internal