/*
- * 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.
#include <dali/internal/event/actors/camera-actor-impl.h>
#include <dali/internal/event/common/property-helper.h>
#include <dali/internal/event/common/stage-impl.h>
+#include <dali/internal/event/common/projection.h>
#include <dali/internal/event/images/frame-buffer-image-impl.h>
#include <dali/internal/update/nodes/node.h>
#include <dali/internal/update/render-tasks/scene-graph-render-task.h>
// Name Type writable animatable constraint-input enum for index-checking
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "viewport-position", VECTOR2, true, true, true, Dali::RenderTask::Property::VIEWPORT_POSITION )
-DALI_PROPERTY( "viewport-size", VECTOR2, true, true, true, Dali::RenderTask::Property::VIEWPORT_SIZE )
-DALI_PROPERTY( "clear-color", VECTOR4, true, true, true, Dali::RenderTask::Property::CLEAR_COLOR )
-DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX )
+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, 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 )
{
- mSourceConnector.SetActor( actor );
+ mSourceActor = actor;
+ if ( mSourceActor )
+ {
+ SetSourceNodeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), &mSourceActor->GetNode() );
+ }
+ else
+ {
+ SetSourceNodeMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), nullptr );
+ }
+
+ // set the actor on exclusive container for hit testing
+ mRenderTaskList.SetExclusive( this, mExclusive );
}
Actor* RenderTask::GetSourceActor() const
{
- return mSourceConnector.mActor;
+ return mSourceActor;
}
void RenderTask::SetExclusive( bool exclusive )
{
mExclusive = exclusive;
- if ( mSceneObject )
- {
- // mSceneObject is being used in a separate thread; queue a message to set the value
- SetExclusiveMessage( GetEventThreadServices(), *mSceneObject, mExclusive );
- }
+ mRenderTaskList.SetExclusive( this, exclusive );
+
+ // scene object is being used in a separate thread; queue a message to set the value
+ SetExclusiveMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), mExclusive );
}
}
void RenderTask::SetCameraActor( CameraActor* cameraActor )
{
- mCameraConnector.SetActor( cameraActor );
+ mCameraActor = cameraActor;
+ if( mCameraActor )
+ {
+ SetCameraMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), &mCameraActor->GetNode(), mCameraActor->GetCamera() );
+ }
+ else
+ {
+ SetCameraMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), nullptr, nullptr );
+ }
+
+ // 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 );
+ return mCameraActor;
}
-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(), GetRenderTaskSceneObject(), 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 )
return mScreenToFrameBufferFunction;
}
-void RenderTask::SetScreenToFrameBufferMappingActor( Actor* mappingActor )
+void RenderTask::SetScreenToFrameBufferMappingActor( Dali::Actor& mappingActor )
{
- mMappingConnector.SetActor( mappingActor );
+ mInputMappingActor = WeakHandle<Dali::Actor>( 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<float>( viewport.x ), static_cast<float>( viewport.y ) ) );
+ SetViewportSize( Vector2( static_cast<float>( viewport.width ), static_cast<float>( 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
{
- Vector2 size( Stage::GetCurrent()->GetSize() );
- viewPort.x = viewPort.y = 0;
- viewPort.width = size.width;
- viewPort.height = size.height;
+ Internal::Stage* stage = Internal::Stage::GetCurrent();
+ if ( stage )
+ {
+ Vector2 size( stage->GetSize() );
+ viewPort.x = viewPort.y = 0;
+ viewPort.width = static_cast<int32_t>( size.width ); // truncated
+ viewPort.height = static_cast<int32_t>( 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<int32_t>( position.x ); // truncated
+ viewPort.y = static_cast<int32_t>( position.y ); // truncated
+ viewPort.width = static_cast<int32_t>( size.width ); // truncated
+ viewPort.height = static_cast<int32_t>( size.height ); // truncated
}
}
{
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 )
+{
+ if( mRequiresSync != requiresSync )
+ {
+ mRequiresSync = requiresSync;
+
+ // scene object is being used in a separate thread; queue a message to set the value
+ SetSyncRequiredMessage( GetEventThreadServices(), GetRenderTaskSceneObject(), requiresSync );
+ }
+}
+
+bool RenderTask::IsSyncRequired() const
+{
+ return mRequiresSync;
}
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 );
}
}
{
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 );
}
}
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);
// 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;
}
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
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();
- CameraActor& defaultCamera = stage->GetDefaultCameraActor();
- if( localCamera )
+ if( stage )
{
- Viewport viewport;
- Vector2 size( stage->GetSize() );
- viewport.x = viewport.y = 0;
- viewport.width = size.width;
- viewport.height = size.height;
-
- float localX, localY;
- inside = mMappingConnector.mActor->ScreenToLocal(defaultCamera.GetViewMatrix(), defaultCamera.GetProjectionMatrix(), viewport, localX, localY, screenCoords.x, screenCoords.y);
- Vector3 actorSize = mMappingConnector.mActor->GetCurrentSize();
- if( inside && localX >= 0.f && localX <= actorSize.x && localY >= 0.f && localY <= actorSize.y)
+ CameraActor& defaultCamera = stage->GetDefaultCameraActor();
+ if( localCamera )
{
- screenCoords.x = localX;
- screenCoords.y = localY;
+ Viewport viewport;
+ Vector2 size( stage->GetSize() );
+ viewport.x = viewport.y = 0;
+ viewport.width = static_cast<int32_t>( size.width ); // truncated
+ viewport.height = static_cast<int32_t>( size.height ); // truncated
+
+ float localX, localY;
+ 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;
+ screenCoords.y = localY;
+ }
+ else
+ {
+ inside = false;
+ }
}
else
{
inside = false;
}
}
- else
- {
- inside = false;
- }
}
else if ( mFrameBufferImage && mScreenToFrameBufferFunction )
{
return inside;
}
-bool RenderTask::IsSystemLevel() const
+bool RenderTask::WorldToViewport(const Vector3 &position, float& viewportX, float& viewportY) const
{
- return mIsSystemLevel;
-}
+ CameraActor* cam = GetCameraActor();
-SceneGraph::RenderTask* RenderTask::CreateSceneObject()
-{
- // This should only be called once, with no existing scene-object
- DALI_ASSERT_DEBUG( NULL == mSceneObject );
+ Vector4 pos(position);
+ pos.w = 1.0;
- // Keep the raw-pointer until DiscardSceneObject is called
- mSceneObject = SceneGraph::RenderTask::New();
+ Vector4 viewportPosition;
- // 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();
+ Viewport viewport;
+ GetViewport( viewport );
- resourceId = GetImplementation( mFrameBufferImage ).GetResourceId();
+ bool ok = ProjectFull(pos,
+ cam->GetViewMatrix(),
+ cam->GetProjectionMatrix(),
+ static_cast<float>( viewport.x ), // truncated
+ static_cast<float>( viewport.y ), // truncated
+ static_cast<float>( viewport.width ), // truncated
+ static_cast<float>( viewport.height ), // truncated
+ viewportPosition);
+ if(ok)
+ {
+ viewportX = viewportPosition.x;
+ viewportY = viewportPosition.y;
}
- // 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 );
-
- // Caller takes ownership
- return mSceneObject;
+ return ok;
}
-SceneGraph::RenderTask* RenderTask::GetRenderTaskSceneObject()
+bool RenderTask::ViewportToLocal(Actor* actor, float viewportX, float viewportY, float &localX, float &localY) const
{
- return mSceneObject;
+ return actor->ScreenToLocal( *this, localX, localY, viewportX, viewportY );
}
-void RenderTask::DiscardSceneObject()
+const SceneGraph::RenderTask& RenderTask::GetRenderTaskSceneObject() const
{
- // 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 *static_cast<const SceneGraph::RenderTask*>( mUpdateObject );
}
/********************************************************************************
******************************** 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.push_back( 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:
{
- index = i;
+ SetViewportPosition( property.Get<Vector2>() );
+ break;
+ }
+ case Dali::RenderTask::Property::VIEWPORT_SIZE:
+ {
+ SetViewportSize( property.Get<Vector2>() );
+ break;
+ }
+ case Dali::RenderTask::Property::CLEAR_COLOR:
+ {
+ SetClearColor( property.Get<Vector4>() );
+ break;
+ }
+ case Dali::RenderTask::Property::REQUIRES_SYNC:
+ {
+ SetSyncRequired( property.Get<bool>() );
+ 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<Vector2>() );
+ value = mViewportPosition;
break;
}
case Dali::RenderTask::Property::VIEWPORT_SIZE:
{
- SetViewportSize( property.Get<Vector2>() );
+ value = mViewportSize;
break;
}
case Dali::RenderTask::Property::CLEAR_COLOR:
{
- SetClearColor( property.Get<Vector4>() );
+ value = mClearColor;
break;
}
+ case Dali::RenderTask::Property::REQUIRES_SYNC:
+ {
+ 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();
value = GetClearColor();
break;
}
+ case Dali::RenderTask::Property::REQUIRES_SYNC:
+ {
+ value = IsSyncRequired();
+ break;
+ }
default:
{
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;
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->mViewportSize;
- 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 )
{
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;
}
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 ) )
{
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( nullptr ),
+ mCameraActor( nullptr ),
+ 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 ),
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 )
-{
-}
-
-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 )
-{
- mActor = NULL;
-
- 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 )
- {
- SetCameraNodeMessage( mRenderTask.GetEventThreadServices(), *(mRenderTask.mSceneObject), node );
- }
- }
+ // scene object deletion is handled by our parent
+ // scene object handles observation of source and camera
}
} // namespace Internal
projects / platform / core / uifw / dali-core.git / blobdiff