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   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. Note, MessageQueue::FlushQueue may be called
 938   // between calling IsSceneUpdateRequired() above and here, so updateScene should
 939   // be set again
 940   updateScene |= mImpl->messageQueue.ProcessMessages( bufferIndex );
 941
 942   //Post Process Ids of resources updated by renderer
 943   mImpl->resourceManager.PostProcessResources( bufferIndex );
 944
 945   //Forward compiled shader programs to event thread for saving
 946   ForwardCompiledShadersToEventThread();
 947
 948   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 949   // renderer lists if the scene was updated in the previous frame.
 950   // We should not start skipping update steps or reusing lists until there has been two frames where nothing changes
 951   if( updateScene || mImpl->previousUpdateScene )
 952   {
 953     //Animate
 954     Animate( bufferIndex, elapsedSeconds );
 955
 956     //Constraint custom objects
 957     ConstrainCustomObjects( bufferIndex );
 958
 959     //Prepare texture sets and apply constraints to them
 960     PrepareTextureSets( bufferIndex );
 961
 962     //Clear the lists of renderers from the previous update
 963     for( size_t i(0); i<mImpl->sortedLayers.size(); ++i )
 964     {
 965       mImpl->sortedLayers[i]->ClearRenderables();
 966     }
 967
 968     for( size_t i(0); i<mImpl->systemLevelSortedLayers.size(); ++i )
 969     {
 970       mImpl->systemLevelSortedLayers[i]->ClearRenderables();
 971     }
 972
 973     //Update node hierarchy, apply constraints and perform sorting / culling.
 974     //This will populate each Layer with a list of renderers which are ready.
 975     UpdateNodes( bufferIndex );
 976
 977     //Apply constraints to RenderTasks, shaders
 978     ConstrainRenderTasks( bufferIndex );
 979     ConstrainShaders( bufferIndex );
 980
 981     //Update renderers and apply constraints
 982     UpdateRenderers( bufferIndex );
 983
 984     //Update the trnasformations of all the nodes
 985     mImpl->transformManager.Update();
 986
 987     //Process Property Notifications
 988     ProcessPropertyNotifications( bufferIndex );
 989
 990     //Process the RenderTasks; this creates the instructions for rendering the next frame.
 991     //reset the update buffer index and make sure there is enough room in the instruction container
 992     mImpl->renderInstructions.ResetAndReserve( bufferIndex,
 993                                                mImpl->taskList.GetTasks().Count() + mImpl->systemLevelTaskList.GetTasks().Count() );
 994
 995     if ( NULL != mImpl->root )
 996     {
 997       mImpl->renderTaskProcessor.Process( bufferIndex,
 998                                         mImpl->taskList,
 999                                         *mImpl->root,
1000                                         mImpl->sortedLayers,
1001                                         mImpl->renderInstructions );
1002
1003       // Process the system-level RenderTasks last
1004       if ( NULL != mImpl->systemLevelRoot )
1005       {
1006         mImpl->renderTaskProcessor.Process( bufferIndex,
1007                                           mImpl->systemLevelTaskList,
1008                                           *mImpl->systemLevelRoot,
1009                                           mImpl->systemLevelSortedLayers,
1010                                           mImpl->renderInstructions );
1011       }
1012     }
1013   }
1014
1015   // check the countdown and notify (note, at the moment this is only done for normal tasks, not for systemlevel tasks)
1016   bool doRenderOnceNotify = false;
1017   mImpl->renderTaskWaiting = false;
1018   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
1019   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(), endIter = tasks.End();
1020         endIter != iter; ++iter )
1021   {
1022     RenderTask& renderTask(*(*iter));
1023
1024     renderTask.UpdateState();
1025
1026     if( renderTask.IsWaitingToRender() &&
1027         renderTask.ReadyToRender( bufferIndex ) /*avoid updating forever when source actor is off-stage*/ )
1028     {
1029       mImpl->renderTaskWaiting = true; // keep update/render threads alive
1030     }
1031
1032     if( renderTask.HasRendered() )
1033     {
1034       doRenderOnceNotify = true;
1035     }
1036   }
1037
1038   if( doRenderOnceNotify )
1039   {
1040     DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n");
1041     mImpl->notificationManager.QueueCompleteNotification( mImpl->taskList.GetCompleteNotificationInterface() );
1042   }
1043
1044   // Macro is undefined in release build.
1045   SNAPSHOT_NODE_LOGGING;
1046
1047   // A ResetProperties() may be required in the next frame
1048   mImpl->previousUpdateScene = updateScene;
1049
1050   // Check whether further updates are required
1051   unsigned int keepUpdating = KeepUpdatingCheck( elapsedSeconds );
1052
1053   // tell the update manager that we're done so the queue can be given to event thread
1054   mImpl->notificationManager.UpdateCompleted();
1055
1056   // The update has finished; swap the double-buffering indices
1057   mSceneGraphBuffers.Swap();
1058
1059   return keepUpdating;
1060 }
1061
1062 unsigned int UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const
1063 {
1064   // Update the duration set via Stage::KeepRendering()
1065   if ( mImpl->keepRenderingSeconds > 0.0f )
1066   {
1067     mImpl->keepRenderingSeconds -= elapsedSeconds;
1068   }
1069
1070   unsigned int keepUpdatingRequest = KeepUpdating::NOT_REQUESTED;
1071
1072   // If Stage::KeepRendering() has been called, then continue until the duration has elapsed.
1073   // Keep updating until no messages are received and no animations are running.
1074   // If an animation has just finished, update at least once more for Discard end-actions.
1075   // No need to check for renderQueue as there is always a render after update and if that
1076   // render needs another update it will tell the adaptor to call update again
1077
1078   if ( mImpl->keepRenderingSeconds > 0.0f )
1079   {
1080     keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING;
1081   }
1082
1083   if ( IsAnimationRunning() ||
1084        mImpl->animationFinishedDuringUpdate )
1085   {
1086     keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING;
1087   }
1088
1089   if ( mImpl->renderTaskWaiting )
1090   {
1091     keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC;
1092   }
1093
1094   return keepUpdatingRequest;
1095 }
1096
1097 void UpdateManager::SetBackgroundColor( const Vector4& color )
1098 {
1099   typedef MessageValue1< RenderManager, Vector4 > DerivedType;
1100
1101   // Reserve some memory inside the render queue
1102   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1103
1104   // Construct message in the render queue memory; note that delete should not be called on the return value
1105   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetBackgroundColor, color );
1106 }
1107
1108 void UpdateManager::SetDefaultSurfaceRect( const Rect<int>& rect )
1109 {
1110   typedef MessageValue1< RenderManager, Rect<int> > DerivedType;
1111
1112   // Reserve some memory inside the render queue
1113   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1114
1115   // Construct message in the render queue memory; note that delete should not be called on the return value
1116   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceRect, rect );
1117 }
1118
1119 void UpdateManager::KeepRendering( float durationSeconds )
1120 {
1121   mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds );
1122 }
1123
1124 void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, bool systemLevel )
1125 {
1126   if ( !systemLevel )
1127   {
1128     // just copy the vector of pointers
1129     mImpl->sortedLayers = layers;
1130   }
1131   else
1132   {
1133     mImpl->systemLevelSortedLayers = layers;
1134   }
1135 }
1136
1137 void UpdateManager::SetShaderSaver( ShaderSaver& upstream )
1138 {
1139   mImpl->shaderSaver = &upstream;
1140 }
1141
1142 void UpdateManager::AddSampler( Render::Sampler* sampler )
1143 {
1144   typedef MessageValue1< RenderManager, Render::Sampler* > 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::AddSampler, sampler );
1151 }
1152
1153 void UpdateManager::RemoveSampler( Render::Sampler* sampler )
1154 {
1155   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1156
1157   // Reserve some memory inside the render queue
1158   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1159
1160   // Construct message in the render queue memory; note that delete should not be called on the return value
1161   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveSampler, sampler );
1162 }
1163
1164 void UpdateManager::SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode )
1165 {
1166   typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
1167
1168   // Reserve some memory inside the render queue
1169   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1170
1171   // Construct message in the render queue memory; note that delete should not be called on the return value
1172   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
1173 }
1174
1175 void UpdateManager::SetWrapMode( Render::Sampler* sampler, unsigned int rWrapMode, unsigned int sWrapMode, unsigned int tWrapMode )
1176 {
1177   typedef MessageValue4< RenderManager, Render::Sampler*, unsigned int, unsigned int, unsigned int > DerivedType;
1178
1179   // Reserve some memory inside the render queue
1180   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1181
1182   // Construct message in the render queue memory; note that delete should not be called on the return value
1183   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode );
1184 }
1185
1186 void UpdateManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1187 {
1188   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1189
1190   // Reserve some memory inside the render queue
1191   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1192
1193   // Construct message in the render queue memory; note that delete should not be called on the return value
1194   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddPropertyBuffer, propertyBuffer );
1195 }
1196
1197 void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1198 {
1199   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1200
1201   // Reserve some memory inside the render queue
1202   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1203
1204   // Construct message in the render queue memory; note that delete should not be called on the return value
1205   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemovePropertyBuffer, propertyBuffer );
1206 }
1207
1208 void UpdateManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format )
1209 {
1210   typedef MessageValue2< RenderManager, Render::PropertyBuffer*, Render::PropertyBuffer::Format* > DerivedType;
1211
1212   // Reserve some memory inside the render queue
1213   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1214
1215   // Construct message in the render queue memory; note that delete should not be called on the return value
1216   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetPropertyBufferFormat, propertyBuffer, format );
1217 }
1218
1219 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data, size_t size )
1220 {
1221   typedef MessageValue3< RenderManager, Render::PropertyBuffer*, Dali::Vector<char>*, size_t > DerivedType;
1222
1223   // Reserve some memory inside the render queue
1224   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1225
1226   // Construct message in the render queue memory; note that delete should not be called on the return value
1227   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
1228 }
1229
1230 void UpdateManager::AddGeometry( Render::Geometry* geometry )
1231 {
1232   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1233
1234   // Reserve some memory inside the render queue
1235   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1236
1237   // Construct message in the render queue memory; note that delete should not be called on the return value
1238   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddGeometry, geometry );
1239 }
1240
1241 void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
1242 {
1243   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1244
1245   // Reserve some memory inside the render queue
1246   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1247
1248   // Construct message in the render queue memory; note that delete should not be called on the return value
1249   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveGeometry, geometry );
1250 }
1251
1252 void UpdateManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
1253 {
1254   typedef MessageValue2< RenderManager, Render::Geometry*, unsigned int > DerivedType;
1255
1256   // Reserve some memory inside the render queue
1257   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1258
1259   // Construct message in the render queue memory; note that delete should not be called on the return value
1260   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryType, geometry, geometryType );
1261 }
1262
1263 void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
1264 {
1265   typedef IndexBufferMessage< RenderManager > DerivedType;
1266
1267   // Reserve some memory inside the render queue
1268   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1269
1270   // Construct message in the render queue memory; note that delete should not be called on the return value
1271   new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
1272 }
1273
1274 void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1275 {
1276   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1277
1278   // Reserve some memory inside the render queue
1279   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1280
1281   // Construct message in the render queue memory; note that delete should not be called on the return value
1282   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveVertexBuffer, geometry, propertyBuffer );
1283 }
1284
1285 void UpdateManager::AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1286 {
1287   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1288
1289   // Reserve some memory inside the render queue
1290   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1291
1292   // Construct message in the render queue memory; note that delete should not be called on the return value
1293   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddVertexBuffer, geometry, propertyBuffer );
1294 }
1295
1296 void UpdateManager::AddTexture( Render::NewTexture* texture )
1297 {
1298   typedef MessageValue1< RenderManager, Render::NewTexture* > DerivedType;
1299
1300   // Reserve some memory inside the render queue
1301   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1302
1303   // Construct message in the render queue memory; note that delete should not be called on the return value
1304   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddTexture, texture );
1305 }
1306
1307 void UpdateManager::RemoveTexture( Render::NewTexture* texture)
1308 {
1309   typedef MessageValue1< RenderManager, Render::NewTexture* > DerivedType;
1310
1311   // Reserve some memory inside the render queue
1312   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1313
1314   // Construct message in the render queue memory; note that delete should not be called on the return value
1315   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveTexture, texture );
1316 }
1317
1318 void UpdateManager::UploadTexture( Render::NewTexture* texture, PixelDataPtr pixelData, const NewTexture::UploadParams& params )
1319 {
1320   typedef MessageValue3< RenderManager, Render::NewTexture*, PixelDataPtr, NewTexture::UploadParams > DerivedType;
1321
1322   // Reserve some memory inside the message queue
1323   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1324
1325   // Construct message in the message queue memory; note that delete should not be called on the return value
1326   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params );
1327 }
1328
1329 void UpdateManager::GenerateMipmaps( Render::NewTexture* texture )
1330 {
1331   typedef MessageValue1< RenderManager, Render::NewTexture* > DerivedType;
1332
1333   // Reserve some memory inside the render queue
1334   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1335
1336   // Construct message in the render queue memory; note that delete should not be called on the return value
1337   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::GenerateMipmaps, texture );
1338 }
1339
1340 void UpdateManager::AddFrameBuffer( Render::FrameBuffer* frameBuffer )
1341 {
1342   typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
1343
1344   // Reserve some memory inside the render queue
1345   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1346
1347   // Construct message in the render queue memory; note that delete should not be called on the return value
1348   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddFrameBuffer, frameBuffer );
1349 }
1350
1351 void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
1352 {
1353   typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
1354
1355   // Reserve some memory inside the render queue
1356   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1357
1358   // Construct message in the render queue memory; note that delete should not be called on the return value
1359   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveFrameBuffer, frameBuffer );
1360 }
1361
1362 void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::NewTexture* texture, unsigned int mipmapLevel, unsigned int layer )
1363 {
1364   typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::NewTexture*, unsigned int, unsigned int > DerivedType;
1365
1366   // Reserve some memory inside the render queue
1367   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1368
1369   // Construct message in the render queue memory; note that delete should not be called on the return value
1370   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer );
1371 }
1372
1373 } // namespace SceneGraph
1374
1375 } // namespace Internal
1376
1377 } // namespace Dali