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

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