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 #include <dali/internal/update/manager/geometry-batcher.h>
  62 #include <dali/internal/update/render-tasks/scene-graph-camera.h>
  63
  64 #include <dali/internal/render/common/render-instruction-container.h>
  65 #include <dali/internal/render/common/render-manager.h>
  66 #include <dali/internal/render/queue/render-queue.h>
  67 #include <dali/internal/render/gl-resources/texture-cache.h>
  68 #include <dali/internal/render/shaders/scene-graph-shader.h>
  69
  70 // Un-comment to enable node tree debug logging
  71 //#define NODE_TREE_LOGGING 1
  72
  73 #if ( defined( DEBUG_ENABLED ) && defined( NODE_TREE_LOGGING ) )
  74 #define SNAPSHOT_NODE_LOGGING \
  75 const int FRAME_COUNT_TRIGGER = 16;\
  76 if( mImpl->frameCounter >= FRAME_COUNT_TRIGGER )\
  77   {\
  78     if ( NULL != mImpl->root )\
  79     {\
  80       mImpl->frameCounter = 0;\
  81       PrintNodeTree( *mImpl->root, mSceneGraphBuffers.GetUpdateBufferIndex(), "" );\
  82     }\
  83   }\
  84 mImpl->frameCounter++;
  85 #else
  86 #define SNAPSHOT_NODE_LOGGING
  87 #endif
  88
  89 #if defined(DEBUG_ENABLED)
  90 extern Debug::Filter* gRenderTaskLogFilter;
  91 #endif
  92
  93
  94 using namespace Dali::Integration;
  95 using Dali::Internal::Update::MessageQueue;
  96
  97 namespace Dali
  98 {
  99
 100 namespace Internal
 101 {
 102
 103 namespace SceneGraph
 104 {
 105
 106 typedef OwnerContainer< Shader* >              ShaderContainer;
 107 typedef ShaderContainer::Iterator              ShaderIter;
 108 typedef ShaderContainer::ConstIterator         ShaderConstIter;
 109
 110 typedef std::vector<Internal::ShaderDataPtr>   ShaderDataBinaryQueue;
 111
 112 typedef OwnerContainer<PanGesture*>            GestureContainer;
 113 typedef GestureContainer::Iterator             GestureIter;
 114 typedef GestureContainer::ConstIterator        GestureConstIter;
 115
 116 typedef OwnerContainer< TextureSet* >          TextureSetContainer;
 117 typedef TextureSetContainer::Iterator          TextureSetIter;
 118 typedef TextureSetContainer::ConstIterator     TextureSetConstIter;
 119
 120 /**
 121  * Structure to contain UpdateManager internal data
 122  */
 123 struct UpdateManager::Impl
 124 {
 125   Impl( NotificationManager& notificationManager,
 126         CompleteNotificationInterface& animationFinishedNotifier,
 127         PropertyNotifier& propertyNotifier,
 128         ResourceManager& resourceManager,
 129         DiscardQueue& discardQueue,
 130         RenderController& renderController,
 131         RenderManager& renderManager,
 132         RenderQueue& renderQueue,
 133         SceneGraphBuffers& sceneGraphBuffers,
 134         GeometryBatcher& geometryBatcher,
 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     geometryBatcher( geometryBatcher ),
 150     renderTaskProcessor( renderTaskProcessor ),
 151     backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
 152     taskList( renderMessageDispatcher, resourceManager ),
 153     systemLevelTaskList( renderMessageDispatcher, resourceManager ),
 154     root( NULL ),
 155     systemLevelRoot( NULL ),
 156     renderers( sceneGraphBuffers, discardQueue ),
 157     textureSets(),
 158     messageQueue( renderController, sceneGraphBuffers ),
 159     keepRenderingSeconds( 0.0f ),
 160     animationFinishedDuringUpdate( false ),
 161     nodeDirtyFlags( TransformFlag ), // set to TransformFlag to ensure full update the first time through Update()
 162     previousUpdateScene( false ),
 163     frameCounter( 0 ),
 164     renderTaskWaiting( false )
 165   {
 166     sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue );
 167
 168     renderers.SetSceneController( *sceneController );
 169
 170     discardQueue.SetGeometryBatcher( &geometryBatcher );
 171
 172     // create first 'dummy' node
 173     nodes.PushBack(0u);
 174   }
 175
 176   ~Impl()
 177   {
 178     // Disconnect render tasks from nodes, before destroying the nodes
 179     RenderTaskList::RenderTaskContainer& tasks = taskList.GetTasks();
 180     for (RenderTaskList::RenderTaskContainer::Iterator iter = tasks.Begin(); iter != tasks.End(); ++iter)
 181     {
 182       (*iter)->SetSourceNode( NULL );
 183     }
 184     // ..repeat for system level RenderTasks
 185     RenderTaskList::RenderTaskContainer& systemLevelTasks = systemLevelTaskList.GetTasks();
 186     for (RenderTaskList::RenderTaskContainer::Iterator iter = systemLevelTasks.Begin(); iter != systemLevelTasks.End(); ++iter)
 187     {
 188       (*iter)->SetSourceNode( NULL );
 189     }
 190
 191     // UpdateManager owns the Nodes
 192     Vector<Node*>::Iterator iter = nodes.Begin()+1;
 193     Vector<Node*>::Iterator endIter = nodes.End();
 194     for(;iter!=endIter;++iter)
 195     {
 196       (*iter)->OnDestroy();
 197       delete(*iter);
 198     }
 199
 200     // If there is root, reset it, otherwise do nothing as rendering was never started
 201     if( root )
 202     {
 203       root->OnDestroy();
 204
 205       delete root;
 206       root = NULL;
 207     }
 208
 209     if( systemLevelRoot )
 210     {
 211       systemLevelRoot->OnDestroy();
 212
 213       delete systemLevelRoot;
 214       systemLevelRoot = NULL;
 215     }
 216
 217     delete sceneController;
 218   }
 219
 220   SceneGraphBuffers                   sceneGraphBuffers;             ///< Used to keep track of which buffers are being written or read
 221   RenderMessageDispatcher             renderMessageDispatcher;       ///< Used for passing messages to the render-thread
 222   NotificationManager&                notificationManager;           ///< Queues notification messages for the event-thread.
 223   TransformManager                    transformManager;              ///< Used to update the transformation matrices of the nodes
 224   CompleteNotificationInterface&      animationFinishedNotifier;     ///< Provides notification to applications when animations are finished.
 225   PropertyNotifier&                   propertyNotifier;              ///< Provides notification to applications when properties are modified.
 226   ShaderSaver*                        shaderSaver;                   ///< Saves shader binaries.
 227   ResourceManager&                    resourceManager;               ///< resource manager
 228   DiscardQueue&                       discardQueue;                  ///< Nodes are added here when disconnected from the scene-graph.
 229   RenderController&                   renderController;              ///< render controller
 230   SceneControllerImpl*                sceneController;               ///< scene controller
 231   RenderManager&                      renderManager;                 ///< This is responsible for rendering the results of each "update"
 232   RenderQueue&                        renderQueue;                   ///< Used to queue messages for the next render
 233   RenderInstructionContainer&         renderInstructions;            ///< Used to prepare the render instructions
 234   GeometryBatcher&                    geometryBatcher;               ///< An instance of the GeometryBatcher
 235   RenderTaskProcessor&                renderTaskProcessor;           ///< Handles RenderTasks and RenderInstrucitons
 236
 237   Vector4                             backgroundColor;               ///< The glClear color used at the beginning of each frame.
 238
 239   RenderTaskList                      taskList;                      ///< The list of scene graph render-tasks
 240   RenderTaskList                      systemLevelTaskList;           ///< Separate render-tasks for system-level content
 241
 242   Layer*                              root;                          ///< The root node (root is a layer)
 243   Layer*                              systemLevelRoot;               ///< A separate root-node for system-level content
 244
 245   Vector<Node*>                       nodes;                         ///< A container of all instantiated nodes
 246
 247   SortedLayerPointers                 sortedLayers;                  ///< A container of Layer pointers sorted by depth
 248   SortedLayerPointers                 systemLevelSortedLayers;       ///< A separate container of system-level Layers
 249
 250   OwnerContainer< Camera* >           cameras;                       ///< A container of cameras
 251   OwnerContainer< PropertyOwner* >    customObjects;                 ///< A container of owned objects (with custom properties)
 252
 253   AnimationContainer                  animations;                    ///< A container of owned animations
 254   PropertyNotificationContainer       propertyNotifications;         ///< A container of owner property notifications.
 255
 256   ObjectOwnerContainer<Renderer>      renderers;
 257   TextureSetContainer                 textureSets;                   ///< A container of texture sets
 258
 259   ShaderContainer                     shaders;                       ///< A container of owned shaders
 260
 261   MessageQueue                        messageQueue;                  ///< The messages queued from the event-thread
 262   ShaderDataBinaryQueue               renderCompiledShaders;         ///< Shaders compiled on Render thread are inserted here for update thread to pass on to event thread.
 263   ShaderDataBinaryQueue               updateCompiledShaders;         ///< Shaders to be sent from Update to Event
 264   Mutex                               compiledShaderMutex;           ///< lock to ensure no corruption on the renderCompiledShaders
 265
 266   float                               keepRenderingSeconds;          ///< Set via Dali::Stage::KeepRendering
 267   bool                                animationFinishedDuringUpdate; ///< Flag whether any animations finished during the Update()
 268
 269   int                                 nodeDirtyFlags;                ///< cumulative node dirty flags from previous frame
 270   bool                                previousUpdateScene;           ///< True if the scene was updated in the previous frame (otherwise it was optimized out)
 271
 272   int                                 frameCounter;                  ///< Frame counter used in debugging to choose which frame to debug and which to ignore.
 273
 274   GestureContainer                    gestures;                      ///< A container of owned gesture detectors
 275   bool                                renderTaskWaiting;             ///< A REFRESH_ONCE render task is waiting to be rendered
 276
 277 private:
 278
 279   Impl( const Impl& ); ///< Undefined
 280   Impl& operator=( const Impl& ); ///< Undefined
 281 };
 282
 283 UpdateManager::UpdateManager( NotificationManager& notificationManager,
 284                               CompleteNotificationInterface& animationFinishedNotifier,
 285                               PropertyNotifier& propertyNotifier,
 286                               ResourceManager& resourceManager,
 287                               DiscardQueue& discardQueue,
 288                               RenderController& controller,
 289                               RenderManager& renderManager,
 290                               RenderQueue& renderQueue,
 291                               TextureCacheDispatcher& textureCacheDispatcher,
 292                               GeometryBatcher& geometryBatcher,
 293                               RenderTaskProcessor& renderTaskProcessor )
 294   : mImpl(NULL)
 295 {
 296   mImpl = new Impl( notificationManager,
 297                     animationFinishedNotifier,
 298                     propertyNotifier,
 299                     resourceManager,
 300                     discardQueue,
 301                     controller,
 302                     renderManager,
 303                     renderQueue,
 304                     mSceneGraphBuffers,
 305                     geometryBatcher,
 306                     renderTaskProcessor );
 307
 308   textureCacheDispatcher.SetBufferIndices( &mSceneGraphBuffers );
 309   mImpl->geometryBatcher.SetUpdateManager( this );
 310 }
 311
 312 UpdateManager::~UpdateManager()
 313 {
 314   delete mImpl;
 315 }
 316
 317 void UpdateManager::InstallRoot( SceneGraph::Layer* layer, bool systemLevel )
 318 {
 319   DALI_ASSERT_DEBUG( layer->IsLayer() );
 320   DALI_ASSERT_DEBUG( layer->GetParent() == NULL);
 321
 322   if ( !systemLevel )
 323   {
 324     DALI_ASSERT_DEBUG( mImpl->root == NULL && "Root Node already installed" );
 325     mImpl->root = layer;
 326     mImpl->root->CreateTransform( &mImpl->transformManager );
 327   }
 328   else
 329   {
 330     DALI_ASSERT_DEBUG( mImpl->systemLevelRoot == NULL && "System-level Root Node already installed" );
 331     mImpl->systemLevelRoot = layer;
 332     mImpl->systemLevelRoot->CreateTransform( &mImpl->transformManager );
 333   }
 334
 335   layer->SetRoot(true);
 336 }
 337
 338 void UpdateManager::AddNode( Node* node )
 339 {
 340   DALI_ASSERT_ALWAYS( NULL != node );
 341   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
 342
 343   // Nodes must be sorted by pointer
 344   Vector<Node*>::Iterator begin = mImpl->nodes.Begin();
 345   for(Vector<Node*>::Iterator iter = mImpl->nodes.End()-1; iter >= begin; --iter)
 346   {
 347     if(node > (*iter))
 348     {
 349       mImpl->nodes.Insert((iter+1), node);
 350       node->CreateTransform( &mImpl->transformManager );
 351       node->mGeometryBatcher = &mImpl->geometryBatcher;
 352       break;
 353     }
 354   }
 355 }
 356
 357 void UpdateManager::ConnectNode( Node* parent, Node* node )
 358 {
 359   DALI_ASSERT_ALWAYS( NULL != parent );
 360   DALI_ASSERT_ALWAYS( NULL != node );
 361   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
 362
 363   parent->ConnectChild( node );
 364 }
 365
 366 void UpdateManager::DisconnectNode( Node* node )
 367 {
 368   Node* parent = node->GetParent();
 369   DALI_ASSERT_ALWAYS( NULL != parent );
 370   parent->SetDirtyFlag( ChildDeletedFlag ); // make parent dirty so that render items dont get reused
 371
 372   parent->DisconnectChild( mSceneGraphBuffers.GetUpdateBufferIndex(), *node );
 373 }
 374
 375 void UpdateManager::DestroyNode( Node* node )
 376 {
 377   DALI_ASSERT_ALWAYS( NULL != node );
 378   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should have been disconnected
 379
 380   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
 381   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
 382   for(;iter!=endIter;++iter)
 383   {
 384     if((*iter) == node)
 385     {
 386       mImpl->nodes.Erase(iter);
 387       break;
 388     }
 389   }
 390
 391   mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), node );
 392
 393   // Notify the Node about impending destruction
 394   node->OnDestroy();
 395 }
 396
 397 void UpdateManager::AddCamera( Camera* camera )
 398 {
 399   DALI_ASSERT_DEBUG( camera != NULL );
 400
 401   mImpl->cameras.PushBack( camera ); // takes ownership
 402 }
 403
 404 void UpdateManager::RemoveCamera( const Camera* camera )
 405 {
 406   // Find the camera
 407   OwnerContainer<Camera*>::Iterator iter = mImpl->cameras.Begin();
 408   OwnerContainer<Camera*>::ConstIterator end = mImpl->cameras.End();
 409   for ( ; iter != end; ++iter )
 410   {
 411     Camera* value = *iter;
 412     if ( camera == value )
 413     {
 414       // Transfer ownership to the discard queue
 415       mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), mImpl->cameras.Release( iter ) );
 416
 417       return;
 418     }
 419   }
 420
 421 }
 422
 423 void UpdateManager::AddObject( PropertyOwner* object )
 424 {
 425   DALI_ASSERT_DEBUG( NULL != object );
 426
 427   mImpl->customObjects.PushBack( object );
 428 }
 429
 430 void UpdateManager::RemoveObject( PropertyOwner* object )
 431 {
 432   DALI_ASSERT_DEBUG( NULL != object );
 433
 434   OwnerContainer< PropertyOwner* >& customObjects = mImpl->customObjects;
 435
 436   // Find the object and destroy it
 437   for ( OwnerContainer< PropertyOwner* >::Iterator iter = customObjects.Begin(); iter != customObjects.End(); ++iter )
 438   {
 439     PropertyOwner* current = *iter;
 440     if ( current == object )
 441     {
 442       customObjects.Erase( iter );
 443       return;
 444     }
 445   }
 446
 447   // Should not reach here
 448   DALI_ASSERT_DEBUG(false);
 449 }
 450
 451 void UpdateManager::AddAnimation( Animation* animation )
 452 {
 453   mImpl->animations.PushBack( animation );
 454 }
 455
 456 void UpdateManager::StopAnimation( Animation* animation )
 457 {
 458   DALI_ASSERT_DEBUG( animation && "NULL animation called to stop" );
 459
 460   bool animationFinished = animation->Stop( mSceneGraphBuffers.GetUpdateBufferIndex() );
 461
 462   mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || animationFinished;
 463 }
 464
 465 void UpdateManager::RemoveAnimation( Animation* animation )
 466 {
 467   DALI_ASSERT_DEBUG( animation && "NULL animation called to remove" );
 468
 469   animation->OnDestroy( mSceneGraphBuffers.GetUpdateBufferIndex() );
 470
 471   DALI_ASSERT_DEBUG( animation->GetState() == Animation::Destroyed );
 472 }
 473
 474 bool UpdateManager::IsAnimationRunning() const
 475 {
 476   bool isRunning(false);
 477   AnimationContainer& animations = mImpl->animations;
 478
 479   // Find any animation that isn't stopped or paused
 480
 481   const AnimationIter endIter = animations.End();
 482   for ( AnimationIter iter = animations.Begin(); !isRunning && iter != endIter; ++iter )
 483   {
 484     const Animation::State state = (*iter)->GetState();
 485
 486     if (state != Animation::Stopped &&
 487         state != Animation::Paused)
 488     {
 489       isRunning = true;
 490     }
 491   }
 492
 493   return isRunning;
 494 }
 495
 496 void UpdateManager::AddPropertyNotification( PropertyNotification* propertyNotification )
 497 {
 498   mImpl->propertyNotifications.PushBack( propertyNotification );
 499 }
 500
 501 void UpdateManager::RemovePropertyNotification( PropertyNotification* propertyNotification )
 502 {
 503   PropertyNotificationContainer &propertyNotifications = mImpl->propertyNotifications;
 504   PropertyNotificationIter iter = propertyNotifications.Begin();
 505
 506   while ( iter != propertyNotifications.End() )
 507   {
 508     if( *iter == propertyNotification )
 509     {
 510       propertyNotifications.Erase(iter);
 511       break;
 512     }
 513     ++iter;
 514   }
 515 }
 516
 517 void UpdateManager::PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode )
 518 {
 519   DALI_ASSERT_DEBUG( propertyNotification && "propertyNotification scene graph object missing" );
 520   propertyNotification->SetNotifyMode( notifyMode );
 521 }
 522
 523 ObjectOwnerContainer<Renderer>& UpdateManager::GetRendererOwner()
 524 {
 525   return mImpl->renderers;
 526 }
 527
 528 void UpdateManager::AddShader( Shader* shader )
 529 {
 530   DALI_ASSERT_DEBUG( NULL != shader );
 531
 532   if( mImpl->shaders.Count() == 0 )
 533   {
 534     // the first added shader becomes our default shader
 535     // Construct message in the render queue memory; note that delete should not be called on the return value
 536     typedef MessageValue1< RenderManager, Shader* > DerivedType;
 537
 538     // Reserve some memory inside the render queue
 539     unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 540
 541     // Construct message in the render queue memory; note that delete should not be called on the return value
 542     new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetDefaultShader, shader );
 543   }
 544
 545   mImpl->shaders.PushBack( shader );
 546 }
 547
 548 void UpdateManager::RemoveShader( Shader* shader )
 549 {
 550   DALI_ASSERT_DEBUG(shader != NULL);
 551
 552   ShaderContainer& shaders = mImpl->shaders;
 553
 554   // Find the shader and destroy it
 555   for ( ShaderIter iter = shaders.Begin(); iter != shaders.End(); ++iter )
 556   {
 557     Shader& current = **iter;
 558     if ( &current == shader )
 559     {
 560       // Transfer ownership to the discard queue
 561       // This keeps the shader alive, until the render-thread has finished with it
 562       mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), shaders.Release( iter ) );
 563
 564       return;
 565     }
 566   }
 567   // Should not reach here
 568   DALI_ASSERT_DEBUG(false);
 569 }
 570
 571 void UpdateManager::SetShaderProgram( Shader* shader,
 572                                       Internal::ShaderDataPtr shaderData, bool modifiesGeometry )
 573 {
 574   if( shaderData )
 575   {
 576
 577     typedef MessageValue3< Shader, Internal::ShaderDataPtr, ProgramCache*, bool> DerivedType;
 578
 579     // Reserve some memory inside the render queue
 580     unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 581
 582     // Construct message in the render queue memory; note that delete should not be called on the return value
 583     new (slot) DerivedType( shader, &Shader::SetProgram, shaderData, mImpl->renderManager.GetProgramCache(), modifiesGeometry );
 584   }
 585 }
 586
 587 void UpdateManager::SaveBinary( Internal::ShaderDataPtr shaderData )
 588 {
 589   DALI_ASSERT_DEBUG( shaderData && "No NULL shader data pointers please." );
 590   DALI_ASSERT_DEBUG( shaderData->GetBufferSize() > 0 && "Shader binary empty so nothing to save." );
 591   {
 592     // lock as update might be sending previously compiled shaders to event thread
 593     Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
 594     mImpl->renderCompiledShaders.push_back( shaderData );
 595   }
 596 }
 597
 598 RenderTaskList* UpdateManager::GetRenderTaskList( bool systemLevel )
 599 {
 600   if ( !systemLevel )
 601   {
 602     // copy the list, this is only likely to happen once in application life cycle
 603     return &(mImpl->taskList);
 604   }
 605   else
 606   {
 607     // copy the list, this is only likely to happen once in application life cycle
 608     return &(mImpl->systemLevelTaskList);
 609   }
 610 }
 611
 612 void UpdateManager::AddGesture( PanGesture* gesture )
 613 {
 614   DALI_ASSERT_DEBUG( NULL != gesture );
 615
 616   mImpl->gestures.PushBack( gesture );
 617 }
 618
 619 void UpdateManager::RemoveGesture( PanGesture* gesture )
 620 {
 621   DALI_ASSERT_DEBUG( gesture != NULL );
 622
 623   GestureContainer& gestures = mImpl->gestures;
 624
 625   // Find the gesture and destroy it
 626   for ( GestureIter iter = gestures.Begin(), endIter = gestures.End(); iter != endIter; ++iter )
 627   {
 628     PanGesture& current = **iter;
 629     if ( &current == gesture )
 630     {
 631       mImpl->gestures.Erase( iter );
 632       return;
 633     }
 634   }
 635   // Should not reach here
 636   DALI_ASSERT_DEBUG(false);
 637 }
 638
 639 void UpdateManager::AddTextureSet( TextureSet* textureSet )
 640 {
 641   DALI_ASSERT_DEBUG( NULL != textureSet );
 642   mImpl->textureSets.PushBack( textureSet );
 643 }
 644
 645 void UpdateManager::RemoveTextureSet( TextureSet* textureSet )
 646 {
 647   DALI_ASSERT_DEBUG(textureSet != NULL);
 648   size_t textureSetCount( mImpl->textureSets.Size() );
 649   for( size_t i(0); i<textureSetCount; ++i )
 650   {
 651     if( textureSet == mImpl->textureSets[i] )
 652     {
 653       mImpl->textureSets.Remove( mImpl->textureSets.Begin() + i );
 654       return;
 655     }
 656   }
 657 }
 658
 659 unsigned int* UpdateManager::ReserveMessageSlot( std::size_t size, bool updateScene )
 660 {
 661   return mImpl->messageQueue.ReserveMessageSlot( size, updateScene );
 662 }
 663
 664 void UpdateManager::EventProcessingStarted()
 665 {
 666   mImpl->messageQueue.EventProcessingStarted();
 667 }
 668
 669 bool UpdateManager::FlushQueue()
 670 {
 671   return mImpl->messageQueue.FlushQueue();
 672 }
 673
 674 void UpdateManager::ResetProperties( BufferIndex bufferIndex )
 675 {
 676   // Clear the "animations finished" flag; This should be set if any (previously playing) animation is stopped
 677   mImpl->animationFinishedDuringUpdate = false;
 678
 679   // Animated properties have to be reset to their original value each frame
 680
 681   // Reset root properties
 682   if ( mImpl->root )
 683   {
 684     mImpl->root->ResetToBaseValues( bufferIndex );
 685   }
 686   if ( mImpl->systemLevelRoot )
 687   {
 688     mImpl->systemLevelRoot->ResetToBaseValues( bufferIndex );
 689   }
 690
 691   // Reset all the nodes
 692   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
 693   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
 694   for(;iter != endIter; ++iter)
 695   {
 696     (*iter)->ResetToBaseValues( bufferIndex );
 697   }
 698
 699   // Reset system-level render-task list properties to base values
 700   const RenderTaskList::RenderTaskContainer& systemLevelTasks = mImpl->systemLevelTaskList.GetTasks();
 701
 702   for (RenderTaskList::RenderTaskContainer::ConstIterator iter = systemLevelTasks.Begin(); iter != systemLevelTasks.End(); ++iter)
 703   {
 704     (*iter)->ResetToBaseValues( bufferIndex );
 705   }
 706
 707   // Reset render-task list properties to base values.
 708   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
 709
 710   for (RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(); iter != tasks.End(); ++iter)
 711   {
 712     (*iter)->ResetToBaseValues( bufferIndex );
 713   }
 714
 715   // Reset custom object properties to base values
 716   for (OwnerContainer<PropertyOwner*>::Iterator iter = mImpl->customObjects.Begin(); iter != mImpl->customObjects.End(); ++iter)
 717   {
 718     (*iter)->ResetToBaseValues( bufferIndex );
 719   }
 720
 721   mImpl->renderers.ResetToBaseValues( bufferIndex );
 722
 723   // Reset animatable shader properties to base values
 724   for (ShaderIter iter = mImpl->shaders.Begin(); iter != mImpl->shaders.End(); ++iter)
 725   {
 726     (*iter)->ResetToBaseValues( bufferIndex );
 727   }
 728 }
 729
 730 bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds )
 731 {
 732   bool gestureUpdated( false );
 733
 734   // constrain gestures... (in construction order)
 735   GestureContainer& gestures = mImpl->gestures;
 736
 737   for ( GestureIter iter = gestures.Begin(), endIter = gestures.End(); iter != endIter; ++iter )
 738   {
 739     PanGesture& gesture = **iter;
 740     gesture.ResetToBaseValues( bufferIndex ); // Needs to be done every time as gesture data is written directly to an update-buffer rather than via a message
 741     gestureUpdated |= gesture.UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 742   }
 743
 744   return gestureUpdated;
 745 }
 746
 747 void UpdateManager::Animate( BufferIndex bufferIndex, float elapsedSeconds )
 748 {
 749   AnimationContainer &animations = mImpl->animations;
 750   AnimationIter iter = animations.Begin();
 751   bool animationLooped = false;
 752   while ( iter != animations.End() )
 753   {
 754     Animation* animation = *iter;
 755     bool finished = false;
 756     bool looped = false;
 757     animation->Update( bufferIndex, elapsedSeconds, looped, finished );
 758
 759     mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || finished;
 760     animationLooped = animationLooped || looped;
 761
 762     // Remove animations that had been destroyed but were still waiting for an update
 763     if (animation->GetState() == Animation::Destroyed)
 764     {
 765       iter = animations.Erase(iter);
 766     }
 767     else
 768     {
 769       ++iter;
 770     }
 771   }
 772
 773   // queue the notification on finished or looped (to update loop count)
 774   if ( mImpl->animationFinishedDuringUpdate || animationLooped )
 775   {
 776     // The application should be notified by NotificationManager, in another thread
 777     mImpl->notificationManager.QueueCompleteNotification( &mImpl->animationFinishedNotifier );
 778   }
 779 }
 780
 781 void UpdateManager::ConstrainCustomObjects( BufferIndex bufferIndex )
 782 {
 783   //Constrain custom objects (in construction order)
 784   OwnerContainer< PropertyOwner* >& customObjects = mImpl->customObjects;
 785   const OwnerContainer< PropertyOwner* >::Iterator endIter = customObjects.End();
 786   for ( OwnerContainer< PropertyOwner* >::Iterator iter = customObjects.Begin(); endIter != iter; ++iter )
 787   {
 788     PropertyOwner& object = **iter;
 789     ConstrainPropertyOwner( object, bufferIndex );
 790   }
 791 }
 792
 793 void UpdateManager::ConstrainRenderTasks( BufferIndex bufferIndex )
 794 {
 795   // Constrain system-level render-tasks
 796   const RenderTaskList::RenderTaskContainer& systemLevelTasks = mImpl->systemLevelTaskList.GetTasks();
 797   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = systemLevelTasks.Begin(); iter != systemLevelTasks.End(); ++iter )
 798   {
 799     RenderTask& task = **iter;
 800     ConstrainPropertyOwner( task, bufferIndex );
 801   }
 802
 803   // Constrain render-tasks
 804   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
 805   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(); iter != tasks.End(); ++iter )
 806   {
 807     RenderTask& task = **iter;
 808     ConstrainPropertyOwner( task, bufferIndex );
 809   }
 810 }
 811
 812 void UpdateManager::ConstrainShaders( BufferIndex bufferIndex )
 813 {
 814   // constrain shaders... (in construction order)
 815   ShaderContainer& shaders = mImpl->shaders;
 816   for ( ShaderIter iter = shaders.Begin(); iter != shaders.End(); ++iter )
 817   {
 818     Shader& shader = **iter;
 819     ConstrainPropertyOwner( shader, bufferIndex );
 820   }
 821 }
 822
 823 void UpdateManager::ProcessPropertyNotifications( BufferIndex bufferIndex )
 824 {
 825   PropertyNotificationContainer &notifications = mImpl->propertyNotifications;
 826   PropertyNotificationIter iter = notifications.Begin();
 827
 828   while ( iter != notifications.End() )
 829   {
 830     PropertyNotification* notification = *iter;
 831     bool valid = notification->Check( bufferIndex );
 832     if(valid)
 833     {
 834       mImpl->notificationManager.QueueMessage( PropertyChangedMessage( mImpl->propertyNotifier, notification, notification->GetValidity() ) );
 835     }
 836     ++iter;
 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     //Clear the lists of renderers from the previous update
 958     for( size_t i(0); i<mImpl->sortedLayers.size(); ++i )
 959     {
 960       mImpl->sortedLayers[i]->ClearRenderables();
 961     }
 962
 963     for( size_t i(0); i<mImpl->systemLevelSortedLayers.size(); ++i )
 964     {
 965       mImpl->systemLevelSortedLayers[i]->ClearRenderables();
 966     }
 967
 968     //Update node hierarchy, apply constraints and perform sorting / culling.
 969     //This will populate each Layer with a list of renderers which are ready.
 970     UpdateNodes( bufferIndex );
 971
 972     //Apply constraints to RenderTasks, shaders
 973     ConstrainRenderTasks( bufferIndex );
 974     ConstrainShaders( bufferIndex );
 975
 976     //Update renderers and apply constraints
 977     UpdateRenderers( bufferIndex );
 978
 979     //Update the trnasformations of all the nodes
 980     mImpl->transformManager.Update();
 981
 982     //Process Property Notifications
 983     ProcessPropertyNotifications( bufferIndex );
 984
 985     //Update geometry batcher
 986     mImpl->geometryBatcher.Update( 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->geometryBatcher,
1000                                         mImpl->renderInstructions );
1001
1002       // Process the system-level RenderTasks last
1003       if ( NULL != mImpl->systemLevelRoot )
1004       {
1005         mImpl->renderTaskProcessor.Process( bufferIndex,
1006                                           mImpl->systemLevelTaskList,
1007                                           *mImpl->systemLevelRoot,
1008                                           mImpl->systemLevelSortedLayers,
1009                                           mImpl->geometryBatcher,
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