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