/*
- * 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.
// CLASS HEADER
#include <dali/internal/event/render-tasks/render-task-impl.h>
+// EXTERNAL INCLUDES
+#include <cstring> // for strcmp
+
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-#include <dali/internal/common/event-to-update.h>
+#include <dali/public-api/object/type-registry.h>
+#include <dali/internal/event/common/event-thread-services.h>
#include <dali/internal/event/actors/actor-impl.h>
#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/thread-local-storage.h>
+#include <dali/internal/event/common/projection.h>
#include <dali/internal/event/images/frame-buffer-image-impl.h>
-#include <dali/internal/update/render-tasks/scene-graph-render-task.h>
#include <dali/internal/update/nodes/node.h>
+#include <dali/internal/event/render-tasks/render-task-list-impl.h>
+#include <dali/internal/update/render-tasks/scene-graph-render-task.h>
#if defined(DEBUG_ENABLED)
namespace
namespace Dali
{
-const Property::Index RenderTask::VIEWPORT_POSITION = 0;
-const Property::Index RenderTask::VIEWPORT_SIZE = 1;
-const Property::Index RenderTask::CLEAR_COLOR = 2;
-
namespace Internal
{
namespace // For internal properties
{
-const std::string DEFAULT_PROPERTY_NAMES[] =
-{
- "viewport-position",
- "viewport-size",
- "clear-color"
-};
-const int DEFAULT_PROPERTY_COUNT = sizeof( DEFAULT_PROPERTY_NAMES ) / sizeof( std::string );
+// Properties
-const Property::Type DEFAULT_PROPERTY_TYPES[DEFAULT_PROPERTY_COUNT] =
-{
- Property::VECTOR2, // viewport-position
- Property::VECTOR2, // viewport-size
- Property::VECTOR4, // clear-color
-};
+// Name Type writable animatable constraint-input enum for index-checking
+DALI_PROPERTY_TABLE_BEGIN
+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 )
-}// unnamed namespace
+// Signals
-RenderTask::DefaultPropertyLookup* RenderTask::sDefaultPropertyLookup = NULL;
+const char* const SIGNAL_FINISHED = "finished";
+
+TypeRegistration mType( typeid( Dali::RenderTask ), typeid( Dali::BaseHandle ), NULL );
+
+SignalConnectorType signalConnector1( mType, SIGNAL_FINISHED, &RenderTask::DoConnectSignal );
+
+} // Unnamed namespace
RenderTask* RenderTask::New( bool isSystemLevel )
{
- RenderTask* task( new RenderTask( ThreadLocalStorage::Get().GetEventToUpdate(), isSystemLevel ) );
+ RenderTask* task( new RenderTask( isSystemLevel ) );
return task;
}
void RenderTask::SetSourceActor( Actor* actor )
{
+ const Stage* stage = Stage::GetCurrent();
+ if ( stage )
+ {
+ stage->GetRenderTaskList().SetExclusive( this, mExclusive );
+ }
mSourceConnector.SetActor( actor );
}
{
mExclusive = exclusive;
+ const Stage* stage = Stage::GetCurrent();
+ if ( stage )
+ {
+ stage->GetRenderTaskList().SetExclusive( this, exclusive );
+ }
+
if ( mSceneObject )
{
// mSceneObject is being used in a separate thread; queue a message to set the value
- SetExclusiveMessage( mEventToUpdate, *mSceneObject, mExclusive );
+ SetExclusiveMessage( GetEventThreadServices(), *mSceneObject, mExclusive );
}
}
}
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( mEventToUpdate, *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)
{
- StagePtr stage = Stage::GetCurrent();
- BakeViewportPositionMessage( stage->GetUpdateInterface(), *mSceneObject, value );
+ mViewportPosition = value;
+
+ BakeViewportPositionMessage( GetEventThreadServices(), *mSceneObject, value );
}
Vector2 RenderTask::GetCurrentViewportPosition() const
{
- StagePtr stage = Stage::GetCurrent();
- return mSceneObject->GetViewportPosition(stage->GetEventBufferIndex());
+ return mSceneObject->GetViewportPosition( GetEventThreadServices().GetEventBufferIndex() );
}
void RenderTask::SetViewportSize(const Vector2& value)
{
- StagePtr stage = Stage::GetCurrent();
- BakeViewportSizeMessage( stage->GetUpdateInterface(), *mSceneObject, value );
+ mViewportSize = value;
+
+ BakeViewportSizeMessage( GetEventThreadServices(), *mSceneObject, value );
}
Vector2 RenderTask::GetCurrentViewportSize() const
{
- StagePtr stage = Stage::GetCurrent();
- return mSceneObject->GetViewportSize(stage->GetEventBufferIndex());
+ return mSceneObject->GetViewportSize( GetEventThreadServices().GetEventBufferIndex() );
}
void RenderTask::SetViewport( const Viewport& viewport )
void RenderTask::GetViewport( Viewport& viewPort ) const
{
- BufferIndex bufferIndex = Stage::GetCurrent()->GetEventBufferIndex();
+ BufferIndex bufferIndex = GetEventThreadServices().GetEventBufferIndex();
if(!mSceneObject->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 = size.width;
+ viewPort.height = size.height;
+ }
}
}
else
if ( mSceneObject )
{
// mSceneObject is being used in a separate thread; queue a message to set the value
- StagePtr stage = Stage::GetCurrent();
- BakeClearColorMessage( stage->GetUpdateInterface(), *mSceneObject, color );
+ BakeClearColorMessage( GetEventThreadServices(), *mSceneObject, color );
}
}
}
const Vector4& RenderTask::GetClearColor() const
{
- StagePtr stage = Stage::GetCurrent();
- return mSceneObject->GetClearColor(stage->GetEventBufferIndex());
+ 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 ( mSceneObject )
{
// mSceneObject is being used in a separate thread; queue a message to set the value
- SetClearEnabledMessage( mEventToUpdate, *mSceneObject, mClearEnabled );
+ SetClearEnabledMessage( GetEventThreadServices(), *mSceneObject, mClearEnabled );
}
}
}
return mClearEnabled;
}
+void RenderTask::SetCullMode( bool mode )
+{
+ if ( mCullMode != mode )
+ {
+ mCullMode = mode;
+
+ if ( mSceneObject )
+ {
+ // mSceneObject is being used in a separate thread; queue a message to set the value
+ SetCullModeMessage( GetEventThreadServices(), *mSceneObject, mCullMode );
+ }
+ }
+}
+
+bool RenderTask::GetCullMode() const
+{
+ return mCullMode;
+}
+
void RenderTask::SetRefreshRate( unsigned int refreshRate )
{
DALI_LOG_TRACE_METHOD_FMT(gLogRender, "this:%p rate:%d\n", this, refreshRate);
if ( mSceneObject )
{
// mSceneObject is being used in a separate thread; queue a message to set the value
- SetRefreshRateMessage( mEventToUpdate, *mSceneObject, refreshRate );
+ SetRefreshRateMessage( GetEventThreadServices(), *mSceneObject, refreshRate );
}
}
{
CameraActor* localCamera = GetCameraActor();
StagePtr stage = Stage::GetCurrent();
- CameraActor& defaultCamera = stage->GetDefaultCameraActor();
- if( localCamera )
- {
- 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)
+ if( stage )
+ {
+ 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 = 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)
+ {
+ screenCoords.x = localX;
+ screenCoords.y = localY;
+ }
+ else
+ {
+ inside = false;
+ }
}
else
{
inside = false;
}
}
- else
- {
- inside = false;
- }
}
else if ( mFrameBufferImage && mScreenToFrameBufferFunction )
{
return mIsSystemLevel;
}
+bool RenderTask::WorldToViewport(const Vector3 &position, float& viewportX, float& viewportY) const
+{
+ CameraActor* cam = GetCameraActor();
+
+ Vector4 pos(position);
+ pos.w = 1.0;
+
+ Vector4 viewportPosition;
+
+ Viewport viewport;
+ GetViewport( viewport );
+
+ bool ok = ProjectFull(pos,
+ cam->GetViewMatrix(),
+ cam->GetProjectionMatrix(),
+ viewport.x,
+ viewport.y,
+ viewport.width,
+ viewport.height,
+ viewportPosition);
+ if(ok)
+ {
+ viewportX = viewportPosition.x;
+ viewportY = viewportPosition.y;
+ }
+
+ return ok;
+}
+
+bool RenderTask::ViewportToLocal(Actor* actor, float viewportX, float viewportY, float &localX, float &localY) const
+{
+ return actor->ScreenToLocal( *this, localX, localY, viewportX, viewportY );
+}
+
SceneGraph::RenderTask* RenderTask::CreateSceneObject()
{
// This should only be called once, with no existing scene-object
// 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( mEventToUpdate, *mSceneObject, resourceId );
-
// Send messages to set other properties that may have changed since last time we were on stage
- SetExclusiveMessage( mEventToUpdate, *mSceneObject, mExclusive );
- SetClearColorMessage( mEventToUpdate, *mSceneObject, mClearColor );
- SetClearEnabledMessage( mEventToUpdate, *mSceneObject, mClearEnabled );
- SetRefreshRateMessage( mEventToUpdate, *mSceneObject, mRefreshRate );
+ 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();
- }
}
/********************************************************************************
- ********************************************************************************
******************************** PROPERTY METHODS **************************
- ********************************************************************************
********************************************************************************/
-bool RenderTask::IsSceneObjectRemovable() const
-{
- return false; // The scene object is permanently "on stage" whilst this object is alive
-}
-
unsigned int RenderTask::GetDefaultPropertyCount() const
{
return DEFAULT_PROPERTY_COUNT;
void RenderTask::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
{
- indices.reserve( DEFAULT_PROPERTY_COUNT );
+ indices.Reserve( DEFAULT_PROPERTY_COUNT );
for ( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
- indices.push_back( i );
+ indices.PushBack( i );
}
}
-const std::string& RenderTask::GetDefaultPropertyName( Property::Index index ) const
+const char* RenderTask::GetDefaultPropertyName( Property::Index index ) const
{
if( index < DEFAULT_PROPERTY_COUNT )
{
- return DEFAULT_PROPERTY_NAMES[index];
+ return DEFAULT_PROPERTY_DETAILS[index].name;
}
else
{
- // index out of range..return empty string
- static const std::string INVALID_PROPERTY_NAME;
- return INVALID_PROPERTY_NAME;
+ return NULL;
}
}
{
Property::Index index = Property::INVALID_INDEX;
- // Lazy initialization of static sDefaultPropertyLookup
- if (!sDefaultPropertyLookup)
+ // Look for name in default properties
+ for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
{
- sDefaultPropertyLookup = new DefaultPropertyLookup();
-
- 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
{
- (*sDefaultPropertyLookup)[DEFAULT_PROPERTY_NAMES[i]] = i;
+ index = i;
+ break;
}
}
- DALI_ASSERT_DEBUG( NULL != sDefaultPropertyLookup );
-
- // Look for name in default properties
- DefaultPropertyLookup::const_iterator result = sDefaultPropertyLookup->find( name );
- if ( sDefaultPropertyLookup->end() != result )
- {
- index = result->second;
- }
return index;
}
bool RenderTask::IsDefaultPropertyWritable(Property::Index index) const
{
- return true;
+ return DEFAULT_PROPERTY_DETAILS[ index ].writable;
}
bool RenderTask::IsDefaultPropertyAnimatable(Property::Index index) const
{
- return true;
+ return DEFAULT_PROPERTY_DETAILS[ index ].animatable;
}
bool RenderTask::IsDefaultPropertyAConstraintInput( Property::Index index ) const
{
- return true;
+ return DEFAULT_PROPERTY_DETAILS[ index ].constraintInput;
}
Property::Type RenderTask::GetDefaultPropertyType(Property::Index index) const
{
if( index < DEFAULT_PROPERTY_COUNT )
{
- return DEFAULT_PROPERTY_TYPES[index];
- }
- else
- {
- // index out of range...return Property::NONE
- return Property::NONE;
+ return DEFAULT_PROPERTY_DETAILS[index].type;
}
+
+ // index out of range...return Property::NONE
+ return Property::NONE;
}
void RenderTask::SetDefaultProperty( Property::Index index, const Property::Value& property )
{
switch ( index )
{
- case Dali::RenderTask::VIEWPORT_POSITION:
+ case Dali::RenderTask::Property::VIEWPORT_POSITION:
{
SetViewportPosition( property.Get<Vector2>() );
break;
}
- case Dali::RenderTask::VIEWPORT_SIZE:
+ case Dali::RenderTask::Property::VIEWPORT_SIZE:
{
SetViewportSize( property.Get<Vector2>() );
break;
}
- case Dali::RenderTask::CLEAR_COLOR:
+ case Dali::RenderTask::Property::CLEAR_COLOR:
{
SetClearColor( property.Get<Vector4>() );
break;
}
-
+ case Dali::RenderTask::Property::REQUIRES_SYNC:
+ {
+ SetSyncRequired( property.Get<bool>() );
+ break;
+ }
default:
{
- DALI_ASSERT_ALWAYS(false && "RenderTask property index out of range"); // should not come here
+ // nothing to do
break;
}
}
}
-void RenderTask::SetCustomProperty( Property::Index /*index*/, const CustomProperty& /*entry*/, const Property::Value& /*value*/ )
+Property::Value RenderTask::GetDefaultProperty(Property::Index index) const
{
- // TODO: support them, it doesn't hurt.
- DALI_ASSERT_ALWAYS( 0 && "RenderTask does not support custom properties");
+ Property::Value value;
+
+ switch ( index )
+ {
+
+ 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::GetDefaultProperty(Property::Index index) const
+Property::Value RenderTask::GetDefaultPropertyCurrentValue( Property::Index index ) const
{
Property::Value value;
switch ( index )
{
- case Dali::RenderTask::VIEWPORT_POSITION:
+ case Dali::RenderTask::Property::VIEWPORT_POSITION:
{
value = GetCurrentViewportPosition();
break;
}
- case Dali::RenderTask::VIEWPORT_SIZE:
+ case Dali::RenderTask::Property::VIEWPORT_SIZE:
{
value = GetCurrentViewportSize();
break;
}
- case Dali::RenderTask::CLEAR_COLOR:
+ case Dali::RenderTask::Property::CLEAR_COLOR:
{
value = GetClearColor();
break;
}
+ case Dali::RenderTask::Property::REQUIRES_SYNC:
+ {
+ value = IsSyncRequired();
+ break;
+ }
default:
{
return value;
}
-void RenderTask::InstallSceneObjectProperty( SceneGraph::PropertyBase& newProperty, const std::string& name, unsigned int index )
+void RenderTask::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value )
{
- // TODO: support them, it doesn't hurt.
- DALI_ASSERT_ALWAYS( 0 && "RenderTask does not support custom properties" );
+ 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
{
switch ( index )
{
- case Dali::RenderTask::VIEWPORT_POSITION:
+ case Dali::RenderTask::Property::VIEWPORT_POSITION:
property = &mSceneObject->mViewportPosition;
break;
- case Dali::RenderTask::VIEWPORT_SIZE:
+ case Dali::RenderTask::Property::VIEWPORT_SIZE:
property = &mSceneObject->mViewportSize;
break;
- case Dali::RenderTask::CLEAR_COLOR:
+ case Dali::RenderTask::Property::CLEAR_COLOR:
property = &mSceneObject->mClearColor;
break;
{
switch ( index )
{
- case Dali::RenderTask::VIEWPORT_POSITION:
+ case Dali::RenderTask::Property::VIEWPORT_POSITION:
property = &mSceneObject->mViewportPosition;
break;
- case Dali::RenderTask::VIEWPORT_SIZE:
+ case Dali::RenderTask::Property::VIEWPORT_SIZE:
property = &mSceneObject->mViewportSize;
break;
- case Dali::RenderTask::CLEAR_COLOR:
- property = &mSceneObject->mViewportSize;
+ case Dali::RenderTask::Property::CLEAR_COLOR:
+ property = &mSceneObject->mClearColor;
break;
default:
{
DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::EmitSignalFinish(this:%p)\n", this);
- if( !mSignalFinishedV2.Empty() )
+ if( !mSignalFinished.Empty() )
{
Dali::RenderTask handle( this );
- mSignalFinishedV2.Emit(handle );
+ mSignalFinished.Emit(handle );
}
}
-Dali::RenderTask::RenderTaskSignalV2& RenderTask::FinishedSignal()
+Dali::RenderTask::RenderTaskSignalType& RenderTask::FinishedSignal()
{
- return mSignalFinishedV2;
+ return mSignalFinished;
}
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 ( Dali::RenderTask::SIGNAL_FINISHED == signalName )
+ if ( 0 == strcmp( signalName.c_str(), SIGNAL_FINISHED ) )
{
renderTask->FinishedSignal().Connect( tracker, functor );
}
return connected;
}
-RenderTask::RenderTask( EventToUpdate& eventToUpdate, bool isSystemLevel )
-: mEventToUpdate( eventToUpdate ),
- mSceneObject( NULL ),
+RenderTask::RenderTask( bool isSystemLevel )
+: mSceneObject( NULL ),
mSourceConnector( Connector::SOURCE_CONNECTOR, *this ),
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 ),
mExclusive( Dali::RenderTask::DEFAULT_EXCLUSIVE ),
mInputEnabled( Dali::RenderTask::DEFAULT_INPUT_ENABLED ),
mClearEnabled( Dali::RenderTask::DEFAULT_CLEAR_ENABLED ),
- mIsSystemLevel( isSystemLevel )
+ mCullMode( Dali::RenderTask::DEFAULT_CULL_MODE ),
+ 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 )
{
}
}
}
-void RenderTask::Connector::SceneObjectAdded( ProxyObject& proxy )
+void RenderTask::Connector::SceneObjectAdded( Object& object )
{
UpdateRenderTask();
}
-void RenderTask::Connector::SceneObjectRemoved( ProxyObject& proxy )
+void RenderTask::Connector::SceneObjectRemoved( Object& object )
{
UpdateRenderTask();
}
-void RenderTask::Connector::ProxyDestroyed( ProxyObject& proxy )
+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();
}
//the mapping node is not used in the scene graph
if ( SOURCE_CONNECTOR == mType )
{
- SetSourceNodeMessage( mRenderTask.mEventToUpdate, *(mRenderTask.mSceneObject), node );
+ SetSourceNodeMessage( mRenderTask.GetEventThreadServices(), *(mRenderTask.mSceneObject), node );
}
else if( CAMERA_CONNECTOR == mType )
{
- SetCameraNodeMessage( mRenderTask.mEventToUpdate, *(mRenderTask.mSceneObject), node );
+ SetCameraMessage( mRenderTask.GetEventThreadServices(), *(mRenderTask.mSceneObject), node, mCamera );
}
}
}
projects / platform / core / uifw / dali-core.git / blobdiff