2 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <dali/internal/event/render-tasks/render-task-impl.h>
22 #include <cstring> // for strcmp
25 #include <dali/public-api/common/dali-common.h>
26 #include <dali/public-api/object/type-registry.h>
27 #include <dali/internal/event/common/event-thread-services.h>
28 #include <dali/internal/event/actors/actor-impl.h>
29 #include <dali/internal/event/actors/camera-actor-impl.h>
30 #include <dali/internal/event/common/property-helper.h>
31 #include <dali/internal/event/common/stage-impl.h>
32 #include <dali/internal/event/common/projection.h>
33 #include <dali/internal/event/images/frame-buffer-image-impl.h>
34 #include <dali/internal/update/nodes/node.h>
35 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
36 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
38 #if defined(DEBUG_ENABLED)
41 Debug::Filter* gLogRender = Debug::Filter::New(Debug::Concise, false, "LOG_RENDER_TASK");
51 namespace // For internal properties
56 // Name Type writable animatable constraint-input enum for index-checking
57 DALI_PROPERTY_TABLE_BEGIN
58 DALI_PROPERTY( "viewportPosition", VECTOR2, true, true, true, Dali::RenderTask::Property::VIEWPORT_POSITION )
59 DALI_PROPERTY( "viewportSize", VECTOR2, true, true, true, Dali::RenderTask::Property::VIEWPORT_SIZE )
60 DALI_PROPERTY( "clearColor", VECTOR4, true, true, true, Dali::RenderTask::Property::CLEAR_COLOR )
61 DALI_PROPERTY( "requiresSync", BOOLEAN, true, false, false, Dali::RenderTask::Property::REQUIRES_SYNC )
62 DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX )
66 const char* const SIGNAL_FINISHED = "finished";
68 TypeRegistration mType( typeid( Dali::RenderTask ), typeid( Dali::BaseHandle ), NULL );
70 SignalConnectorType signalConnector1( mType, SIGNAL_FINISHED, &RenderTask::DoConnectSignal );
72 /// Helper to adjust the current value of a variable from the given property-value
73 template< typename PropertyType >
74 inline void AdjustValue( PropertyType& currentValue, const Property::Value& value )
76 PropertyType relativeValue;
77 if( value.Get( relativeValue ) )
79 currentValue += relativeValue;
83 } // Unnamed namespace
85 RenderTask* RenderTask::New( bool isSystemLevel )
87 RenderTask* task( new RenderTask( isSystemLevel ) );
92 void RenderTask::SetSourceActor( Actor* actor )
94 const Stage* stage = Stage::GetCurrent();
97 stage->GetRenderTaskList().SetExclusive( this, mExclusive );
99 mSourceConnector.SetActor( actor );
102 Actor* RenderTask::GetSourceActor() const
104 return mSourceConnector.mActor;
107 void RenderTask::SetExclusive( bool exclusive )
109 if ( mExclusive != exclusive )
111 mExclusive = exclusive;
113 const Stage* stage = Stage::GetCurrent();
116 stage->GetRenderTaskList().SetExclusive( this, exclusive );
121 // mSceneObject is being used in a separate thread; queue a message to set the value
122 SetExclusiveMessage( GetEventThreadServices(), *mSceneObject, mExclusive );
127 bool RenderTask::IsExclusive() const
132 void RenderTask::SetInputEnabled( bool enabled )
134 mInputEnabled = enabled;
137 bool RenderTask::GetInputEnabled() const
139 return mInputEnabled;
142 void RenderTask::SetCameraActor( CameraActor* cameraActor )
146 mCameraConnector.mCamera = cameraActor->GetCamera();
150 mCameraConnector.mCamera = NULL;
152 mCameraConnector.SetActor( cameraActor );
155 CameraActor* RenderTask::GetCameraActor() const
157 // camera connector can only point to camera actor
158 return static_cast< CameraActor* >( mCameraConnector.mActor );
161 void RenderTask::SetTargetFrameBuffer( FrameBufferImagePtr image )
163 mFrameBufferImage = image;
164 FrameBuffer* frameBufferPtr( NULL );
167 frameBufferPtr = image->GetFrameBuffer();
170 SetFrameBuffer( frameBufferPtr );
173 void RenderTask::SetFrameBuffer( FrameBufferPtr frameBuffer )
175 mFrameBuffer = frameBuffer;
176 Render::FrameBuffer* renderFrameBufferPtr( NULL );
179 renderFrameBufferPtr = mFrameBuffer->GetRenderObject();
182 SetFrameBufferMessage( GetEventThreadServices(), *mSceneObject, renderFrameBufferPtr );
185 FrameBuffer* RenderTask::GetFrameBuffer() const
187 return mFrameBuffer.Get();
190 FrameBufferImage* RenderTask::GetTargetFrameBuffer() const
192 return mFrameBufferImage.Get();
195 void RenderTask::SetScreenToFrameBufferFunction( ScreenToFrameBufferFunction conversionFunction )
197 mScreenToFrameBufferFunction = conversionFunction;
200 RenderTask::ScreenToFrameBufferFunction RenderTask::GetScreenToFrameBufferFunction() const
202 return mScreenToFrameBufferFunction;
205 void RenderTask::SetScreenToFrameBufferMappingActor( Actor* mappingActor )
207 mMappingConnector.SetActor( mappingActor );
210 Actor* RenderTask::GetScreenToFrameBufferMappingActor() const
212 return mMappingConnector.mActor;
215 void RenderTask::SetViewportPosition(const Vector2& value)
217 mViewportPosition = value;
219 BakeViewportPositionMessage( GetEventThreadServices(), *mSceneObject, value );
222 Vector2 RenderTask::GetCurrentViewportPosition() const
224 return mSceneObject->GetViewportPosition( GetEventThreadServices().GetEventBufferIndex() );
227 void RenderTask::SetViewportSize(const Vector2& value)
229 mViewportSize = value;
231 BakeViewportSizeMessage( GetEventThreadServices(), *mSceneObject, value );
234 Vector2 RenderTask::GetCurrentViewportSize() const
236 return mSceneObject->GetViewportSize( GetEventThreadServices().GetEventBufferIndex() );
239 void RenderTask::SetViewport( const Viewport& viewport )
241 SetViewportPosition(Vector2(viewport.x, viewport.y));
242 SetViewportSize(Vector2(viewport.width, viewport.height));
245 void RenderTask::GetViewport( Viewport& viewPort ) const
247 BufferIndex bufferIndex = GetEventThreadServices().GetEventBufferIndex();
249 if(!mSceneObject->GetViewportEnabled( bufferIndex ))
251 if ( mFrameBufferImage )
253 viewPort.x = viewPort.y = 0;
254 viewPort.width = mFrameBufferImage->GetWidth();
255 viewPort.height = mFrameBufferImage->GetHeight();
259 Internal::Stage* stage = Internal::Stage::GetCurrent();
262 Vector2 size( stage->GetSize() );
263 viewPort.x = viewPort.y = 0;
264 viewPort.width = size.width;
265 viewPort.height = size.height;
271 const Vector2& position = mSceneObject->GetViewportPosition(bufferIndex);
272 const Vector2& size = mSceneObject->GetViewportSize(bufferIndex);
273 viewPort.x = position.x;
274 viewPort.y = position.y;
275 viewPort.width = size.width;
276 viewPort.height = size.height;
280 void RenderTask::SetClearColor( const Vector4& color )
282 if ( mClearColor != color )
288 // mSceneObject is being used in a separate thread; queue a message to set the value
289 BakeClearColorMessage( GetEventThreadServices(), *mSceneObject, color );
294 const Vector4& RenderTask::GetClearColor() const
296 return mSceneObject->GetClearColor( GetEventThreadServices().GetEventBufferIndex() );
299 void RenderTask::SetSyncRequired( bool requiresSync )
301 if( mRequiresSync != requiresSync )
303 mRequiresSync = requiresSync;
307 // mSceneObject is being used in a separate thread; queue a message to set the value
308 SetSyncRequiredMessage( GetEventThreadServices(), *mSceneObject, requiresSync );
313 bool RenderTask::IsSyncRequired() const
315 return mRequiresSync;
318 void RenderTask::SetClearEnabled( bool enabled )
320 if ( mClearEnabled != enabled )
322 mClearEnabled = enabled;
326 // mSceneObject is being used in a separate thread; queue a message to set the value
327 SetClearEnabledMessage( GetEventThreadServices(), *mSceneObject, mClearEnabled );
332 bool RenderTask::GetClearEnabled() const
334 return mClearEnabled;
337 void RenderTask::SetCullMode( bool mode )
339 if ( mCullMode != mode )
345 // mSceneObject is being used in a separate thread; queue a message to set the value
346 SetCullModeMessage( GetEventThreadServices(), *mSceneObject, mCullMode );
351 bool RenderTask::GetCullMode() const
356 void RenderTask::SetRefreshRate( unsigned int refreshRate )
358 DALI_LOG_TRACE_METHOD_FMT(gLogRender, "this:%p rate:%d\n", this, refreshRate);
359 DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::SetRefreshRate(this:%p, %d)\n", this, refreshRate);
361 mRefreshRate = refreshRate; // cached for GetRefreshRate()
363 // Note - even when refreshRate is the same as mRefreshRate, a message should be sent
367 // mSceneObject is being used in a separate thread; queue a message to set the value
368 SetRefreshRateMessage( GetEventThreadServices(), *mSceneObject, refreshRate );
372 unsigned int RenderTask::GetRefreshRate() const
377 bool RenderTask::IsHittable( Vector2& screenCoords ) const
379 // True when input is enabled, source & camera actor are valid
380 bool inputEnabled( false );
382 Actor* sourceActor = GetSourceActor();
383 CameraActor* cameraActor = GetCameraActor();
385 if ( mInputEnabled &&
386 NULL != sourceActor &&
387 sourceActor->OnStage() &&
388 NULL != cameraActor &&
389 cameraActor->OnStage() )
391 // If the actors are rendered off-screen, then the screen coordinates must be converted
392 // and the conversion function will tell us if they are inside or outside
393 if ( TranslateCoordinates( screenCoords ) )
395 // This is a suitable render-task for input handling
403 bool RenderTask::TranslateCoordinates( Vector2& screenCoords ) const
405 // return true for on-screen tasks
407 // If the actors are rendered off-screen, then the screen coordinates must be converted
408 // the function should only be called for offscreen tasks
409 if( mFrameBufferImage && mMappingConnector.mActor )
411 CameraActor* localCamera = GetCameraActor();
412 StagePtr stage = Stage::GetCurrent();
415 CameraActor& defaultCamera = stage->GetDefaultCameraActor();
419 Vector2 size( stage->GetSize() );
420 viewport.x = viewport.y = 0;
421 viewport.width = size.width;
422 viewport.height = size.height;
424 float localX, localY;
425 inside = mMappingConnector.mActor->ScreenToLocal(defaultCamera.GetViewMatrix(), defaultCamera.GetProjectionMatrix(), viewport, localX, localY, screenCoords.x, screenCoords.y);
426 Vector3 actorSize = mMappingConnector.mActor->GetCurrentSize();
427 if( inside && localX >= 0.f && localX <= actorSize.x && localY >= 0.f && localY <= actorSize.y)
429 screenCoords.x = localX;
430 screenCoords.y = localY;
443 else if ( mFrameBufferImage && mScreenToFrameBufferFunction )
445 inside = mScreenToFrameBufferFunction( screenCoords );
450 bool RenderTask::IsSystemLevel() const
452 return mIsSystemLevel;
455 bool RenderTask::WorldToViewport(const Vector3 &position, float& viewportX, float& viewportY) const
457 CameraActor* cam = GetCameraActor();
459 Vector4 pos(position);
462 Vector4 viewportPosition;
465 GetViewport( viewport );
467 bool ok = ProjectFull(pos,
468 cam->GetViewMatrix(),
469 cam->GetProjectionMatrix(),
477 viewportX = viewportPosition.x;
478 viewportY = viewportPosition.y;
484 bool RenderTask::ViewportToLocal(Actor* actor, float viewportX, float viewportY, float &localX, float &localY) const
486 return actor->ScreenToLocal( *this, localX, localY, viewportX, viewportY );
489 SceneGraph::RenderTask* RenderTask::CreateSceneObject()
491 // This should only be called once, with no existing scene-object
492 DALI_ASSERT_DEBUG( NULL == mSceneObject );
494 // Keep the raw-pointer until DiscardSceneObject is called
495 mSceneObject = SceneGraph::RenderTask::New();
497 // Send messages to set other properties that may have changed since last time we were on stage
498 SetExclusiveMessage( GetEventThreadServices(), *mSceneObject, mExclusive );
499 SetClearColorMessage( GetEventThreadServices(), *mSceneObject, mClearColor );
500 SetClearEnabledMessage( GetEventThreadServices(), *mSceneObject, mClearEnabled );
501 SetCullModeMessage( GetEventThreadServices(), *mSceneObject, mCullMode );
502 SetRefreshRateMessage( GetEventThreadServices(), *mSceneObject, mRefreshRate );
503 SetSyncRequiredMessage( GetEventThreadServices(), *mSceneObject, mRequiresSync );
504 SetFrameBuffer( mFrameBuffer );
506 // Caller takes ownership
510 SceneGraph::RenderTask* RenderTask::GetRenderTaskSceneObject()
515 void RenderTask::DiscardSceneObject()
517 // mSceneObject is not owned; throw away the raw-pointer
521 /********************************************************************************
522 ******************************** PROPERTY METHODS **************************
523 ********************************************************************************/
525 unsigned int RenderTask::GetDefaultPropertyCount() const
527 return DEFAULT_PROPERTY_COUNT;
530 void RenderTask::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
532 indices.Reserve( DEFAULT_PROPERTY_COUNT );
534 for ( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
536 indices.PushBack( i );
540 const char* RenderTask::GetDefaultPropertyName( Property::Index index ) const
542 if( index < DEFAULT_PROPERTY_COUNT )
544 return DEFAULT_PROPERTY_DETAILS[index].name;
552 Property::Index RenderTask::GetDefaultPropertyIndex(const std::string& name) const
554 Property::Index index = Property::INVALID_INDEX;
556 // Look for name in default properties
557 for( int i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
559 if( 0 == strcmp( name.c_str(), DEFAULT_PROPERTY_DETAILS[i].name ) ) // dont want to convert rhs to string
569 bool RenderTask::IsDefaultPropertyWritable(Property::Index index) const
571 return DEFAULT_PROPERTY_DETAILS[ index ].writable;
574 bool RenderTask::IsDefaultPropertyAnimatable(Property::Index index) const
576 return DEFAULT_PROPERTY_DETAILS[ index ].animatable;
579 bool RenderTask::IsDefaultPropertyAConstraintInput( Property::Index index ) const
581 return DEFAULT_PROPERTY_DETAILS[ index ].constraintInput;
584 Property::Type RenderTask::GetDefaultPropertyType(Property::Index index) const
586 if( index < DEFAULT_PROPERTY_COUNT )
588 return DEFAULT_PROPERTY_DETAILS[index].type;
591 // index out of range...return Property::NONE
592 return Property::NONE;
595 void RenderTask::SetDefaultProperty( Property::Index index, const Property::Value& property )
599 case Dali::RenderTask::Property::VIEWPORT_POSITION:
601 SetViewportPosition( property.Get<Vector2>() );
604 case Dali::RenderTask::Property::VIEWPORT_SIZE:
606 SetViewportSize( property.Get<Vector2>() );
609 case Dali::RenderTask::Property::CLEAR_COLOR:
611 SetClearColor( property.Get<Vector4>() );
614 case Dali::RenderTask::Property::REQUIRES_SYNC:
616 SetSyncRequired( property.Get<bool>() );
627 Property::Value RenderTask::GetDefaultProperty(Property::Index index) const
629 Property::Value value;
634 case Dali::RenderTask::Property::VIEWPORT_POSITION:
636 value = mViewportPosition;
639 case Dali::RenderTask::Property::VIEWPORT_SIZE:
641 value = mViewportSize;
644 case Dali::RenderTask::Property::CLEAR_COLOR:
649 case Dali::RenderTask::Property::REQUIRES_SYNC:
651 value = IsSyncRequired();
657 DALI_ASSERT_ALWAYS(false && "RenderTask property index out of range"); // should not come here
665 Property::Value RenderTask::GetDefaultPropertyCurrentValue( Property::Index index ) const
667 Property::Value value;
672 case Dali::RenderTask::Property::VIEWPORT_POSITION:
674 value = GetCurrentViewportPosition();
677 case Dali::RenderTask::Property::VIEWPORT_SIZE:
679 value = GetCurrentViewportSize();
682 case Dali::RenderTask::Property::CLEAR_COLOR:
684 value = GetClearColor();
687 case Dali::RenderTask::Property::REQUIRES_SYNC:
689 value = IsSyncRequired();
695 DALI_ASSERT_ALWAYS(false && "RenderTask property index out of range"); // should not come here
703 void RenderTask::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, PropertyChange::Type propertyChangeType )
705 if( propertyChangeType == Object::PropertyChange::SET )
709 case Dali::RenderTask::Property::VIEWPORT_POSITION:
711 value.Get( mViewportPosition );
714 case Dali::RenderTask::Property::VIEWPORT_SIZE:
716 value.Get( mViewportSize );
719 case Dali::RenderTask::Property::CLEAR_COLOR:
721 value.Get( mClearColor );
724 case Dali::RenderTask::Property::REQUIRES_SYNC:
727 // Nothing to do as not animatable
736 case Dali::RenderTask::Property::VIEWPORT_POSITION:
738 AdjustValue< Vector2 >( mViewportPosition, value );
741 case Dali::RenderTask::Property::VIEWPORT_SIZE:
743 AdjustValue< Vector2 >( mViewportSize, value );
746 case Dali::RenderTask::Property::CLEAR_COLOR:
748 AdjustValue< Vector4 >( mClearColor, value );
751 case Dali::RenderTask::Property::REQUIRES_SYNC:
754 // Nothing to do as not animatable
761 const SceneGraph::PropertyOwner* RenderTask::GetSceneObject() const
766 const SceneGraph::PropertyBase* RenderTask::GetSceneObjectAnimatableProperty( Property::Index index ) const
768 DALI_ASSERT_ALWAYS( IsPropertyAnimatable(index) && "Property is not animatable" );
770 const SceneGraph::PropertyBase* property( NULL );
772 // This method should only return a property which is part of the scene-graph
773 if( mSceneObject != NULL )
777 case Dali::RenderTask::Property::VIEWPORT_POSITION:
778 property = &mSceneObject->mViewportPosition;
781 case Dali::RenderTask::Property::VIEWPORT_SIZE:
782 property = &mSceneObject->mViewportSize;
785 case Dali::RenderTask::Property::CLEAR_COLOR:
786 property = &mSceneObject->mClearColor;
797 const PropertyInputImpl* RenderTask::GetSceneObjectInputProperty( Property::Index index ) const
799 const PropertyInputImpl* property( NULL );
800 if( mSceneObject != NULL )
804 case Dali::RenderTask::Property::VIEWPORT_POSITION:
805 property = &mSceneObject->mViewportPosition;
808 case Dali::RenderTask::Property::VIEWPORT_SIZE:
809 property = &mSceneObject->mViewportSize;
812 case Dali::RenderTask::Property::CLEAR_COLOR:
813 property = &mSceneObject->mClearColor;
824 bool RenderTask::HasFinished()
826 bool finished = false;
827 const unsigned int counter = mSceneObject->GetRenderedOnceCounter();
829 if( mRefreshOnceCounter < counter )
832 mRefreshOnceCounter = counter;
835 DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::HasFinished()=%s SCRT:%p SC\n", finished?"T":"F", mSceneObject);
840 void RenderTask::EmitSignalFinish()
842 DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::EmitSignalFinish(this:%p)\n", this);
844 if( !mSignalFinished.Empty() )
846 Dali::RenderTask handle( this );
847 mSignalFinished.Emit(handle );
851 Dali::RenderTask::RenderTaskSignalType& RenderTask::FinishedSignal()
853 return mSignalFinished;
856 bool RenderTask::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
858 bool connected( true );
859 RenderTask* renderTask = static_cast< RenderTask* >(object); // TypeRegistry guarantees that this is the correct type.
861 if ( 0 == strcmp( signalName.c_str(), SIGNAL_FINISHED ) )
863 renderTask->FinishedSignal().Connect( tracker, functor );
867 // signalName does not match any signal
874 RenderTask::RenderTask( bool isSystemLevel )
875 : mSceneObject( NULL ),
876 mSourceConnector( Connector::SOURCE_CONNECTOR, *this ),
877 mCameraConnector( Connector::CAMERA_CONNECTOR, *this ),
878 mMappingConnector( Connector::MAPPING_CONNECTOR, *this ),
879 mClearColor( Dali::RenderTask::DEFAULT_CLEAR_COLOR ),
880 mViewportPosition( Vector2::ZERO ),
881 mViewportSize( Vector2::ZERO ),
882 mRefreshRate( Dali::RenderTask::DEFAULT_REFRESH_RATE ),
883 mRefreshOnceCounter( 0u ),
884 mScreenToFrameBufferFunction( Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION ),
885 mExclusive( Dali::RenderTask::DEFAULT_EXCLUSIVE ),
886 mInputEnabled( Dali::RenderTask::DEFAULT_INPUT_ENABLED ),
887 mClearEnabled( Dali::RenderTask::DEFAULT_CLEAR_ENABLED ),
888 mCullMode( Dali::RenderTask::DEFAULT_CULL_MODE ),
889 mIsSystemLevel( isSystemLevel ),
890 mRequiresSync( false )
892 DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::RenderTask(this:%p)\n", this);
895 RenderTask::~RenderTask()
897 DALI_LOG_INFO(gLogRender, Debug::General, "RenderTask::~RenderTask(this:%p)\n", this);
900 // Helper class for connecting Nodes to the scene-graph RenderTask
902 RenderTask::Connector::Connector( Type type, RenderTask& renderTask )
904 mRenderTask( renderTask ),
910 RenderTask::Connector::~Connector()
915 void RenderTask::Connector::SetActor( Actor* actor )
917 if ( mActor != actor )
921 mActor->RemoveObserver( *this );
928 mActor->AddObserver( *this );
935 void RenderTask::Connector::SceneObjectAdded( Object& object )
940 void RenderTask::Connector::SceneObjectRemoved( Object& object )
945 void RenderTask::Connector::ObjectDestroyed( Object& object )
947 if ( SOURCE_CONNECTOR == mType )
949 const Stage* stage = Stage::GetCurrent();
952 stage->GetRenderTaskList().SetExclusive( &mRenderTask, false );
957 mCamera = NULL; // only meaningful for the camera connector but no simple way to distinguish
962 void RenderTask::Connector::UpdateRenderTask()
964 // Guard to allow handle destruction after Core has been destroyed
965 if( Internal::Stage::IsInstalled() &&
966 mRenderTask.mSceneObject )
968 const SceneGraph::Node* node( NULL );
970 // Check whether a Node exists in the scene-graph
971 if ( NULL != mActor )
973 const SceneGraph::PropertyOwner* object = mActor->GetSceneObject();
974 if ( NULL != object )
976 // actors only point to nodes as their scene objects
977 node = static_cast< const SceneGraph::Node* >( object );
981 //the mapping node is not used in the scene graph
982 if ( SOURCE_CONNECTOR == mType )
984 SetSourceNodeMessage( mRenderTask.GetEventThreadServices(), *(mRenderTask.mSceneObject), node );
986 else if( CAMERA_CONNECTOR == mType )
988 SetCameraMessage( mRenderTask.GetEventThreadServices(), *(mRenderTask.mSceneObject), node, mCamera );
993 } // namespace Internal