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       return;
 635     }
 636   }
 637 }
 638
 639 unsigned int* UpdateManager::ReserveMessageSlot( std::size_t size, bool updateScene )
 640 {
 641   return mImpl->messageQueue.ReserveMessageSlot( size, updateScene );
 642 }
 643
 644 void UpdateManager::EventProcessingStarted()
 645 {
 646   mImpl->messageQueue.EventProcessingStarted();
 647 }
 648
 649 bool UpdateManager::FlushQueue()
 650 {
 651   return mImpl->messageQueue.FlushQueue();
 652 }
 653
 654 void UpdateManager::ResetProperties( BufferIndex bufferIndex )
 655 {
 656   // Clear the "animations finished" flag; This should be set if any (previously playing) animation is stopped
 657   mImpl->animationFinishedDuringUpdate = false;
 658
 659   // Animated properties have to be reset to their original value each frame
 660
 661   // Reset root properties
 662   if ( mImpl->root )
 663   {
 664     mImpl->root->ResetToBaseValues( bufferIndex );
 665   }
 666   if ( mImpl->systemLevelRoot )
 667   {
 668     mImpl->systemLevelRoot->ResetToBaseValues( bufferIndex );
 669   }
 670
 671   // Reset all the nodes
 672   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
 673   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
 674   for(;iter != endIter; ++iter)
 675   {
 676     (*iter)->ResetToBaseValues( bufferIndex );
 677   }
 678
 679   // Reset system-level render-task list properties to base values
 680   const RenderTaskList::RenderTaskContainer& systemLevelTasks = mImpl->systemLevelTaskList.GetTasks();
 681
 682   for (RenderTaskList::RenderTaskContainer::ConstIterator iter = systemLevelTasks.Begin(); iter != systemLevelTasks.End(); ++iter)
 683   {
 684     (*iter)->ResetToBaseValues( bufferIndex );
 685   }
 686
 687   // Reset render-task list properties to base values.
 688   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
 689
 690   for (RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(); iter != tasks.End(); ++iter)
 691   {
 692     (*iter)->ResetToBaseValues( bufferIndex );
 693   }
 694
 695   // Reset custom object properties to base values
 696   for (OwnerContainer<PropertyOwner*>::Iterator iter = mImpl->customObjects.Begin(); iter != mImpl->customObjects.End(); ++iter)
 697   {
 698     (*iter)->ResetToBaseValues( bufferIndex );
 699   }
 700
 701   mImpl->renderers.ResetToBaseValues( bufferIndex );
 702
 703   // Reset animatable shader properties to base values
 704   for (ShaderIter iter = mImpl->shaders.Begin(); iter != mImpl->shaders.End(); ++iter)
 705   {
 706     (*iter)->ResetToBaseValues( bufferIndex );
 707   }
 708 }
 709
 710 bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds )
 711 {
 712   bool gestureUpdated( false );
 713
 714   // constrain gestures... (in construction order)
 715   GestureContainer& gestures = mImpl->gestures;
 716
 717   for ( GestureIter iter = gestures.Begin(), endIter = gestures.End(); iter != endIter; ++iter )
 718   {
 719     PanGesture& gesture = **iter;
 720     gesture.ResetToBaseValues( bufferIndex ); // Needs to be done every time as gesture data is written directly to an update-buffer rather than via a message
 721     gestureUpdated |= gesture.UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 722   }
 723
 724   return gestureUpdated;
 725 }
 726
 727 void UpdateManager::Animate( BufferIndex bufferIndex, float elapsedSeconds )
 728 {
 729   AnimationContainer &animations = mImpl->animations;
 730   AnimationIter iter = animations.Begin();
 731   bool animationLooped = false;
 732   while ( iter != animations.End() )
 733   {
 734     Animation* animation = *iter;
 735     bool finished = false;
 736     bool looped = false;
 737     animation->Update( bufferIndex, elapsedSeconds, looped, finished );
 738
 739     mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || finished;
 740     animationLooped = animationLooped || looped;
 741
 742     // Remove animations that had been destroyed but were still waiting for an update
 743     if (animation->GetState() == Animation::Destroyed)
 744     {
 745       iter = animations.Erase(iter);
 746     }
 747     else
 748     {
 749       ++iter;
 750     }
 751   }
 752
 753   // queue the notification on finished or looped (to update loop count)
 754   if ( mImpl->animationFinishedDuringUpdate || animationLooped )
 755   {
 756     // The application should be notified by NotificationManager, in another thread
 757     mImpl->notificationManager.QueueCompleteNotification( &mImpl->animationFinishedNotifier );
 758   }
 759 }
 760
 761 void UpdateManager::ConstrainCustomObjects( BufferIndex bufferIndex )
 762 {
 763   //Constrain custom objects (in construction order)
 764   OwnerContainer< PropertyOwner* >& customObjects = mImpl->customObjects;
 765   const OwnerContainer< PropertyOwner* >::Iterator endIter = customObjects.End();
 766   for ( OwnerContainer< PropertyOwner* >::Iterator iter = customObjects.Begin(); endIter != iter; ++iter )
 767   {
 768     PropertyOwner& object = **iter;
 769     ConstrainPropertyOwner( object, bufferIndex );
 770   }
 771 }
 772
 773 void UpdateManager::ConstrainRenderTasks( BufferIndex bufferIndex )
 774 {
 775   // Constrain system-level render-tasks
 776   const RenderTaskList::RenderTaskContainer& systemLevelTasks = mImpl->systemLevelTaskList.GetTasks();
 777   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = systemLevelTasks.Begin(); iter != systemLevelTasks.End(); ++iter )
 778   {
 779     RenderTask& task = **iter;
 780     ConstrainPropertyOwner( task, bufferIndex );
 781   }
 782
 783   // Constrain render-tasks
 784   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
 785   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(); iter != tasks.End(); ++iter )
 786   {
 787     RenderTask& task = **iter;
 788     ConstrainPropertyOwner( task, bufferIndex );
 789   }
 790 }
 791
 792 void UpdateManager::ConstrainShaders( BufferIndex bufferIndex )
 793 {
 794   // constrain shaders... (in construction order)
 795   ShaderContainer& shaders = mImpl->shaders;
 796   for ( ShaderIter iter = shaders.Begin(); iter != shaders.End(); ++iter )
 797   {
 798     Shader& shader = **iter;
 799     ConstrainPropertyOwner( shader, bufferIndex );
 800   }
 801 }
 802
 803 void UpdateManager::ProcessPropertyNotifications( BufferIndex bufferIndex )
 804 {
 805   PropertyNotificationContainer &notifications = mImpl->propertyNotifications;
 806   PropertyNotificationIter iter = notifications.Begin();
 807
 808   while ( iter != notifications.End() )
 809   {
 810     PropertyNotification* notification = *iter;
 811     bool valid = notification->Check( bufferIndex );
 812     if(valid)
 813     {
 814       mImpl->notificationManager.QueueMessage( PropertyChangedMessage( mImpl->propertyNotifier, notification, notification->GetValidity() ) );
 815     }
 816     ++iter;
 817   }
 818 }
 819
 820 void UpdateManager::ForwardCompiledShadersToEventThread()
 821 {
 822   DALI_ASSERT_DEBUG( (mImpl->shaderSaver != 0) && "shaderSaver should be wired-up during startup." );
 823   if( mImpl->shaderSaver )
 824   {
 825     // lock and swap the queues
 826     {
 827       // render might be attempting to send us more binaries at the same time
 828       Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
 829       mImpl->renderCompiledShaders.swap( mImpl->updateCompiledShaders );
 830     }
 831
 832     if( mImpl->updateCompiledShaders.size() > 0 )
 833     {
 834       ShaderSaver& factory = *mImpl->shaderSaver;
 835       ShaderDataBinaryQueue::iterator i   = mImpl->updateCompiledShaders.begin();
 836       ShaderDataBinaryQueue::iterator end = mImpl->updateCompiledShaders.end();
 837       for( ; i != end; ++i )
 838       {
 839         mImpl->notificationManager.QueueMessage( ShaderCompiledMessage( factory, *i ) );
 840       }
 841       // we don't need them in update anymore
 842       mImpl->updateCompiledShaders.clear();
 843     }
 844   }
 845 }
 846
 847 void UpdateManager::UpdateRenderers( BufferIndex bufferIndex )
 848 {
 849   const OwnerContainer<Renderer*>& rendererContainer( mImpl->renderers.GetObjectContainer() );
 850   unsigned int rendererCount( rendererContainer.Size() );
 851   for( unsigned int i(0); i<rendererCount; ++i )
 852   {
 853     //Apply constraints
 854     ConstrainPropertyOwner( *rendererContainer[i], bufferIndex );
 855
 856     rendererContainer[i]->PrepareRender( bufferIndex );
 857   }
 858 }
 859
 860 void UpdateManager::UpdateNodes( BufferIndex bufferIndex )
 861 {
 862   mImpl->nodeDirtyFlags = NothingFlag;
 863
 864   if ( !mImpl->root )
 865   {
 866     return;
 867   }
 868
 869   // Prepare resources, update shaders, for each node
 870   // And add the renderers to the sorted layers. Start from root, which is also a layer
 871   mImpl->nodeDirtyFlags = UpdateNodeTree( *( mImpl->root ),
 872                                           bufferIndex,
 873                                           mImpl->renderQueue );
 874
 875   if ( mImpl->systemLevelRoot )
 876   {
 877     mImpl->nodeDirtyFlags |= UpdateNodeTree( *( mImpl->systemLevelRoot ),
 878                                              bufferIndex,
 879                                              mImpl->renderQueue );
 880   }
 881 }
 882
 883 unsigned int UpdateManager::Update( float elapsedSeconds,
 884                                     unsigned int lastVSyncTimeMilliseconds,
 885                                     unsigned int nextVSyncTimeMilliseconds )
 886 {
 887   const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
 888
 889   //Clear nodes/resources which were previously discarded
 890   mImpl->discardQueue.Clear( bufferIndex );
 891
 892   //Process Touches & Gestures
 893   const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 894
 895   const bool updateScene =                                  // The scene-graph requires an update if..
 896       (mImpl->nodeDirtyFlags & RenderableUpdateFlags) ||    // ..nodes were dirty in previous frame OR
 897       IsAnimationRunning()                            ||    // ..at least one animation is running OR
 898       mImpl->messageQueue.IsSceneUpdateRequired()     ||    // ..a message that modifies the scene graph node tree is queued OR
 899       gestureUpdated;                                       // ..a gesture property was updated
 900
 901
 902   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 903   // values if the scene was updated in the previous frame.
 904   if( updateScene || mImpl->previousUpdateScene )
 905   {
 906     //Reset properties from the previous update
 907     ResetProperties( bufferIndex );
 908     mImpl->transformManager.ResetToBaseValue();
 909   }
 910
 911   //Process the queued scene messages
 912   mImpl->messageQueue.ProcessMessages( bufferIndex );
 913
 914   //Forward compiled shader programs to event thread for saving
 915   ForwardCompiledShadersToEventThread();
 916
 917   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 918   // renderer lists if the scene was updated in the previous frame.
 919   // We should not start skipping update steps or reusing lists until there has been two frames where nothing changes
 920   if( updateScene || mImpl->previousUpdateScene )
 921   {
 922     //Animate
 923     Animate( bufferIndex, elapsedSeconds );
 924
 925     //Constraint custom objects
 926     ConstrainCustomObjects( bufferIndex );
 927
 928     //Clear the lists of renderers from the previous update
 929     for( size_t i(0); i<mImpl->sortedLayers.size(); ++i )
 930     {
 931       mImpl->sortedLayers[i]->ClearRenderables();
 932     }
 933
 934     for( size_t i(0); i<mImpl->systemLevelSortedLayers.size(); ++i )
 935     {
 936       mImpl->systemLevelSortedLayers[i]->ClearRenderables();
 937     }
 938
 939     //Update node hierarchy, apply constraints and perform sorting / culling.
 940     //This will populate each Layer with a list of renderers which are ready.
 941     UpdateNodes( bufferIndex );
 942
 943     //Apply constraints to RenderTasks, shaders
 944     ConstrainRenderTasks( bufferIndex );
 945     ConstrainShaders( bufferIndex );
 946
 947     //Update renderers and apply constraints
 948     UpdateRenderers( bufferIndex );
 949
 950     //Update the trnasformations of all the nodes
 951     mImpl->transformManager.Update();
 952
 953     //Process Property Notifications
 954     ProcessPropertyNotifications( bufferIndex );
 955
 956     //Process the RenderTasks; this creates the instructions for rendering the next frame.
 957     //reset the update buffer index and make sure there is enough room in the instruction container
 958     mImpl->renderInstructions.ResetAndReserve( bufferIndex,
 959                                                mImpl->taskList.GetTasks().Count() + mImpl->systemLevelTaskList.GetTasks().Count() );
 960
 961     if ( NULL != mImpl->root )
 962     {
 963       mImpl->renderTaskProcessor.Process( bufferIndex,
 964                                         mImpl->taskList,
 965                                         *mImpl->root,
 966                                         mImpl->sortedLayers,
 967                                         mImpl->renderInstructions );
 968
 969       // Process the system-level RenderTasks last
 970       if ( NULL != mImpl->systemLevelRoot )
 971       {
 972         mImpl->renderTaskProcessor.Process( bufferIndex,
 973                                           mImpl->systemLevelTaskList,
 974                                           *mImpl->systemLevelRoot,
 975                                           mImpl->systemLevelSortedLayers,
 976                                           mImpl->renderInstructions );
 977       }
 978     }
 979   }
 980
 981   // check the countdown and notify (note, at the moment this is only done for normal tasks, not for systemlevel tasks)
 982   bool doRenderOnceNotify = false;
 983   mImpl->renderTaskWaiting = false;
 984   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
 985   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(), endIter = tasks.End();
 986         endIter != iter; ++iter )
 987   {
 988     RenderTask& renderTask(*(*iter));
 989
 990     renderTask.UpdateState();
 991
 992     if( renderTask.IsWaitingToRender() &&
 993         renderTask.ReadyToRender( bufferIndex ) /*avoid updating forever when source actor is off-stage*/ )
 994     {
 995       mImpl->renderTaskWaiting = true; // keep update/render threads alive
 996     }
 997
 998     if( renderTask.HasRendered() )
 999     {
1000       doRenderOnceNotify = true;
1001     }
1002   }
1003
1004   if( doRenderOnceNotify )
1005   {
1006     DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n");
1007     mImpl->notificationManager.QueueCompleteNotification( mImpl->taskList.GetCompleteNotificationInterface() );
1008   }
1009
1010   // Macro is undefined in release build.
1011   SNAPSHOT_NODE_LOGGING;
1012
1013   // A ResetProperties() may be required in the next frame
1014   mImpl->previousUpdateScene = updateScene;
1015
1016   // Check whether further updates are required
1017   unsigned int keepUpdating = KeepUpdatingCheck( elapsedSeconds );
1018
1019   // tell the update manager that we're done so the queue can be given to event thread
1020   mImpl->notificationManager.UpdateCompleted();
1021
1022   // The update has finished; swap the double-buffering indices
1023   mSceneGraphBuffers.Swap();
1024
1025   return keepUpdating;
1026 }
1027
1028 unsigned int UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const
1029 {
1030   // Update the duration set via Stage::KeepRendering()
1031   if ( mImpl->keepRenderingSeconds > 0.0f )
1032   {
1033     mImpl->keepRenderingSeconds -= elapsedSeconds;
1034   }
1035
1036   unsigned int keepUpdatingRequest = KeepUpdating::NOT_REQUESTED;
1037
1038   // If Stage::KeepRendering() has been called, then continue until the duration has elapsed.
1039   // Keep updating until no messages are received and no animations are running.
1040   // If an animation has just finished, update at least once more for Discard end-actions.
1041   // No need to check for renderQueue as there is always a render after update and if that
1042   // render needs another update it will tell the adaptor to call update again
1043
1044   if ( mImpl->keepRenderingSeconds > 0.0f )
1045   {
1046     keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING;
1047   }
1048
1049   if ( IsAnimationRunning() ||
1050        mImpl->animationFinishedDuringUpdate )
1051   {
1052     keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING;
1053   }
1054
1055   if ( mImpl->renderTaskWaiting )
1056   {
1057     keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC;
1058   }
1059
1060   return keepUpdatingRequest;
1061 }
1062
1063 void UpdateManager::SetBackgroundColor( const Vector4& color )
1064 {
1065   typedef MessageValue1< RenderManager, Vector4 > DerivedType;
1066
1067   // Reserve some memory inside the render queue
1068   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1069
1070   // Construct message in the render queue memory; note that delete should not be called on the return value
1071   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetBackgroundColor, color );
1072 }
1073
1074 void UpdateManager::SetDefaultSurfaceRect( const Rect<int>& rect )
1075 {
1076   typedef MessageValue1< RenderManager, Rect<int> > DerivedType;
1077
1078   // Reserve some memory inside the render queue
1079   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1080
1081   // Construct message in the render queue memory; note that delete should not be called on the return value
1082   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceRect, rect );
1083 }
1084
1085 void UpdateManager::KeepRendering( float durationSeconds )
1086 {
1087   mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds );
1088 }
1089
1090 void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, bool systemLevel )
1091 {
1092   if ( !systemLevel )
1093   {
1094     // just copy the vector of pointers
1095     mImpl->sortedLayers = layers;
1096   }
1097   else
1098   {
1099     mImpl->systemLevelSortedLayers = layers;
1100   }
1101 }
1102
1103 void UpdateManager::SetShaderSaver( ShaderSaver& upstream )
1104 {
1105   mImpl->shaderSaver = &upstream;
1106 }
1107
1108 void UpdateManager::AddSampler( Render::Sampler* sampler )
1109 {
1110   // Message has ownership of Sampler while in transit from update to render
1111   typedef MessageValue1< RenderManager, OwnerPointer< Render::Sampler > > DerivedType;
1112
1113   // Reserve some memory inside the render queue
1114   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1115
1116   // Construct message in the render queue memory; note that delete should not be called on the return value
1117   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddSampler, sampler );
1118 }
1119
1120 void UpdateManager::RemoveSampler( Render::Sampler* sampler )
1121 {
1122   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1123
1124   // Reserve some memory inside the render queue
1125   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1126
1127   // Construct message in the render queue memory; note that delete should not be called on the return value
1128   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveSampler, sampler );
1129 }
1130
1131 void UpdateManager::SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode )
1132 {
1133   typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
1134
1135   // Reserve some memory inside the render queue
1136   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1137
1138   // Construct message in the render queue memory; note that delete should not be called on the return value
1139   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
1140 }
1141
1142 void UpdateManager::SetWrapMode( Render::Sampler* sampler, unsigned int rWrapMode, unsigned int sWrapMode, unsigned int tWrapMode )
1143 {
1144   typedef MessageValue4< RenderManager, Render::Sampler*, unsigned int, unsigned int, unsigned int > DerivedType;
1145
1146   // Reserve some memory inside the render queue
1147   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1148
1149   // Construct message in the render queue memory; note that delete should not be called on the return value
1150   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode );
1151 }
1152
1153 void UpdateManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1154 {
1155   // Message has ownership of format while in transit from update -> render
1156   typedef MessageValue1< RenderManager, OwnerPointer< Render::PropertyBuffer > > DerivedType;
1157
1158   // Reserve some memory inside the render queue
1159   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1160
1161   // Construct message in the render queue memory; note that delete should not be called on the return value
1162   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddPropertyBuffer, propertyBuffer );
1163 }
1164
1165 void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1166 {
1167   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1168
1169   // Reserve some memory inside the render queue
1170   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1171
1172   // Construct message in the render queue memory; note that delete should not be called on the return value
1173   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemovePropertyBuffer, propertyBuffer );
1174 }
1175
1176 void UpdateManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format )
1177 {
1178   // Message has ownership of format while in transit from update -> render
1179   typedef MessageValue2< RenderManager, Render::PropertyBuffer*, OwnerPointer< Render::PropertyBuffer::Format > > DerivedType;
1180
1181   // Reserve some memory inside the render queue
1182   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1183
1184   // Construct message in the render queue memory; note that delete should not be called on the return value
1185   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetPropertyBufferFormat, propertyBuffer, format );
1186 }
1187
1188 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data, size_t size )
1189 {
1190   // Message has ownership of format while in transit from update -> render
1191   typedef MessageValue3< RenderManager, Render::PropertyBuffer*, OwnerPointer< Dali::Vector<char> >, size_t > DerivedType;
1192
1193   // Reserve some memory inside the render queue
1194   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1195
1196   // Construct message in the render queue memory; note that delete should not be called on the return value
1197   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
1198 }
1199
1200 void UpdateManager::AddGeometry( Render::Geometry* geometry )
1201 {
1202   // Message has ownership of format while in transit from update -> render
1203   typedef MessageValue1< RenderManager, OwnerPointer< Render::Geometry > > DerivedType;
1204
1205   // Reserve some memory inside the render queue
1206   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1207
1208   // Construct message in the render queue memory; note that delete should not be called on the return value
1209   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddGeometry, geometry );
1210 }
1211
1212 void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
1213 {
1214   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1215
1216   // Reserve some memory inside the render queue
1217   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1218
1219   // Construct message in the render queue memory; note that delete should not be called on the return value
1220   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveGeometry, geometry );
1221 }
1222
1223 void UpdateManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
1224 {
1225   typedef MessageValue2< RenderManager, Render::Geometry*, unsigned int > DerivedType;
1226
1227   // Reserve some memory inside the render queue
1228   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1229
1230   // Construct message in the render queue memory; note that delete should not be called on the return value
1231   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryType, geometry, geometryType );
1232 }
1233
1234 void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
1235 {
1236   typedef IndexBufferMessage< RenderManager > DerivedType;
1237
1238   // Reserve some memory inside the render queue
1239   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1240
1241   // Construct message in the render queue memory; note that delete should not be called on the return value
1242   new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
1243 }
1244
1245 void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1246 {
1247   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1248
1249   // Reserve some memory inside the render queue
1250   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1251
1252   // Construct message in the render queue memory; note that delete should not be called on the return value
1253   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveVertexBuffer, geometry, propertyBuffer );
1254 }
1255
1256 void UpdateManager::AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1257 {
1258   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1259
1260   // Reserve some memory inside the render queue
1261   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1262
1263   // Construct message in the render queue memory; note that delete should not be called on the return value
1264   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddVertexBuffer, geometry, propertyBuffer );
1265 }
1266
1267 void UpdateManager::AddTexture( Render::Texture* texture )
1268 {
1269   // Message has ownership of Texture while in transit from update -> render
1270   typedef MessageValue1< RenderManager, OwnerPointer< Render::Texture > > DerivedType;
1271
1272   // Reserve some memory inside the render queue
1273   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1274
1275   // Construct message in the render queue memory; note that delete should not be called on the return value
1276   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddTexture, texture );
1277 }
1278
1279 void UpdateManager::RemoveTexture( Render::Texture* texture)
1280 {
1281   typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
1282
1283   // Reserve some memory inside the render queue
1284   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1285
1286   // Construct message in the render queue memory; note that delete should not be called on the return value
1287   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveTexture, texture );
1288 }
1289
1290 void UpdateManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
1291 {
1292   typedef MessageValue3< RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > DerivedType;
1293
1294   // Reserve some memory inside the message queue
1295   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1296
1297   // Construct message in the message queue memory; note that delete should not be called on the return value
1298   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params );
1299 }
1300
1301 void UpdateManager::GenerateMipmaps( Render::Texture* texture )
1302 {
1303   typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
1304
1305   // Reserve some memory inside the render queue
1306   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1307
1308   // Construct message in the render queue memory; note that delete should not be called on the return value
1309   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::GenerateMipmaps, texture );
1310 }
1311
1312 void UpdateManager::AddFrameBuffer( Render::FrameBuffer* frameBuffer )
1313 {
1314   typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
1315
1316   // Reserve some memory inside the render queue
1317   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1318
1319   // Construct message in the render queue memory; note that delete should not be called on the return value
1320   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddFrameBuffer, frameBuffer );
1321 }
1322
1323 void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
1324 {
1325   typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
1326
1327   // Reserve some memory inside the render queue
1328   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1329
1330   // Construct message in the render queue memory; note that delete should not be called on the return value
1331   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveFrameBuffer, frameBuffer );
1332 }
1333
1334 void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, unsigned int mipmapLevel, unsigned int layer )
1335 {
1336   typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::Texture*, unsigned int, unsigned int > DerivedType;
1337
1338   // Reserve some memory inside the render queue
1339   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1340
1341   // Construct message in the render queue memory; note that delete should not be called on the return value
1342   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer );
1343 }
1344
1345 } // namespace SceneGraph
1346
1347 } // namespace Internal
1348
1349 } // namespace Dali