dali/internal/update/manager/update-manager.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/update/manager/update-manager.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/common/stage.h>
  23 #include <dali/devel-api/common/owner-container.h>
  24 #include <dali/devel-api/threading/mutex.h>
  25
  26 #include <dali/integration-api/core.h>
  27 #include <dali/integration-api/render-controller.h>
  28 #include <dali/internal/common/shader-data.h>
  29 #include <dali/integration-api/debug.h>
  30
  31 #include <dali/internal/common/core-impl.h>
  32 #include <dali/internal/common/message.h>
  33
  34 #include <dali/internal/event/common/notification-manager.h>
  35 #include <dali/internal/event/common/property-notification-impl.h>
  36 #include <dali/internal/event/common/property-notifier.h>
  37 #include <dali/internal/event/effects/shader-factory.h>
  38 #include <dali/internal/event/animation/animation-playlist.h>
  39
  40 #include <dali/internal/update/animation/scene-graph-animator.h>
  41 #include <dali/internal/update/animation/scene-graph-animation.h>
  42 #include <dali/internal/update/common/discard-queue.h>
  43 #include <dali/internal/update/common/scene-graph-buffers.h>
  44 #include <dali/internal/update/controllers/render-message-dispatcher.h>
  45 #include <dali/internal/update/controllers/scene-controller-impl.h>
  46 #include <dali/internal/update/gestures/scene-graph-pan-gesture.h>
  47 #include <dali/internal/update/manager/frame-callback-processor.h>
  48 #include <dali/internal/update/manager/render-task-processor.h>
  49 #include <dali/internal/update/manager/sorted-layers.h>
  50 #include <dali/internal/update/manager/scene-graph-frame-callback.h>
  51 #include <dali/internal/update/manager/update-algorithms.h>
  52 #include <dali/internal/update/manager/update-manager-debug.h>
  53 #include <dali/internal/update/manager/transform-manager.h>
  54 #include <dali/internal/update/nodes/node.h>
  55 #include <dali/internal/update/nodes/scene-graph-layer.h>
  56 #include <dali/internal/update/queue/update-message-queue.h>
  57 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
  58 #include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
  59 #include <dali/internal/update/render-tasks/scene-graph-camera.h>
  60
  61 #include <dali/internal/render/common/render-instruction-container.h>
  62 #include <dali/internal/render/common/render-manager.h>
  63 #include <dali/internal/render/queue/render-queue.h>
  64 #include <dali/internal/render/shaders/scene-graph-shader.h>
  65
  66 // Un-comment to enable node tree debug logging
  67 //#define NODE_TREE_LOGGING 1
  68
  69 #if ( defined( DEBUG_ENABLED ) && defined( NODE_TREE_LOGGING ) )
  70 #define SNAPSHOT_NODE_LOGGING \
  71 const uint32_t FRAME_COUNT_TRIGGER = 16;\
  72 if( mImpl->frameCounter >= FRAME_COUNT_TRIGGER )\
  73   {\
  74     for( auto root : mImpl->roots )
  75     {\
  76       if ( NULL != root )\
  77       {\
  78         mImpl->frameCounter = 0;\
  79         PrintNodeTree( *root, mSceneGraphBuffers.GetUpdateBufferIndex(), "" );\
  80       }\
  81     }\
  82   }\
  83 mImpl->frameCounter++;
  84 #else
  85 #define SNAPSHOT_NODE_LOGGING
  86 #endif
  87
  88 #if defined(DEBUG_ENABLED)
  89 extern Debug::Filter* gRenderTaskLogFilter;
  90 #endif
  91
  92
  93 using namespace Dali::Integration;
  94 using Dali::Internal::Update::MessageQueue;
  95
  96 namespace Dali
  97 {
  98
  99 namespace Internal
 100 {
 101
 102 namespace SceneGraph
 103 {
 104
 105 namespace
 106 {
 107 /**
 108  * Helper to Erase an object from OwnerContainer using discard queue
 109  * @param container to remove from
 110  * @param object to remove
 111  * @param discardQueue to put the object to
 112  * @param updateBufferIndex to use
 113  */
 114 template < class T >
 115 inline void EraseUsingDiscardQueue( OwnerContainer<T*>& container, T* object, DiscardQueue& discardQueue, BufferIndex updateBufferIndex )
 116 {
 117   DALI_ASSERT_DEBUG( object && "NULL object not allowed" );
 118
 119   // need to use the reference version of auto as we need the pointer to the pointer for the Release call below
 120   for( auto&& iter : container )
 121   {
 122     if ( iter == object )
 123     {
 124       // Transfer ownership to the discard queue, this keeps the object alive, until the render-thread has finished with it
 125       discardQueue.Add( updateBufferIndex, container.Release( &iter ) ); // take the address of the reference to a pointer (iter)
 126       return; // return as we only ever remove one object. Iterators to container are now invalidated as well so cannot continue
 127     }
 128   }
 129 }
 130
 131 /**
 132  * Descends into node's hierarchy and sorts the children of each child according to their depth-index.
 133  * @param[in] node The node whose hierarchy to descend
 134  */
 135 void SortSiblingNodesRecursively( Node& node )
 136 {
 137   NodeContainer& container = node.GetChildren();
 138   std::sort( container.Begin(), container.End(),
 139              []( Node* a, Node* b ) { return a->GetDepthIndex() < b->GetDepthIndex(); } );
 140
 141   // Descend tree and sort as well
 142   for( auto&& iter : container )
 143   {
 144     SortSiblingNodesRecursively( *iter );
 145   }
 146 }
 147
 148 } // unnamed namespace
 149
 150 /**
 151  * Structure to contain UpdateManager internal data
 152  */
 153 struct UpdateManager::Impl
 154 {
 155   Impl( NotificationManager& notificationManager,
 156         CompleteNotificationInterface& animationPlaylist,
 157         PropertyNotifier& propertyNotifier,
 158         DiscardQueue& discardQueue,
 159         RenderController& renderController,
 160         RenderManager& renderManager,
 161         RenderQueue& renderQueue,
 162         SceneGraphBuffers& sceneGraphBuffers,
 163         RenderTaskProcessor& renderTaskProcessor )
 164   : renderMessageDispatcher( renderManager, renderQueue, sceneGraphBuffers ),
 165     notificationManager( notificationManager ),
 166     transformManager(),
 167     animationPlaylist( animationPlaylist ),
 168     propertyNotifier( propertyNotifier ),
 169     shaderSaver( NULL ),
 170     discardQueue( discardQueue ),
 171     renderController( renderController ),
 172     sceneController( NULL ),
 173     renderManager( renderManager ),
 174     renderQueue( renderQueue ),
 175     renderInstructions( renderManager.GetRenderInstructionContainer() ),
 176     renderTaskProcessor( renderTaskProcessor ),
 177     backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
 178     renderers(),
 179     textureSets(),
 180     shaders(),
 181     panGestureProcessor( NULL ),
 182     messageQueue( renderController, sceneGraphBuffers ),
 183     frameCallbackProcessor( NULL ),
 184     keepRenderingSeconds( 0.0f ),
 185     nodeDirtyFlags( NodePropertyFlags::TRANSFORM ), // set to TransformFlag to ensure full update the first time through Update()
 186     frameCounter( 0 ),
 187     renderingBehavior( DevelStage::Rendering::IF_REQUIRED ),
 188     animationFinishedDuringUpdate( false ),
 189     previousUpdateScene( false ),
 190     renderTaskWaiting( false ),
 191     renderersAdded( false ),
 192     surfaceRectChanged( false )
 193   {
 194     sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue );
 195
 196     // create first 'dummy' node
 197     nodes.PushBack(0u);
 198   }
 199
 200   ~Impl()
 201   {
 202     // Disconnect render tasks from nodes, before destroying the nodes
 203     for( auto taskList : taskLists )
 204     {
 205       RenderTaskList::RenderTaskContainer& tasks = taskList->GetTasks();
 206       for ( auto&& task : tasks )
 207       {
 208         task->SetSourceNode( NULL );
 209       }
 210     }
 211
 212     // UpdateManager owns the Nodes. Although Nodes are pool allocated they contain heap allocated parts
 213     // like custom properties, which get released here
 214     Vector<Node*>::Iterator iter = nodes.Begin()+1;
 215     Vector<Node*>::Iterator endIter = nodes.End();
 216     for(;iter!=endIter;++iter)
 217     {
 218       (*iter)->OnDestroy();
 219       Node::Delete(*iter);
 220     }
 221
 222     for( auto root : roots )
 223     {
 224       root->OnDestroy();
 225       Node::Delete(root);
 226     }
 227
 228     delete sceneController;
 229   }
 230
 231   /**
 232    * Lazy init for FrameCallbackProcessor.
 233    * @param[in]  updateManager  A reference to the update-manager
 234    */
 235   FrameCallbackProcessor& GetFrameCallbackProcessor( UpdateManager& updateManager )
 236   {
 237     if( ! frameCallbackProcessor )
 238     {
 239       frameCallbackProcessor = new FrameCallbackProcessor( updateManager, transformManager );
 240     }
 241     return *frameCallbackProcessor;
 242   }
 243
 244   SceneGraphBuffers                    sceneGraphBuffers;             ///< Used to keep track of which buffers are being written or read
 245   RenderMessageDispatcher              renderMessageDispatcher;       ///< Used for passing messages to the render-thread
 246   NotificationManager&                 notificationManager;           ///< Queues notification messages for the event-thread.
 247   TransformManager                     transformManager;              ///< Used to update the transformation matrices of the nodes
 248   CompleteNotificationInterface&       animationPlaylist;             ///< Holds handles to all the animations
 249   PropertyNotifier&                    propertyNotifier;              ///< Provides notification to applications when properties are modified.
 250   ShaderSaver*                         shaderSaver;                   ///< Saves shader binaries.
 251   DiscardQueue&                        discardQueue;                  ///< Nodes are added here when disconnected from the scene-graph.
 252   RenderController&                    renderController;              ///< render controller
 253   SceneControllerImpl*                 sceneController;               ///< scene controller
 254   RenderManager&                       renderManager;                 ///< This is responsible for rendering the results of each "update"
 255   RenderQueue&                         renderQueue;                   ///< Used to queue messages for the next render
 256   RenderInstructionContainer&          renderInstructions;            ///< Used to prepare the render instructions
 257   RenderTaskProcessor&                 renderTaskProcessor;           ///< Handles RenderTasks and RenderInstrucitons
 258
 259   Vector4                              backgroundColor;               ///< The glClear color used at the beginning of each frame.
 260
 261   OwnerContainer<RenderTaskList*>      taskLists;                     ///< A container of scene graph render task lists
 262
 263   Vector<Layer*>                       roots;                         ///< A container of root nodes (root is a layer). The layers are not stored in the node memory pool.
 264
 265   Vector<Node*>                        nodes;                         ///< A container of all instantiated nodes
 266
 267   std::vector<SortedLayerPointers>     sortedLayerLists;              ///< A container of lists of Layer pointers sorted by depth (one list of sorted layers per root)
 268
 269   OwnerContainer< Camera* >            cameras;                       ///< A container of cameras
 270   OwnerContainer< PropertyOwner* >     customObjects;                 ///< A container of owned objects (with custom properties)
 271
 272   OwnerContainer< PropertyResetterBase* > propertyResetters;          ///< A container of property resetters
 273   OwnerContainer< Animation* >         animations;                    ///< A container of owned animations
 274   PropertyNotificationContainer        propertyNotifications;         ///< A container of owner property notifications.
 275   OwnerContainer< Renderer* >          renderers;                     ///< A container of owned renderers
 276   OwnerContainer< TextureSet* >        textureSets;                   ///< A container of owned texture sets
 277   OwnerContainer< Shader* >            shaders;                       ///< A container of owned shaders
 278   OwnerPointer< PanGesture >           panGestureProcessor;           ///< Owned pan gesture processor; it lives for the lifecycle of UpdateManager
 279
 280   MessageQueue                         messageQueue;                  ///< The messages queued from the event-thread
 281   std::vector<Internal::ShaderDataPtr> renderCompiledShaders;         ///< Shaders compiled on Render thread are inserted here for update thread to pass on to event thread.
 282   std::vector<Internal::ShaderDataPtr> updateCompiledShaders;         ///< Shaders to be sent from Update to Event
 283   Mutex                                compiledShaderMutex;           ///< lock to ensure no corruption on the renderCompiledShaders
 284
 285   OwnerPointer<FrameCallbackProcessor> frameCallbackProcessor;        ///< Owned FrameCallbackProcessor, only created if required.
 286
 287   float                                keepRenderingSeconds;          ///< Set via Dali::Stage::KeepRendering
 288   NodePropertyFlags                    nodeDirtyFlags;                ///< cumulative node dirty flags from previous frame
 289   uint32_t                             frameCounter;                  ///< Frame counter used in debugging to choose which frame to debug and which to ignore.
 290
 291   DevelStage::Rendering                renderingBehavior;             ///< Set via DevelStage::SetRenderingBehavior
 292
 293   bool                                 animationFinishedDuringUpdate; ///< Flag whether any animations finished during the Update()
 294   bool                                 previousUpdateScene;           ///< True if the scene was updated in the previous frame (otherwise it was optimized out)
 295   bool                                 renderTaskWaiting;             ///< A REFRESH_ONCE render task is waiting to be rendered
 296   bool                                 renderersAdded;                ///< Flag to keep track when renderers have been added to avoid unnecessary processing
 297   bool                                 surfaceRectChanged;            ///< True if the default surface rect is changed
 298
 299 private:
 300
 301   Impl( const Impl& ); ///< Undefined
 302   Impl& operator=( const Impl& ); ///< Undefined
 303 };
 304
 305 UpdateManager::UpdateManager( NotificationManager& notificationManager,
 306                               CompleteNotificationInterface& animationFinishedNotifier,
 307                               PropertyNotifier& propertyNotifier,
 308                               DiscardQueue& discardQueue,
 309                               RenderController& controller,
 310                               RenderManager& renderManager,
 311                               RenderQueue& renderQueue,
 312                               RenderTaskProcessor& renderTaskProcessor )
 313   : mImpl(NULL)
 314 {
 315   mImpl = new Impl( notificationManager,
 316                     animationFinishedNotifier,
 317                     propertyNotifier,
 318                     discardQueue,
 319                     controller,
 320                     renderManager,
 321                     renderQueue,
 322                     mSceneGraphBuffers,
 323                     renderTaskProcessor );
 324
 325 }
 326
 327 UpdateManager::~UpdateManager()
 328 {
 329   delete mImpl;
 330 }
 331
 332 void UpdateManager::InstallRoot( OwnerPointer<Layer>& layer )
 333 {
 334   DALI_ASSERT_DEBUG( layer->IsLayer() );
 335   DALI_ASSERT_DEBUG( layer->GetParent() == NULL);
 336
 337   Layer* rootLayer = layer.Release();
 338
 339   DALI_ASSERT_DEBUG( std::find( mImpl->roots.begin(), mImpl->roots.end(), rootLayer ) == mImpl->roots.end() && "Root Node already installed" );
 340
 341   rootLayer->CreateTransform( &mImpl->transformManager );
 342   rootLayer->SetRoot(true);
 343   mImpl->roots.PushBack( rootLayer );
 344 }
 345
 346 void UpdateManager::UninstallRoot( Layer* layer )
 347 {
 348   DALI_ASSERT_DEBUG( layer->IsLayer() );
 349   DALI_ASSERT_DEBUG( layer->GetParent() == NULL );
 350
 351   for ( auto&& iter : mImpl->roots )
 352   {
 353     if( ( *iter ) == layer )
 354     {
 355       mImpl->roots.Erase( &iter );
 356       break;
 357     }
 358   }
 359
 360   mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), layer );
 361
 362   // Notify the layer about impending destruction
 363   layer->OnDestroy();
 364 }
 365
 366 void UpdateManager::AddNode( OwnerPointer<Node>& node )
 367 {
 368   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
 369
 370   // Nodes must be sorted by pointer
 371   Node* rawNode = node.Release();
 372   Vector<Node*>::Iterator begin = mImpl->nodes.Begin();
 373   for( Vector<Node*>::Iterator iter = mImpl->nodes.End()-1; iter >= begin; --iter )
 374   {
 375     if( rawNode > (*iter) )
 376     {
 377       mImpl->nodes.Insert((iter+1), rawNode );
 378       rawNode->CreateTransform( &mImpl->transformManager );
 379       return;
 380     }
 381   }
 382 }
 383
 384 void UpdateManager::ConnectNode( Node* parent, Node* node )
 385 {
 386   DALI_ASSERT_ALWAYS( NULL != parent );
 387   DALI_ASSERT_ALWAYS( NULL != node );
 388   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
 389
 390   parent->ConnectChild( node );
 391
 392   // Inform the frame-callback-processor, if set, about the node-hierarchy changing
 393   if( mImpl->frameCallbackProcessor )
 394   {
 395     mImpl->frameCallbackProcessor->NodeHierarchyChanged();
 396   }
 397 }
 398
 399 void UpdateManager::DisconnectNode( Node* node )
 400 {
 401   Node* parent = node->GetParent();
 402   DALI_ASSERT_ALWAYS( NULL != parent );
 403   parent->SetDirtyFlag( NodePropertyFlags::CHILD_DELETED ); // make parent dirty so that render items dont get reused
 404
 405   parent->DisconnectChild( mSceneGraphBuffers.GetUpdateBufferIndex(), *node );
 406
 407   // Inform the frame-callback-processor, if set, about the node-hierarchy changing
 408   if( mImpl->frameCallbackProcessor )
 409   {
 410     mImpl->frameCallbackProcessor->NodeHierarchyChanged();
 411   }
 412 }
 413
 414 void UpdateManager::DestroyNode( Node* node )
 415 {
 416   DALI_ASSERT_ALWAYS( NULL != node );
 417   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should have been disconnected
 418
 419   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
 420   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
 421   for(;iter!=endIter;++iter)
 422   {
 423     if((*iter) == node)
 424     {
 425       mImpl->nodes.Erase(iter);
 426       break;
 427     }
 428   }
 429
 430   mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), node );
 431
 432   // Notify the Node about impending destruction
 433   node->OnDestroy();
 434 }
 435
 436 void UpdateManager::AddCamera( OwnerPointer< Camera >& camera )
 437 {
 438   mImpl->cameras.PushBack( camera.Release() ); // takes ownership
 439 }
 440
 441 void UpdateManager::RemoveCamera( Camera* camera )
 442 {
 443   // Find the camera and destroy it
 444   EraseUsingDiscardQueue( mImpl->cameras, camera, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
 445 }
 446
 447 void UpdateManager::AddObject( OwnerPointer<PropertyOwner>& object )
 448 {
 449   mImpl->customObjects.PushBack( object.Release() );
 450 }
 451
 452 void UpdateManager::RemoveObject( PropertyOwner* object )
 453 {
 454   mImpl->customObjects.EraseObject( object );
 455 }
 456
 457 void UpdateManager::AddRenderTaskList( OwnerPointer<RenderTaskList>& taskList )
 458 {
 459   RenderTaskList* taskListPointer = taskList.Release();
 460   taskListPointer->SetRenderMessageDispatcher( &mImpl->renderMessageDispatcher );
 461   mImpl->taskLists.PushBack( taskListPointer );
 462 }
 463
 464 void UpdateManager::RemoveRenderTaskList( RenderTaskList* taskList )
 465 {
 466   mImpl->taskLists.EraseObject( taskList );
 467 }
 468
 469 void UpdateManager::AddAnimation( OwnerPointer< SceneGraph::Animation >& animation )
 470 {
 471   mImpl->animations.PushBack( animation.Release() );
 472 }
 473
 474 void UpdateManager::StopAnimation( Animation* animation )
 475 {
 476   DALI_ASSERT_DEBUG( animation && "NULL animation called to stop" );
 477
 478   bool animationFinished = animation->Stop( mSceneGraphBuffers.GetUpdateBufferIndex() );
 479
 480   mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || animationFinished;
 481 }
 482
 483 void UpdateManager::RemoveAnimation( Animation* animation )
 484 {
 485   DALI_ASSERT_DEBUG( animation && "NULL animation called to remove" );
 486
 487   animation->OnDestroy( mSceneGraphBuffers.GetUpdateBufferIndex() );
 488
 489   DALI_ASSERT_DEBUG( animation->GetState() == Animation::Destroyed );
 490 }
 491
 492 bool UpdateManager::IsAnimationRunning() const
 493 {
 494   // Find any animation that isn't stopped or paused
 495   for ( auto&& iter : mImpl->animations )
 496   {
 497     const Animation::State state = iter->GetState();
 498
 499     if (state != Animation::Stopped &&
 500         state != Animation::Paused)
 501     {
 502       return true; // stop iteration as soon as first one is found
 503     }
 504   }
 505
 506   return false;
 507 }
 508
 509 void UpdateManager::AddPropertyResetter( OwnerPointer<PropertyResetterBase>& propertyResetter )
 510 {
 511   propertyResetter->Initialize();
 512   mImpl->propertyResetters.PushBack( propertyResetter.Release() );
 513 }
 514
 515 void UpdateManager::AddPropertyNotification( OwnerPointer< PropertyNotification >& propertyNotification )
 516 {
 517   mImpl->propertyNotifications.PushBack( propertyNotification.Release() );
 518 }
 519
 520 void UpdateManager::RemovePropertyNotification( PropertyNotification* propertyNotification )
 521 {
 522   mImpl->propertyNotifications.EraseObject( propertyNotification );
 523 }
 524
 525 void UpdateManager::PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode )
 526 {
 527   DALI_ASSERT_DEBUG( propertyNotification && "propertyNotification scene graph object missing" );
 528   propertyNotification->SetNotifyMode( notifyMode );
 529 }
 530
 531 void UpdateManager::AddShader( OwnerPointer< Shader >& shader )
 532 {
 533   mImpl->shaders.PushBack( shader.Release() );
 534 }
 535
 536 void UpdateManager::RemoveShader( Shader* shader )
 537 {
 538   // Find the shader and destroy it
 539   EraseUsingDiscardQueue( mImpl->shaders, shader, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
 540 }
 541
 542 void UpdateManager::SetShaderProgram( Shader* shader,
 543                                       Internal::ShaderDataPtr shaderData, bool modifiesGeometry )
 544 {
 545   if( shaderData )
 546   {
 547
 548     typedef MessageValue3< Shader, Internal::ShaderDataPtr, ProgramCache*, bool> DerivedType;
 549
 550     // Reserve some memory inside the render queue
 551     uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 552
 553     // Construct message in the render queue memory; note that delete should not be called on the return value
 554     new (slot) DerivedType( shader, &Shader::SetProgram, shaderData, mImpl->renderManager.GetProgramCache(), modifiesGeometry );
 555   }
 556 }
 557
 558 void UpdateManager::SaveBinary( Internal::ShaderDataPtr shaderData )
 559 {
 560   DALI_ASSERT_DEBUG( shaderData && "No NULL shader data pointers please." );
 561   DALI_ASSERT_DEBUG( shaderData->GetBufferSize() > 0 && "Shader binary empty so nothing to save." );
 562   {
 563     // lock as update might be sending previously compiled shaders to event thread
 564     Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
 565     mImpl->renderCompiledShaders.push_back( shaderData );
 566   }
 567 }
 568
 569 void UpdateManager::SetShaderSaver( ShaderSaver& upstream )
 570 {
 571   mImpl->shaderSaver = &upstream;
 572 }
 573
 574 void UpdateManager::AddRenderer( OwnerPointer< Renderer >& renderer )
 575 {
 576   renderer->ConnectToSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() );
 577   mImpl->renderers.PushBack( renderer.Release() );
 578   mImpl->renderersAdded = true;
 579 }
 580
 581 void UpdateManager::RemoveRenderer( Renderer* renderer )
 582 {
 583   // Find the renderer and destroy it
 584   EraseUsingDiscardQueue( mImpl->renderers, renderer, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
 585   // Need to remove the render object as well
 586   renderer->DisconnectFromSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() );
 587 }
 588
 589 void UpdateManager::SetPanGestureProcessor( PanGesture* panGestureProcessor )
 590 {
 591   DALI_ASSERT_DEBUG( NULL != panGestureProcessor );
 592
 593   mImpl->panGestureProcessor = panGestureProcessor;
 594 }
 595
 596 void UpdateManager::AddTextureSet( OwnerPointer< TextureSet >& textureSet )
 597 {
 598   mImpl->textureSets.PushBack( textureSet.Release() );
 599 }
 600
 601 void UpdateManager::RemoveTextureSet( TextureSet* textureSet )
 602 {
 603   mImpl->textureSets.EraseObject( textureSet );
 604 }
 605
 606 uint32_t* UpdateManager::ReserveMessageSlot( uint32_t size, bool updateScene )
 607 {
 608   return mImpl->messageQueue.ReserveMessageSlot( size, updateScene );
 609 }
 610
 611 void UpdateManager::EventProcessingStarted()
 612 {
 613   mImpl->messageQueue.EventProcessingStarted();
 614 }
 615
 616 bool UpdateManager::FlushQueue()
 617 {
 618   return mImpl->messageQueue.FlushQueue();
 619 }
 620
 621 void UpdateManager::ResetProperties( BufferIndex bufferIndex )
 622 {
 623   // Clear the "animations finished" flag; This should be set if any (previously playing) animation is stopped
 624   mImpl->animationFinishedDuringUpdate = false;
 625
 626   // Reset all animating / constrained properties
 627   std::vector<PropertyResetterBase*>toDelete;
 628   for( auto&& element : mImpl->propertyResetters )
 629   {
 630     element->ResetToBaseValue( bufferIndex );
 631     if( element->IsFinished() )
 632     {
 633       toDelete.push_back( element );
 634     }
 635   }
 636
 637   // If a resetter is no longer required (the animator or constraint has been removed), delete it.
 638   for( auto&& elementPtr : toDelete )
 639   {
 640     mImpl->propertyResetters.EraseObject( elementPtr );
 641   }
 642
 643   // Clear node dirty flags
 644   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
 645   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
 646   for( ;iter != endIter; ++iter )
 647   {
 648     (*iter)->ResetDirtyFlags( bufferIndex );
 649   }
 650 }
 651
 652 bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, uint32_t lastVSyncTimeMilliseconds, uint32_t nextVSyncTimeMilliseconds )
 653 {
 654   bool gestureUpdated( false );
 655
 656   if( mImpl->panGestureProcessor )
 657   {
 658     // gesture processor only supports default properties
 659     mImpl->panGestureProcessor->ResetDefaultProperties( bufferIndex ); // Needs to be done every time as gesture data is written directly to an update-buffer rather than via a message
 660     gestureUpdated |= mImpl->panGestureProcessor->UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 661   }
 662
 663   return gestureUpdated;
 664 }
 665
 666 void UpdateManager::Animate( BufferIndex bufferIndex, float elapsedSeconds )
 667 {
 668   auto&& iter = mImpl->animations.Begin();
 669   bool animationLooped = false;
 670
 671   while ( iter != mImpl->animations.End() )
 672   {
 673     Animation* animation = *iter;
 674     bool finished = false;
 675     bool looped = false;
 676     bool progressMarkerReached = false;
 677     animation->Update( bufferIndex, elapsedSeconds, looped, finished, progressMarkerReached );
 678
 679     if ( progressMarkerReached )
 680     {
 681       mImpl->notificationManager.QueueMessage( Internal::NotifyProgressReachedMessage( mImpl->animationPlaylist, animation ) );
 682     }
 683
 684     mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || finished;
 685     animationLooped = animationLooped || looped;
 686
 687     // Remove animations that had been destroyed but were still waiting for an update
 688     if (animation->GetState() == Animation::Destroyed)
 689     {
 690       iter = mImpl->animations.Erase(iter);
 691     }
 692     else
 693     {
 694       ++iter;
 695     }
 696   }
 697
 698   // queue the notification on finished or looped (to update loop count)
 699   if ( mImpl->animationFinishedDuringUpdate || animationLooped )
 700   {
 701     // The application should be notified by NotificationManager, in another thread
 702     mImpl->notificationManager.QueueCompleteNotification( &mImpl->animationPlaylist );
 703   }
 704 }
 705
 706 void UpdateManager::ConstrainCustomObjects( BufferIndex bufferIndex )
 707 {
 708   //Constrain custom objects (in construction order)
 709   for ( auto&& object : mImpl->customObjects )
 710   {
 711     ConstrainPropertyOwner( *object, bufferIndex );
 712   }
 713 }
 714
 715 void UpdateManager::ConstrainRenderTasks( BufferIndex bufferIndex )
 716 {
 717   // Constrain render-tasks
 718   for( auto taskList : mImpl->taskLists )
 719   {
 720     RenderTaskList::RenderTaskContainer& tasks = taskList->GetTasks();
 721     for ( auto&& task : tasks )
 722     {
 723       ConstrainPropertyOwner( *task, bufferIndex );
 724     }
 725   }
 726 }
 727
 728 void UpdateManager::ConstrainShaders( BufferIndex bufferIndex )
 729 {
 730   // constrain shaders... (in construction order)
 731   for ( auto&& shader : mImpl->shaders )
 732   {
 733     ConstrainPropertyOwner( *shader, bufferIndex );
 734   }
 735 }
 736
 737 void UpdateManager::ProcessPropertyNotifications( BufferIndex bufferIndex )
 738 {
 739   for( auto&& notification : mImpl->propertyNotifications )
 740   {
 741     bool valid = notification->Check( bufferIndex );
 742     if(valid)
 743     {
 744       mImpl->notificationManager.QueueMessage( PropertyChangedMessage( mImpl->propertyNotifier, notification, notification->GetValidity() ) );
 745     }
 746   }
 747 }
 748
 749 void UpdateManager::ForwardCompiledShadersToEventThread()
 750 {
 751   DALI_ASSERT_DEBUG( (mImpl->shaderSaver != 0) && "shaderSaver should be wired-up during startup." );
 752   if( mImpl->shaderSaver )
 753   {
 754     // lock and swap the queues
 755     {
 756       // render might be attempting to send us more binaries at the same time
 757       Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
 758       mImpl->renderCompiledShaders.swap( mImpl->updateCompiledShaders );
 759     }
 760
 761     if( mImpl->updateCompiledShaders.size() > 0 )
 762     {
 763       ShaderSaver& factory = *mImpl->shaderSaver;
 764       for( auto&& shader : mImpl->updateCompiledShaders )
 765       {
 766         mImpl->notificationManager.QueueMessage( ShaderCompiledMessage( factory, shader ) );
 767       }
 768       // we don't need them in update anymore
 769       mImpl->updateCompiledShaders.clear();
 770     }
 771   }
 772 }
 773
 774 void UpdateManager::UpdateRenderers( BufferIndex bufferIndex )
 775 {
 776   for( auto&& renderer : mImpl->renderers )
 777   {
 778     //Apply constraints
 779     ConstrainPropertyOwner( *renderer, bufferIndex );
 780
 781     renderer->PrepareRender( bufferIndex );
 782   }
 783 }
 784
 785 void UpdateManager::UpdateNodes( BufferIndex bufferIndex )
 786 {
 787   mImpl->nodeDirtyFlags = NodePropertyFlags::NOTHING;
 788
 789   for( auto&& rootLayer : mImpl->roots )
 790   {
 791     // Prepare resources, update shaders, for each node
 792     // And add the renderers to the sorted layers. Start from root, which is also a layer
 793     mImpl->nodeDirtyFlags |= UpdateNodeTree( *rootLayer,
 794                                             bufferIndex,
 795                                             mImpl->renderQueue );
 796   }
 797 }
 798
 799 uint32_t UpdateManager::Update( float elapsedSeconds,
 800                                 uint32_t lastVSyncTimeMilliseconds,
 801                                 uint32_t nextVSyncTimeMilliseconds,
 802                                 bool renderToFboEnabled,
 803                                 bool isRenderingToFbo )
 804 {
 805   const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
 806
 807   //Clear nodes/resources which were previously discarded
 808   mImpl->discardQueue.Clear( bufferIndex );
 809
 810   //Process Touches & Gestures
 811   const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 812
 813   bool updateScene = // The scene-graph requires an update if..
 814       (mImpl->nodeDirtyFlags & RenderableUpdateFlags) ||    // ..nodes were dirty in previous frame OR
 815       IsAnimationRunning()                            ||    // ..at least one animation is running OR
 816       mImpl->messageQueue.IsSceneUpdateRequired()     ||    // ..a message that modifies the scene graph node tree is queued OR
 817       gestureUpdated;                                       // ..a gesture property was updated
 818
 819   bool keepRendererRendering = false;
 820
 821   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 822   // values if the scene was updated in the previous frame.
 823   if( updateScene || mImpl->previousUpdateScene )
 824   {
 825     //Reset properties from the previous update
 826     ResetProperties( bufferIndex );
 827     mImpl->transformManager.ResetToBaseValue();
 828   }
 829
 830   // Process the queued scene messages. Note, MessageQueue::FlushQueue may be called
 831   // between calling IsSceneUpdateRequired() above and here, so updateScene should
 832   // be set again
 833   updateScene |= mImpl->messageQueue.ProcessMessages( bufferIndex );
 834
 835   //Forward compiled shader programs to event thread for saving
 836   ForwardCompiledShadersToEventThread();
 837
 838   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 839   // renderer lists if the scene was updated in the previous frame.
 840   // We should not start skipping update steps or reusing lists until there has been two frames where nothing changes
 841   if( updateScene || mImpl->previousUpdateScene )
 842   {
 843     //Animate
 844     Animate( bufferIndex, elapsedSeconds );
 845
 846     //Constraint custom objects
 847     ConstrainCustomObjects( bufferIndex );
 848
 849     //Clear the lists of renderers from the previous update
 850     for( auto sortedLayers : mImpl->sortedLayerLists )
 851     {
 852       for( auto&& layer : sortedLayers )
 853       {
 854         layer->ClearRenderables();
 855       }
 856     }
 857
 858     // Call the frame-callback-processor if set
 859     if( mImpl->frameCallbackProcessor )
 860     {
 861       mImpl->frameCallbackProcessor->Update( bufferIndex, elapsedSeconds );
 862     }
 863
 864     //Update node hierarchy, apply constraints and perform sorting / culling.
 865     //This will populate each Layer with a list of renderers which are ready.
 866     UpdateNodes( bufferIndex );
 867
 868     //Apply constraints to RenderTasks, shaders
 869     ConstrainRenderTasks( bufferIndex );
 870     ConstrainShaders( bufferIndex );
 871
 872     //Update renderers and apply constraints
 873     UpdateRenderers( bufferIndex );
 874
 875     //Update the transformations of all the nodes
 876     mImpl->transformManager.Update();
 877
 878     //Process Property Notifications
 879     ProcessPropertyNotifications( bufferIndex );
 880
 881     //Update cameras
 882     for( auto&& cameraIterator : mImpl->cameras )
 883     {
 884       cameraIterator->Update( bufferIndex );
 885     }
 886
 887     //Process the RenderTasks if renderers exist. This creates the instructions for rendering the next frame.
 888     //reset the update buffer index and make sure there is enough room in the instruction container
 889     if( mImpl->renderersAdded )
 890     {
 891       // Calculate how many render tasks we have in total
 892       VectorBase::SizeType numberOfRenderTasks = 0;
 893
 894       const VectorBase::SizeType taskListCount = mImpl->taskLists.Count();
 895       for ( VectorBase::SizeType index = 0u; index < taskListCount; index++ )
 896       {
 897         numberOfRenderTasks += mImpl->taskLists[index]->GetTasks().Count();
 898       }
 899
 900       mImpl->renderInstructions.ResetAndReserve( bufferIndex,
 901                                                  static_cast<uint32_t>( numberOfRenderTasks ) );
 902
 903       for ( VectorBase::SizeType index = 0u; index < taskListCount; index++ )
 904       {
 905         if ( NULL != mImpl->roots[index] )
 906         {
 907           keepRendererRendering |= mImpl->renderTaskProcessor.Process( bufferIndex,
 908                                               *mImpl->taskLists[index],
 909                                               *mImpl->roots[index],
 910                                               mImpl->sortedLayerLists[index],
 911                                               mImpl->renderInstructions,
 912                                               renderToFboEnabled,
 913                                               isRenderingToFbo );
 914         }
 915       }
 916     }
 917   }
 918
 919   for( auto taskList : mImpl->taskLists )
 920   {
 921     RenderTaskList::RenderTaskContainer& tasks = taskList->GetTasks();
 922
 923     // check the countdown and notify
 924     bool doRenderOnceNotify = false;
 925     mImpl->renderTaskWaiting = false;
 926     for ( auto&& renderTask : tasks )
 927     {
 928       renderTask->UpdateState();
 929
 930       if( renderTask->IsWaitingToRender() &&
 931           renderTask->ReadyToRender( bufferIndex ) /*avoid updating forever when source actor is off-stage*/ )
 932       {
 933         mImpl->renderTaskWaiting = true; // keep update/render threads alive
 934       }
 935
 936       if( renderTask->HasRendered() )
 937       {
 938         doRenderOnceNotify = true;
 939       }
 940     }
 941
 942     if( doRenderOnceNotify )
 943     {
 944       DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n");
 945       mImpl->notificationManager.QueueCompleteNotification( taskList->GetCompleteNotificationInterface() );
 946     }
 947   }
 948
 949   // Macro is undefined in release build.
 950   SNAPSHOT_NODE_LOGGING;
 951
 952   // A ResetProperties() may be required in the next frame
 953   mImpl->previousUpdateScene = updateScene;
 954
 955   // Check whether further updates are required
 956   uint32_t keepUpdating = KeepUpdatingCheck( elapsedSeconds );
 957
 958   if( keepRendererRendering )
 959   {
 960     keepUpdating |= KeepUpdating::STAGE_KEEP_RENDERING;
 961   }
 962
 963   // tell the update manager that we're done so the queue can be given to event thread
 964   mImpl->notificationManager.UpdateCompleted();
 965
 966   // The update has finished; swap the double-buffering indices
 967   mSceneGraphBuffers.Swap();
 968
 969   return keepUpdating;
 970 }
 971
 972 uint32_t UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const
 973 {
 974   // Update the duration set via Stage::KeepRendering()
 975   if ( mImpl->keepRenderingSeconds > 0.0f )
 976   {
 977     mImpl->keepRenderingSeconds -= elapsedSeconds;
 978   }
 979
 980   uint32_t keepUpdatingRequest = KeepUpdating::NOT_REQUESTED;
 981
 982   // If the rendering behavior is set to continuously render, then continue to render.
 983   // If Stage::KeepRendering() has been called, then continue until the duration has elapsed.
 984   // Keep updating until no messages are received and no animations are running.
 985   // If an animation has just finished, update at least once more for Discard end-actions.
 986   // No need to check for renderQueue as there is always a render after update and if that
 987   // render needs another update it will tell the adaptor to call update again
 988
 989   if ( ( mImpl->renderingBehavior == DevelStage::Rendering::CONTINUOUSLY ) ||
 990        ( mImpl->keepRenderingSeconds > 0.0f ) )
 991   {
 992     keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING;
 993   }
 994
 995   if ( IsAnimationRunning() ||
 996        mImpl->animationFinishedDuringUpdate )
 997   {
 998     keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING;
 999   }
1000
1001   if ( mImpl->renderTaskWaiting )
1002   {
1003     keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC;
1004   }
1005
1006   return keepUpdatingRequest;
1007 }
1008
1009 void UpdateManager::SetBackgroundColor( const Vector4& color )
1010 {
1011   typedef MessageValue1< RenderManager, Vector4 > DerivedType;
1012
1013   // Reserve some memory inside the render queue
1014   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1015
1016   // Construct message in the render queue memory; note that delete should not be called on the return value
1017   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetBackgroundColor, color );
1018 }
1019
1020 void UpdateManager::SetDefaultSurfaceRect( const Rect<int32_t>& rect )
1021 {
1022   mImpl->surfaceRectChanged = true;
1023
1024   typedef MessageValue1< RenderManager, Rect<int32_t> > DerivedType;
1025
1026   // Reserve some memory inside the render queue
1027   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1028
1029   // Construct message in the render queue memory; note that delete should not be called on the return value
1030   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceRect, rect );
1031 }
1032
1033 void UpdateManager::KeepRendering( float durationSeconds )
1034 {
1035   mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds );
1036 }
1037
1038 void UpdateManager::SetRenderingBehavior( DevelStage::Rendering renderingBehavior )
1039 {
1040   mImpl->renderingBehavior = renderingBehavior;
1041 }
1042
1043 void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, const Layer* rootLayer )
1044 {
1045   const VectorBase::SizeType rootCount = mImpl->roots.Count();
1046
1047   // Make sure we reserve the correct size for the container so that
1048   // we can save the sorted layers in the same order as the root layer
1049   mImpl->sortedLayerLists.resize( rootCount );
1050
1051   for ( VectorBase::SizeType rootIndex = 0u; rootIndex < rootCount; rootIndex++ )
1052   {
1053     Layer* root = mImpl->roots[rootIndex];
1054     if ( root == rootLayer )
1055     {
1056       mImpl->sortedLayerLists[rootIndex] = layers;
1057       break;
1058     }
1059   }
1060 }
1061
1062 void UpdateManager::SetDepthIndices( OwnerPointer< NodeDepths >& nodeDepths )
1063 {
1064   // note,this vector is already in depth order. It could be used as-is to
1065   // remove sorting in update algorithm. However, it lacks layer boundary markers.
1066   for( auto&& iter : nodeDepths->nodeDepths )
1067   {
1068     iter.node->SetDepthIndex( iter.sortedDepth );
1069   }
1070
1071   for( auto root : mImpl->roots )
1072   {
1073     // Go through node hierarchy and rearrange siblings according to depth-index
1074     SortSiblingNodesRecursively( *root );
1075   }
1076 }
1077
1078 bool UpdateManager::IsDefaultSurfaceRectChanged()
1079 {
1080   bool surfaceRectChanged = mImpl->surfaceRectChanged;
1081
1082   // Reset the flag
1083   mImpl->surfaceRectChanged = false;
1084
1085   return surfaceRectChanged;
1086 }
1087
1088 void UpdateManager::AddFrameCallback( OwnerPointer< FrameCallback >& frameCallback, const Node* rootNode )
1089 {
1090   mImpl->GetFrameCallbackProcessor( *this ).AddFrameCallback( frameCallback, rootNode );
1091 }
1092
1093 void UpdateManager::RemoveFrameCallback( FrameCallbackInterface* frameCallback )
1094 {
1095   mImpl->GetFrameCallbackProcessor( *this ).RemoveFrameCallback( frameCallback );
1096 }
1097
1098 void UpdateManager::AddSampler( OwnerPointer< Render::Sampler >& sampler )
1099 {
1100   // Message has ownership of Sampler while in transit from update to render
1101   typedef MessageValue1< RenderManager, OwnerPointer< Render::Sampler > > DerivedType;
1102
1103   // Reserve some memory inside the render queue
1104   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1105
1106   // Construct message in the render queue memory; note that delete should not be called on the return value
1107   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddSampler, sampler );
1108 }
1109
1110 void UpdateManager::RemoveSampler( Render::Sampler* sampler )
1111 {
1112   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1113
1114   // Reserve some memory inside the render queue
1115   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1116
1117   // Construct message in the render queue memory; note that delete should not be called on the return value
1118   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveSampler, sampler );
1119 }
1120
1121 void UpdateManager::SetFilterMode( Render::Sampler* sampler, uint32_t minFilterMode, uint32_t magFilterMode )
1122 {
1123   typedef MessageValue3< RenderManager, Render::Sampler*, uint32_t, uint32_t > DerivedType;
1124
1125   // Reserve some memory inside the render queue
1126   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1127
1128   // Construct message in the render queue memory; note that delete should not be called on the return value
1129   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
1130 }
1131
1132 void UpdateManager::SetWrapMode( Render::Sampler* sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode )
1133 {
1134   typedef MessageValue4< RenderManager, Render::Sampler*, uint32_t, uint32_t, uint32_t > DerivedType;
1135
1136   // Reserve some memory inside the render queue
1137   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1138
1139   // Construct message in the render queue memory; note that delete should not be called on the return value
1140   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode );
1141 }
1142
1143 void UpdateManager::AddPropertyBuffer( OwnerPointer< Render::PropertyBuffer >& propertyBuffer )
1144 {
1145   // Message has ownership of format while in transit from update -> render
1146   typedef MessageValue1< RenderManager, OwnerPointer< Render::PropertyBuffer > > DerivedType;
1147
1148   // Reserve some memory inside the render queue
1149   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1150
1151   // Construct message in the render queue memory; note that delete should not be called on the return value
1152   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddPropertyBuffer, propertyBuffer );
1153 }
1154
1155 void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1156 {
1157   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1158
1159   // Reserve some memory inside the render queue
1160   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1161
1162   // Construct message in the render queue memory; note that delete should not be called on the return value
1163   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemovePropertyBuffer, propertyBuffer );
1164 }
1165
1166 void UpdateManager::SetPropertyBufferFormat( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Render::PropertyBuffer::Format>& format )
1167 {
1168   // Message has ownership of format while in transit from update -> render
1169   typedef MessageValue2< RenderManager, Render::PropertyBuffer*, OwnerPointer< Render::PropertyBuffer::Format > > DerivedType;
1170
1171   // Reserve some memory inside the render queue
1172   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1173
1174   // Construct message in the render queue memory; note that delete should not be called on the return value
1175   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetPropertyBufferFormat, propertyBuffer, format );
1176 }
1177
1178 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Vector<uint8_t> >& data, uint32_t size )
1179 {
1180   // Message has ownership of format while in transit from update -> render
1181   typedef MessageValue3< RenderManager, Render::PropertyBuffer*, OwnerPointer< Dali::Vector<uint8_t> >, uint32_t > DerivedType;
1182
1183   // Reserve some memory inside the render queue
1184   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1185
1186   // Construct message in the render queue memory; note that delete should not be called on the return value
1187   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
1188 }
1189
1190 void UpdateManager::AddGeometry( OwnerPointer< Render::Geometry >& geometry )
1191 {
1192   // Message has ownership of format while in transit from update -> render
1193   typedef MessageValue1< RenderManager, OwnerPointer< Render::Geometry > > DerivedType;
1194
1195   // Reserve some memory inside the render queue
1196   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1197
1198   // Construct message in the render queue memory; note that delete should not be called on the return value
1199   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddGeometry, geometry );
1200 }
1201
1202 void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
1203 {
1204   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1205
1206   // Reserve some memory inside the render queue
1207   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1208
1209   // Construct message in the render queue memory; note that delete should not be called on the return value
1210   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveGeometry, geometry );
1211 }
1212
1213 void UpdateManager::SetGeometryType( Render::Geometry* geometry, uint32_t geometryType )
1214 {
1215   typedef MessageValue2< RenderManager, Render::Geometry*, uint32_t > DerivedType;
1216
1217   // Reserve some memory inside the render queue
1218   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1219
1220   // Construct message in the render queue memory; note that delete should not be called on the return value
1221   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryType, geometry, geometryType );
1222 }
1223
1224 void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<uint16_t>& indices )
1225 {
1226   typedef IndexBufferMessage< RenderManager > DerivedType;
1227
1228   // Reserve some memory inside the render queue
1229   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1230
1231   // Construct message in the render queue memory; note that delete should not be called on the return value
1232   new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
1233 }
1234
1235 void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1236 {
1237   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1238
1239   // Reserve some memory inside the render queue
1240   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1241
1242   // Construct message in the render queue memory; note that delete should not be called on the return value
1243   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveVertexBuffer, geometry, propertyBuffer );
1244 }
1245
1246 void UpdateManager::AttachVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1247 {
1248   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1249
1250   // Reserve some memory inside the render queue
1251   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1252
1253   // Construct message in the render queue memory; note that delete should not be called on the return value
1254   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachVertexBuffer, geometry, propertyBuffer );
1255 }
1256
1257 void UpdateManager::AddTexture( OwnerPointer< Render::Texture >& texture )
1258 {
1259   // Message has ownership of Texture while in transit from update -> render
1260   typedef MessageValue1< RenderManager, OwnerPointer< Render::Texture > > DerivedType;
1261
1262   // Reserve some memory inside the render queue
1263   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1264
1265   // Construct message in the render queue memory; note that delete should not be called on the return value
1266   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddTexture, texture );
1267 }
1268
1269 void UpdateManager::RemoveTexture( Render::Texture* texture)
1270 {
1271   typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
1272
1273   // Reserve some memory inside the render queue
1274   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1275
1276   // Construct message in the render queue memory; note that delete should not be called on the return value
1277   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveTexture, texture );
1278 }
1279
1280 void UpdateManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
1281 {
1282   typedef MessageValue3< RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > DerivedType;
1283
1284   // Reserve some memory inside the message queue
1285   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1286
1287   // Construct message in the message queue memory; note that delete should not be called on the return value
1288   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params );
1289 }
1290
1291 void UpdateManager::GenerateMipmaps( Render::Texture* texture )
1292 {
1293   typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
1294
1295   // Reserve some memory inside the render queue
1296   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1297
1298   // Construct message in the render queue memory; note that delete should not be called on the return value
1299   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::GenerateMipmaps, texture );
1300 }
1301
1302 void UpdateManager::AddFrameBuffer( OwnerPointer< Render::FrameBuffer >& frameBuffer )
1303 {
1304   typedef MessageValue1< RenderManager, OwnerPointer< Render::FrameBuffer > > DerivedType;
1305
1306   // Reserve some memory inside the render queue
1307   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1308
1309   // Construct message in the render queue memory; note that delete should not be called on the return value
1310   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddFrameBuffer, frameBuffer );
1311 }
1312
1313 void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
1314 {
1315   typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
1316
1317   // Reserve some memory inside the render queue
1318   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1319
1320   // Construct message in the render queue memory; note that delete should not be called on the return value
1321   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveFrameBuffer, frameBuffer );
1322 }
1323
1324 void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
1325 {
1326   typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t > DerivedType;
1327
1328   // Reserve some memory inside the render queue
1329   uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1330
1331   // Construct message in the render queue memory; note that delete should not be called on the return value
1332   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer );
1333 }
1334
1335 } // namespace SceneGraph
1336
1337 } // namespace Internal
1338
1339 } // namespace Dali