/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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.
DALI_PROPERTY( "viewportPosition", VECTOR2, true, true, true, Dali::RenderTask::Property::VIEWPORT_POSITION )
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 )
// Signals
void RenderTask::SetCameraActor( CameraActor* cameraActor )
{
+ if( cameraActor )
+ {
+ mCameraConnector.mCamera = cameraActor->GetCamera();
+ }
+ else
+ {
+ mCameraConnector.mCamera = NULL;
+ }
mCameraConnector.SetActor( cameraActor );
}
return static_cast< CameraActor* >( mCameraConnector.mActor );
}
-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();
- }
+ frameBufferPtr = image->GetFrameBuffer();
+ }
- // update target frame buffer
- mFrameBufferImage = image;
+ SetFrameBuffer( frameBufferPtr );
+}
- unsigned int resourceId = 0;
- if(mFrameBufferImage)
- {
- GetImplementation(mFrameBufferImage).Connect();
+void RenderTask::SetFrameBuffer( FrameBufferPtr frameBuffer )
+{
+ mFrameBuffer = frameBuffer;
+ Render::FrameBuffer* renderFrameBufferPtr( NULL );
+ if( frameBuffer )
+ {
+ renderFrameBufferPtr = mFrameBuffer->GetRenderObject();
+ }
- resourceId = GetImplementation( mFrameBufferImage ).GetResourceId();
- }
+ SetFrameBufferMessage( GetEventThreadServices(), *mSceneObject, renderFrameBufferPtr );
+}
- // mSceneObject is being used in a separate thread; queue a message to set the value
- SetFrameBufferIdMessage( GetEventThreadServices(), *mSceneObject, resourceId );
- }
- else
- {
- // update target frame buffer
- mFrameBufferImage = image;
- }
- }
+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 )
void RenderTask::SetViewportPosition(const Vector2& value)
{
+ mViewportPosition = value;
+
BakeViewportPositionMessage( GetEventThreadServices(), *mSceneObject, value );
}
void RenderTask::SetViewportSize(const Vector2& value)
{
+ mViewportSize = value;
+
BakeViewportSizeMessage( GetEventThreadServices(), *mSceneObject, value );
}
if ( mFrameBufferImage )
{
viewPort.x = viewPort.y = 0;
- viewPort.width = mFrameBufferImage.GetWidth();
- viewPort.height = mFrameBufferImage.GetHeight();
+ viewPort.width = mFrameBufferImage->GetWidth();
+ viewPort.height = mFrameBufferImage->GetHeight();
}
else
{
return mSceneObject->GetClearColor( GetEventThreadServices().GetEventBufferIndex() );
}
+void RenderTask::SetSyncRequired( bool requiresSync )
+{
+ if( mRequiresSync != requiresSync )
+ {
+ mRequiresSync = requiresSync;
+
+ if( mSceneObject )
+ {
+ // mSceneObject is being used in a separate thread; queue a message to set the value
+ SetSyncRequiredMessage( GetEventThreadServices(), *mSceneObject, requiresSync );
+ }
+ }
+}
+
+bool RenderTask::IsSyncRequired() const
+{
+ return mRequiresSync;
+}
+
void RenderTask::SetClearEnabled( bool enabled )
{
if ( mClearEnabled != enabled )
// 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;
- if(mFrameBufferImage)
- {
- GetImplementation(mFrameBufferImage).Connect();
-
- resourceId = GetImplementation( mFrameBufferImage ).GetResourceId();
- }
-
- // mSceneObject is being used in a separate thread; queue a message to set the value
- SetFrameBufferIdMessage( GetEventThreadServices(), *mSceneObject, resourceId );
-
// 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 );
+ SetSyncRequiredMessage( GetEventThreadServices(), *mSceneObject, mRequiresSync );
+ SetFrameBuffer( mFrameBuffer );
// Caller takes ownership
return mSceneObject;
{
// 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();
- }
}
/********************************************************************************
SetClearColor( property.Get<Vector4>() );
break;
}
+ case Dali::RenderTask::Property::REQUIRES_SYNC:
+ {
+ SetSyncRequired( property.Get<bool>() );
+ break;
+ }
default:
{
// nothing to do
case Dali::RenderTask::Property::VIEWPORT_POSITION:
{
+ value = mViewportPosition;
+ break;
+ }
+ case Dali::RenderTask::Property::VIEWPORT_SIZE:
+ {
+ value = mViewportSize;
+ break;
+ }
+ case Dali::RenderTask::Property::CLEAR_COLOR:
+ {
+ value = mClearColor;
+ break;
+ }
+ case Dali::RenderTask::Property::REQUIRES_SYNC:
+ {
+ value = IsSyncRequired();
+ break;
+ }
+
+ default:
+ {
+ DALI_ASSERT_ALWAYS(false && "RenderTask property index out of range"); // should not come here
+ break;
+ }
+ }
+
+ return value;
+}
+
+Property::Value RenderTask::GetDefaultPropertyCurrentValue( Property::Index index ) const
+{
+ Property::Value value;
+
+ switch ( index )
+ {
+
+ case Dali::RenderTask::Property::VIEWPORT_POSITION:
+ {
value = GetCurrentViewportPosition();
break;
}
value = GetClearColor();
break;
}
+ case Dali::RenderTask::Property::REQUIRES_SYNC:
+ {
+ value = IsSyncRequired();
+ break;
+ }
default:
{
return value;
}
+void RenderTask::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value )
+{
+ 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;
+ }
+ }
+}
+
const SceneGraph::PropertyOwner* RenderTask::GetSceneObject() const
{
return mSceneObject;
break;
case Dali::RenderTask::Property::CLEAR_COLOR:
- property = &mSceneObject->mViewportSize;
+ property = &mSceneObject->mClearColor;
break;
default:
bool RenderTask::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
bool connected( true );
- RenderTask* renderTask = dynamic_cast<RenderTask*>(object);
+ RenderTask* renderTask = static_cast< RenderTask* >(object); // TypeRegistry guarantees that this is the correct type.
if ( 0 == strcmp( signalName.c_str(), SIGNAL_FINISHED ) )
{
mCameraConnector( Connector::CAMERA_CONNECTOR, *this ),
mMappingConnector( Connector::MAPPING_CONNECTOR, *this ),
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 ),
mInputEnabled( Dali::RenderTask::DEFAULT_INPUT_ENABLED ),
mClearEnabled( Dali::RenderTask::DEFAULT_CLEAR_ENABLED ),
mCullMode( Dali::RenderTask::DEFAULT_CULL_MODE ),
- mIsSystemLevel( isSystemLevel )
+ mIsSystemLevel( isSystemLevel ),
+ mRequiresSync( false )
{
DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::RenderTask(this:%p)\n", this);
}
RenderTask::Connector::Connector( Type type, RenderTask& renderTask )
: mType( type ),
mRenderTask( renderTask ),
- mActor( NULL )
+ mActor( NULL ),
+ mCamera( NULL )
{
}
}
mActor = NULL;
+ mCamera = NULL; // only meaningful for the camera connector but no simple way to distinguish
UpdateRenderTask();
}
}
else if( CAMERA_CONNECTOR == mType )
{
- SetCameraNodeMessage( mRenderTask.GetEventThreadServices(), *(mRenderTask.mSceneObject), node );
+ SetCameraMessage( mRenderTask.GetEventThreadServices(), *(mRenderTask.mSceneObject), node, mCamera );
}
}
}
projects / platform / core / uifw / dali-core.git / blobdiff