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

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/update/manager/update-manager.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/common/stage.h>
  23 #include <dali/devel-api/common/set-wrapper.h>
  24 #include <dali/devel-api/common/owner-container.h>
  25 #include <dali/devel-api/threading/mutex.h>
  26
  27 #include <dali/integration-api/core.h>
  28 #include <dali/integration-api/render-controller.h>
  29 #include <dali/internal/common/shader-data.h>
  30 #include <dali/integration-api/debug.h>
  31
  32 #include <dali/internal/common/core-impl.h>
  33 #include <dali/internal/common/message.h>
  34
  35 #include <dali/internal/event/common/notification-manager.h>
  36 #include <dali/internal/event/common/property-notification-impl.h>
  37 #include <dali/internal/event/common/property-notifier.h>
  38 #include <dali/internal/event/effects/shader-factory.h>
  39
  40 #include <dali/internal/update/animation/scene-graph-animator.h>
  41 #include <dali/internal/update/animation/scene-graph-animation.h>
  42 #include <dali/internal/update/common/discard-queue.h>
  43 #include <dali/internal/update/common/scene-graph-buffers.h>
  44 #include <dali/internal/update/controllers/render-message-dispatcher.h>
  45 #include <dali/internal/update/controllers/scene-controller-impl.h>
  46 #include <dali/internal/update/gestures/scene-graph-pan-gesture.h>
  47 #include <dali/internal/update/manager/object-owner-container.h>
  48 #include <dali/internal/update/manager/process-render-tasks.h>
  49 #include <dali/internal/update/manager/sorted-layers.h>
  50 #include <dali/internal/update/manager/update-algorithms.h>
  51 #include <dali/internal/update/manager/update-manager-debug.h>
  52 #include <dali/internal/update/manager/transform-manager.h>
  53 #include <dali/internal/update/nodes/node.h>
  54 #include <dali/internal/update/nodes/scene-graph-layer.h>
  55 #include <dali/internal/update/queue/update-message-queue.h>
  56 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
  57 #include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
  58 #include <dali/internal/update/rendering/scene-graph-texture-set.h>
  59 #include <dali/internal/update/resources/resource-manager.h>
  60 #include <dali/internal/update/touch/touch-resampler.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-sampler.h>
  68 #include <dali/internal/update/render-tasks/scene-graph-camera.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         TextureCache& textureCache,
 134         TouchResampler& touchResampler,
 135         SceneGraphBuffers& sceneGraphBuffers )
 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     touchResampler( touchResampler ),
 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     renderSortingHelper(),
 164     renderTaskWaiting( false )
 165   {
 166     sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue );
 167
 168     renderers.SetSceneController( *sceneController );
 169
 170     // create first 'dummy' node
 171     nodes.PushBack(0u);
 172   }
 173
 174   ~Impl()
 175   {
 176     // Disconnect render tasks from nodes, before destroying the nodes
 177     RenderTaskList::RenderTaskContainer& tasks = taskList.GetTasks();
 178     for (RenderTaskList::RenderTaskContainer::Iterator iter = tasks.Begin(); iter != tasks.End(); ++iter)
 179     {
 180       (*iter)->SetSourceNode( NULL );
 181     }
 182     // ..repeat for system level RenderTasks
 183     RenderTaskList::RenderTaskContainer& systemLevelTasks = systemLevelTaskList.GetTasks();
 184     for (RenderTaskList::RenderTaskContainer::Iterator iter = systemLevelTasks.Begin(); iter != systemLevelTasks.End(); ++iter)
 185     {
 186       (*iter)->SetSourceNode( NULL );
 187     }
 188
 189     // UpdateManager owns the Nodes
 190     Vector<Node*>::Iterator iter = nodes.Begin()+1;
 191     Vector<Node*>::Iterator endIter = nodes.End();
 192     for(;iter!=endIter;++iter)
 193     {
 194       (*iter)->OnDestroy();
 195       delete(*iter);
 196     }
 197
 198     // If there is root, reset it, otherwise do nothing as rendering was never started
 199     if( root )
 200     {
 201       root->OnDestroy();
 202
 203       delete root;
 204       root = NULL;
 205     }
 206
 207     if( systemLevelRoot )
 208     {
 209       systemLevelRoot->OnDestroy();
 210
 211       delete systemLevelRoot;
 212       systemLevelRoot = NULL;
 213     }
 214
 215     delete sceneController;
 216   }
 217
 218   SceneGraphBuffers                   sceneGraphBuffers;             ///< Used to keep track of which buffers are being written or read
 219   RenderMessageDispatcher             renderMessageDispatcher;       ///< Used for passing messages to the render-thread
 220   NotificationManager&                notificationManager;           ///< Queues notification messages for the event-thread.
 221   TransformManager                    transformManager;              ///< Used to update the transformation matrices of the nodes
 222   CompleteNotificationInterface&      animationFinishedNotifier;     ///< Provides notification to applications when animations are finished.
 223   PropertyNotifier&                   propertyNotifier;              ///< Provides notification to applications when properties are modified.
 224   ShaderSaver*                        shaderSaver;                   ///< Saves shader binaries.
 225   ResourceManager&                    resourceManager;               ///< resource manager
 226   DiscardQueue&                       discardQueue;                  ///< Nodes are added here when disconnected from the scene-graph.
 227   RenderController&                   renderController;              ///< render controller
 228   SceneControllerImpl*                sceneController;               ///< scene controller
 229   RenderManager&                      renderManager;                 ///< This is responsible for rendering the results of each "update"
 230   RenderQueue&                        renderQueue;                   ///< Used to queue messages for the next render
 231   RenderInstructionContainer&         renderInstructions;            ///< Used to prepare the render instructions
 232   TouchResampler&                     touchResampler;                ///< Used to resample touch events on every update.
 233
 234   Vector4                             backgroundColor;               ///< The glClear color used at the beginning of each frame.
 235
 236   RenderTaskList                      taskList;                      ///< The list of scene graph render-tasks
 237   RenderTaskList                      systemLevelTaskList;           ///< Separate render-tasks for system-level content
 238
 239   Layer*                              root;                          ///< The root node (root is a layer)
 240   Layer*                              systemLevelRoot;               ///< A separate root-node for system-level content
 241
 242   Vector<Node*>                       nodes;                         ///< A container of all instantiated nodes
 243
 244   SortedLayerPointers                 sortedLayers;                  ///< A container of Layer pointers sorted by depth
 245   SortedLayerPointers                 systemLevelSortedLayers;       ///< A separate container of system-level Layers
 246
 247   OwnerContainer< Camera* >           cameras;                       ///< A container of cameras
 248   OwnerContainer< PropertyOwner* >    customObjects;                 ///< A container of owned objects (with custom properties)
 249
 250   AnimationContainer                  animations;                    ///< A container of owned animations
 251   PropertyNotificationContainer       propertyNotifications;         ///< A container of owner property notifications.
 252
 253   ObjectOwnerContainer<Renderer>      renderers;
 254   TextureSetContainer                 textureSets;                     ///< A container of texture sets
 255
 256   ShaderContainer                     shaders;                       ///< A container of owned shaders
 257
 258   MessageQueue                        messageQueue;                  ///< The messages queued from the event-thread
 259   ShaderDataBinaryQueue               renderCompiledShaders;         ///< Shaders compiled on Render thread are inserted here for update thread to pass on to event thread.
 260   ShaderDataBinaryQueue               updateCompiledShaders;         ///< Shaders to be sent from Update to Event
 261   Mutex                               compiledShaderMutex;           ///< lock to ensure no corruption on the renderCompiledShaders
 262
 263   float                               keepRenderingSeconds;          ///< Set via Dali::Stage::KeepRendering
 264   bool                                animationFinishedDuringUpdate; ///< Flag whether any animations finished during the Update()
 265
 266   int                                 nodeDirtyFlags;                ///< cumulative node dirty flags from previous frame
 267   bool                                previousUpdateScene;           ///< True if the scene was updated in the previous frame (otherwise it was optimized out)
 268
 269   int                                 frameCounter;                  ///< Frame counter used in debugging to choose which frame to debug and which to ignore.
 270   RendererSortingHelper               renderSortingHelper;           ///< helper used to sort transparent renderers
 271
 272   GestureContainer                    gestures;                      ///< A container of owned gesture detectors
 273   bool                                renderTaskWaiting;             ///< A REFRESH_ONCE render task is waiting to be rendered
 274 };
 275
 276 UpdateManager::UpdateManager( NotificationManager& notificationManager,
 277                               CompleteNotificationInterface& animationFinishedNotifier,
 278                               PropertyNotifier& propertyNotifier,
 279                               ResourceManager& resourceManager,
 280                               DiscardQueue& discardQueue,
 281                               RenderController& controller,
 282                               RenderManager& renderManager,
 283                               RenderQueue& renderQueue,
 284                               TextureCache& textureCache,
 285                               TouchResampler& touchResampler )
 286   : mImpl(NULL)
 287 {
 288   mImpl = new Impl( notificationManager,
 289                     animationFinishedNotifier,
 290                     propertyNotifier,
 291                     resourceManager,
 292                     discardQueue,
 293                     controller,
 294                     renderManager,
 295                     renderQueue,
 296                     textureCache,
 297                     touchResampler,
 298                     mSceneGraphBuffers );
 299
 300   textureCache.SetBufferIndices( &mSceneGraphBuffers );
 301 }
 302
 303 UpdateManager::~UpdateManager()
 304 {
 305   delete mImpl;
 306 }
 307
 308 void UpdateManager::InstallRoot( SceneGraph::Layer* layer, bool systemLevel )
 309 {
 310   DALI_ASSERT_DEBUG( layer->IsLayer() );
 311   DALI_ASSERT_DEBUG( layer->GetParent() == NULL);
 312
 313   if ( !systemLevel )
 314   {
 315     DALI_ASSERT_DEBUG( mImpl->root == NULL && "Root Node already installed" );
 316     mImpl->root = layer;
 317     mImpl->root->CreateTransform( &mImpl->transformManager);
 318   }
 319   else
 320   {
 321     DALI_ASSERT_DEBUG( mImpl->systemLevelRoot == NULL && "System-level Root Node already installed" );
 322     mImpl->systemLevelRoot = layer;
 323     mImpl->systemLevelRoot->CreateTransform( &mImpl->transformManager);
 324   }
 325
 326   layer->SetRoot(true);
 327 }
 328
 329 void UpdateManager::AddNode( Node* node )
 330 {
 331   DALI_ASSERT_ALWAYS( NULL != node );
 332   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
 333
 334   // Nodes must be sorted by pointer
 335   Vector<Node*>::Iterator begin = mImpl->nodes.Begin();
 336   for(Vector<Node*>::Iterator iter = mImpl->nodes.End()-1; iter >= begin; --iter)
 337   {
 338     if(node > (*iter))
 339     {
 340       mImpl->nodes.Insert((iter+1), node);
 341       node->CreateTransform( &mImpl->transformManager);
 342       break;
 343     }
 344   }
 345 }
 346
 347 void UpdateManager::ConnectNode( Node* parent, Node* node )
 348 {
 349   DALI_ASSERT_ALWAYS( NULL != parent );
 350   DALI_ASSERT_ALWAYS( NULL != node );
 351   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
 352
 353   parent->ConnectChild( node );
 354 }
 355
 356 void UpdateManager::DisconnectNode( Node* node )
 357 {
 358   Node* parent = node->GetParent();
 359   DALI_ASSERT_ALWAYS( NULL != parent );
 360   parent->SetDirtyFlag( ChildDeletedFlag ); // make parent dirty so that render items dont get reused
 361
 362   parent->DisconnectChild( mSceneGraphBuffers.GetUpdateBufferIndex(), *node );
 363 }
 364
 365 void UpdateManager::DestroyNode( Node* node )
 366 {
 367   DALI_ASSERT_ALWAYS( NULL != node );
 368   DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should have been disconnected
 369
 370   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
 371   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
 372   for(;iter!=endIter;++iter)
 373   {
 374     if((*iter) == node)
 375     {
 376       mImpl->nodes.Erase(iter);
 377       break;
 378     }
 379   }
 380
 381   mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), node );
 382
 383   // Notify the Node about impending destruction
 384   node->OnDestroy();
 385 }
 386
 387 void UpdateManager::AddCamera( Camera* camera )
 388 {
 389   DALI_ASSERT_DEBUG( camera != NULL );
 390
 391   mImpl->cameras.PushBack( camera ); // takes ownership
 392 }
 393
 394 void UpdateManager::RemoveCamera( const Camera* camera )
 395 {
 396   // Find the camera
 397   OwnerContainer<Camera*>::Iterator iter = mImpl->cameras.Begin();
 398   OwnerContainer<Camera*>::ConstIterator end = mImpl->cameras.End();
 399   for ( ; iter != end; ++iter )
 400   {
 401     Camera* value = *iter;
 402     if ( camera == value )
 403     {
 404       // Transfer ownership to the discard queue
 405       mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), mImpl->cameras.Release( iter ) );
 406
 407       return;
 408     }
 409   }
 410
 411 }
 412
 413 void UpdateManager::AddObject( PropertyOwner* object )
 414 {
 415   DALI_ASSERT_DEBUG( NULL != object );
 416
 417   mImpl->customObjects.PushBack( object );
 418 }
 419
 420 void UpdateManager::RemoveObject( PropertyOwner* object )
 421 {
 422   DALI_ASSERT_DEBUG( NULL != object );
 423
 424   OwnerContainer< PropertyOwner* >& customObjects = mImpl->customObjects;
 425
 426   // Find the object and destroy it
 427   for ( OwnerContainer< PropertyOwner* >::Iterator iter = customObjects.Begin(); iter != customObjects.End(); ++iter )
 428   {
 429     PropertyOwner* current = *iter;
 430     if ( current == object )
 431     {
 432       customObjects.Erase( iter );
 433       return;
 434     }
 435   }
 436
 437   // Should not reach here
 438   DALI_ASSERT_DEBUG(false);
 439 }
 440
 441 void UpdateManager::AddAnimation( Animation* animation )
 442 {
 443   mImpl->animations.PushBack( animation );
 444 }
 445
 446 void UpdateManager::StopAnimation( Animation* animation )
 447 {
 448   DALI_ASSERT_DEBUG( animation && "NULL animation called to stop" );
 449
 450   bool animationFinished = animation->Stop( mSceneGraphBuffers.GetUpdateBufferIndex() );
 451
 452   mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || animationFinished;
 453 }
 454
 455 void UpdateManager::RemoveAnimation( Animation* animation )
 456 {
 457   DALI_ASSERT_DEBUG( animation && "NULL animation called to remove" );
 458
 459   animation->OnDestroy( mSceneGraphBuffers.GetUpdateBufferIndex() );
 460
 461   DALI_ASSERT_DEBUG( animation->GetState() == Animation::Destroyed );
 462 }
 463
 464 bool UpdateManager::IsAnimationRunning() const
 465 {
 466   bool isRunning(false);
 467   AnimationContainer& animations = mImpl->animations;
 468
 469   // Find any animation that isn't stopped or paused
 470
 471   const AnimationIter endIter = animations.End();
 472   for ( AnimationIter iter = animations.Begin(); !isRunning && iter != endIter; ++iter )
 473   {
 474     const Animation::State state = (*iter)->GetState();
 475
 476     if (state != Animation::Stopped &&
 477         state != Animation::Paused)
 478     {
 479       isRunning = true;
 480     }
 481   }
 482
 483   return isRunning;
 484 }
 485
 486 void UpdateManager::AddPropertyNotification( PropertyNotification* propertyNotification )
 487 {
 488   mImpl->propertyNotifications.PushBack( propertyNotification );
 489 }
 490
 491 void UpdateManager::RemovePropertyNotification( PropertyNotification* propertyNotification )
 492 {
 493   PropertyNotificationContainer &propertyNotifications = mImpl->propertyNotifications;
 494   PropertyNotificationIter iter = propertyNotifications.Begin();
 495
 496   while ( iter != propertyNotifications.End() )
 497   {
 498     if( *iter == propertyNotification )
 499     {
 500       propertyNotifications.Erase(iter);
 501       break;
 502     }
 503     ++iter;
 504   }
 505 }
 506
 507 void UpdateManager::PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode )
 508 {
 509   DALI_ASSERT_DEBUG( propertyNotification && "propertyNotification scene graph object missing" );
 510   propertyNotification->SetNotifyMode( notifyMode );
 511 }
 512
 513 ObjectOwnerContainer<Renderer>& UpdateManager::GetRendererOwner()
 514 {
 515   return mImpl->renderers;
 516 }
 517
 518 void UpdateManager::AddShader( Shader* shader )
 519 {
 520   DALI_ASSERT_DEBUG( NULL != shader );
 521
 522   if( mImpl->shaders.Count() == 0 )
 523   {
 524     // the first added shader becomes our default shader
 525     // Construct message in the render queue memory; note that delete should not be called on the return value
 526     typedef MessageValue1< RenderManager, Shader* > DerivedType;
 527
 528     // Reserve some memory inside the render queue
 529     unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 530
 531     // Construct message in the render queue memory; note that delete should not be called on the return value
 532     new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetDefaultShader, shader );
 533   }
 534
 535   mImpl->shaders.PushBack( shader );
 536 }
 537
 538 void UpdateManager::RemoveShader( Shader* shader )
 539 {
 540   DALI_ASSERT_DEBUG(shader != NULL);
 541
 542   ShaderContainer& shaders = mImpl->shaders;
 543
 544   // Find the shader and destroy it
 545   for ( ShaderIter iter = shaders.Begin(); iter != shaders.End(); ++iter )
 546   {
 547     Shader& current = **iter;
 548     if ( &current == shader )
 549     {
 550       // Transfer ownership to the discard queue
 551       // This keeps the shader alive, until the render-thread has finished with it
 552       mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), shaders.Release( iter ) );
 553
 554       return;
 555     }
 556   }
 557   // Should not reach here
 558   DALI_ASSERT_DEBUG(false);
 559 }
 560
 561 void UpdateManager::SetShaderProgram( Shader* shader,
 562                                       Internal::ShaderDataPtr shaderData, bool modifiesGeometry )
 563 {
 564   if( shaderData )
 565   {
 566
 567     typedef MessageValue3< Shader, Internal::ShaderDataPtr, ProgramCache*, bool> DerivedType;
 568
 569     // Reserve some memory inside the render queue
 570     unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 571
 572     // Construct message in the render queue memory; note that delete should not be called on the return value
 573     new (slot) DerivedType( shader, &Shader::SetProgram, shaderData, mImpl->renderManager.GetProgramCache(), modifiesGeometry );
 574   }
 575 }
 576
 577 void UpdateManager::SaveBinary( Internal::ShaderDataPtr shaderData )
 578 {
 579   DALI_ASSERT_DEBUG( shaderData && "No NULL shader data pointers please." );
 580   DALI_ASSERT_DEBUG( shaderData->GetBufferSize() > 0 && "Shader binary empty so nothing to save." );
 581   {
 582     // lock as update might be sending previously compiled shaders to event thread
 583     Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
 584     mImpl->renderCompiledShaders.push_back( shaderData );
 585   }
 586 }
 587
 588 RenderTaskList* UpdateManager::GetRenderTaskList( bool systemLevel )
 589 {
 590   if ( !systemLevel )
 591   {
 592     // copy the list, this is only likely to happen once in application life cycle
 593     return &(mImpl->taskList);
 594   }
 595   else
 596   {
 597     // copy the list, this is only likely to happen once in application life cycle
 598     return &(mImpl->systemLevelTaskList);
 599   }
 600 }
 601
 602 void UpdateManager::AddGesture( PanGesture* gesture )
 603 {
 604   DALI_ASSERT_DEBUG( NULL != gesture );
 605
 606   mImpl->gestures.PushBack( gesture );
 607 }
 608
 609 void UpdateManager::RemoveGesture( PanGesture* gesture )
 610 {
 611   DALI_ASSERT_DEBUG( gesture != NULL );
 612
 613   GestureContainer& gestures = mImpl->gestures;
 614
 615   // Find the gesture and destroy it
 616   for ( GestureIter iter = gestures.Begin(), endIter = gestures.End(); iter != endIter; ++iter )
 617   {
 618     PanGesture& current = **iter;
 619     if ( &current == gesture )
 620     {
 621       mImpl->gestures.Erase( iter );
 622       return;
 623     }
 624   }
 625   // Should not reach here
 626   DALI_ASSERT_DEBUG(false);
 627 }
 628
 629 void UpdateManager::AddTextureSet( TextureSet* textureSet )
 630 {
 631   DALI_ASSERT_DEBUG( NULL != textureSet );
 632   mImpl->textureSets.PushBack( textureSet );
 633 }
 634
 635 void UpdateManager::RemoveTextureSet( TextureSet* textureSet )
 636 {
 637   DALI_ASSERT_DEBUG(textureSet != NULL);
 638   size_t textureSetCount( mImpl->textureSets.Size() );
 639   for( size_t i(0); i<textureSetCount; ++i )
 640   {
 641     if( textureSet == mImpl->textureSets[i] )
 642     {
 643       mImpl->textureSets.Remove( mImpl->textureSets.Begin() + i );
 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     if( rendererContainer[i]->IsReferenced() )
 877     {
 878       rendererContainer[i]->PrepareRender( bufferIndex );
 879     }
 880   }
 881 }
 882
 883 void UpdateManager::UpdateNodes( BufferIndex bufferIndex )
 884 {
 885   mImpl->nodeDirtyFlags = NothingFlag;
 886
 887   if ( !mImpl->root )
 888   {
 889     return;
 890   }
 891
 892   // Prepare resources, update shaders, for each node
 893   // And add the renderers to the sorted layers. Start from root, which is also a layer
 894   mImpl->nodeDirtyFlags = UpdateNodeTree( *( mImpl->root ),
 895                                           bufferIndex,
 896                                           mImpl->resourceManager,
 897                                           mImpl->renderQueue );
 898
 899   if ( mImpl->systemLevelRoot )
 900   {
 901     mImpl->nodeDirtyFlags |= UpdateNodeTree( *( mImpl->systemLevelRoot ),
 902                                              bufferIndex,
 903                                              mImpl->resourceManager,
 904                                              mImpl->renderQueue );
 905   }
 906 }
 907
 908 unsigned int UpdateManager::Update( float elapsedSeconds,
 909                                     unsigned int lastVSyncTimeMilliseconds,
 910                                     unsigned int nextVSyncTimeMilliseconds )
 911 {
 912   const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
 913
 914   //Clear nodes/resources which were previously discarded
 915   mImpl->discardQueue.Clear( bufferIndex );
 916
 917   //Grab any loaded resources
 918   bool resourceChanged = mImpl->resourceManager.UpdateCache( bufferIndex );
 919
 920   //Process Touches & Gestures
 921   mImpl->touchResampler.Update();
 922   const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 923
 924   const bool updateScene =                                  // The scene-graph requires an update if..
 925       (mImpl->nodeDirtyFlags & RenderableUpdateFlags) ||    // ..nodes were dirty in previous frame OR
 926       IsAnimationRunning()                            ||    // ..at least one animation is running OR
 927       mImpl->messageQueue.IsSceneUpdateRequired()     ||    // ..a message that modifies the scene graph node tree is queued OR
 928       resourceChanged                                 ||    // ..one or more resources were updated/changed OR
 929       gestureUpdated;                                       // ..a gesture property was updated
 930
 931
 932   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 933   // values if the scene was updated in the previous frame.
 934   if( updateScene || mImpl->previousUpdateScene )
 935   {
 936     //Reset properties from the previous update
 937     ResetProperties( bufferIndex );
 938     mImpl->transformManager.ResetToBaseValue();
 939   }
 940
 941   //Process the queued scene messages
 942   mImpl->messageQueue.ProcessMessages( bufferIndex );
 943
 944   //Post Process Ids of resources updated by renderer
 945   mImpl->resourceManager.PostProcessResources( bufferIndex );
 946
 947   //Forward compiled shader programs to event thread for saving
 948   ForwardCompiledShadersToEventThread();
 949
 950   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 951   // renderer lists if the scene was updated in the previous frame.
 952   // We should not start skipping update steps or reusing lists until there has been two frames where nothing changes
 953   if( updateScene || mImpl->previousUpdateScene )
 954   {
 955     //Animate
 956     Animate( bufferIndex, elapsedSeconds );
 957
 958     //Constraint custom objects
 959     ConstrainCustomObjects( bufferIndex );
 960
 961     //Prepare texture sets and apply constraints to them
 962     PrepareTextureSets( bufferIndex );
 963
 964     //Clear the lists of renderers from the previous update
 965     for( size_t i(0); i<mImpl->sortedLayers.size(); ++i )
 966     {
 967       mImpl->sortedLayers[i]->ClearRenderables();
 968     }
 969
 970     for( size_t i(0); i<mImpl->systemLevelSortedLayers.size(); ++i )
 971     {
 972       mImpl->systemLevelSortedLayers[i]->ClearRenderables();
 973     }
 974
 975     //Update node hierarchy, apply constraints and perform sorting / culling.
 976     //This will populate each Layer with a list of renderers which are ready.
 977     UpdateNodes( bufferIndex );
 978
 979     //Apply constraints to RenderTasks, shaders
 980     ConstrainRenderTasks( bufferIndex );
 981     ConstrainShaders( bufferIndex );
 982
 983     //Update renderers and apply constraints
 984     UpdateRenderers( bufferIndex );
 985
 986     //Update the trnasformations of all the nodes
 987     mImpl->transformManager.Update();
 988
 989     //Process Property Notifications
 990     ProcessPropertyNotifications( bufferIndex );
 991
 992     //Process the RenderTasks; this creates the instructions for rendering the next frame.
 993     //reset the update buffer index and make sure there is enough room in the instruction container
 994     mImpl->renderInstructions.ResetAndReserve( bufferIndex,
 995                                                mImpl->taskList.GetTasks().Count() + mImpl->systemLevelTaskList.GetTasks().Count() );
 996
 997     if ( NULL != mImpl->root )
 998     {
 999       ProcessRenderTasks(  bufferIndex,
1000                            mImpl->taskList,
1001                            *mImpl->root,
1002                            mImpl->sortedLayers,
1003                            mImpl->renderSortingHelper,
1004                            mImpl->renderInstructions );
1005
1006       // Process the system-level RenderTasks last
1007       if ( NULL != mImpl->systemLevelRoot )
1008       {
1009         ProcessRenderTasks(  bufferIndex,
1010                              mImpl->systemLevelTaskList,
1011                              *mImpl->systemLevelRoot,
1012                              mImpl->systemLevelSortedLayers,
1013                              mImpl->renderSortingHelper,
1014                              mImpl->renderInstructions );
1015       }
1016     }
1017   }
1018
1019   // check the countdown and notify (note, at the moment this is only done for normal tasks, not for systemlevel tasks)
1020   bool doRenderOnceNotify = false;
1021   mImpl->renderTaskWaiting = false;
1022   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
1023   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(), endIter = tasks.End();
1024         endIter != iter; ++iter )
1025   {
1026     RenderTask& renderTask(*(*iter));
1027
1028     renderTask.UpdateState();
1029
1030     if( renderTask.IsWaitingToRender() &&
1031         renderTask.ReadyToRender( bufferIndex ) /*avoid updating forever when source actor is off-stage*/ )
1032     {
1033       mImpl->renderTaskWaiting = true; // keep update/render threads alive
1034     }
1035
1036     if( renderTask.HasRendered() )
1037     {
1038       doRenderOnceNotify = true;
1039     }
1040   }
1041
1042   if( doRenderOnceNotify )
1043   {
1044     DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n");
1045     mImpl->notificationManager.QueueCompleteNotification( mImpl->taskList.GetCompleteNotificationInterface() );
1046   }
1047
1048   // Macro is undefined in release build.
1049   SNAPSHOT_NODE_LOGGING;
1050
1051   // A ResetProperties() may be required in the next frame
1052   mImpl->previousUpdateScene = updateScene;
1053
1054   // Check whether further updates are required
1055   unsigned int keepUpdating = KeepUpdatingCheck( elapsedSeconds );
1056
1057   // tell the update manager that we're done so the queue can be given to event thread
1058   mImpl->notificationManager.UpdateCompleted();
1059
1060   // The update has finished; swap the double-buffering indices
1061   mSceneGraphBuffers.Swap();
1062
1063   return keepUpdating;
1064 }
1065
1066 unsigned int UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const
1067 {
1068   // Update the duration set via Stage::KeepRendering()
1069   if ( mImpl->keepRenderingSeconds > 0.0f )
1070   {
1071     mImpl->keepRenderingSeconds -= elapsedSeconds;
1072   }
1073
1074   unsigned int keepUpdatingRequest = KeepUpdating::NOT_REQUESTED;
1075
1076   // If Stage::KeepRendering() has been called, then continue until the duration has elapsed.
1077   // Keep updating until no messages are received and no animations are running.
1078   // If an animation has just finished, update at least once more for Discard end-actions.
1079   // No need to check for renderQueue as there is always a render after update and if that
1080   // render needs another update it will tell the adaptor to call update again
1081
1082   if ( mImpl->keepRenderingSeconds > 0.0f )
1083   {
1084     keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING;
1085   }
1086
1087   if ( IsAnimationRunning() ||
1088        mImpl->animationFinishedDuringUpdate )
1089   {
1090     keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING;
1091   }
1092
1093   if ( mImpl->renderTaskWaiting )
1094   {
1095     keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC;
1096   }
1097
1098   return keepUpdatingRequest;
1099 }
1100
1101 void UpdateManager::SetBackgroundColor( const Vector4& color )
1102 {
1103   typedef MessageValue1< RenderManager, Vector4 > DerivedType;
1104
1105   // Reserve some memory inside the render queue
1106   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1107
1108   // Construct message in the render queue memory; note that delete should not be called on the return value
1109   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetBackgroundColor, color );
1110 }
1111
1112 void UpdateManager::SetDefaultSurfaceRect( const Rect<int>& rect )
1113 {
1114   typedef MessageValue1< RenderManager, Rect<int> > DerivedType;
1115
1116   // Reserve some memory inside the render queue
1117   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1118
1119   // Construct message in the render queue memory; note that delete should not be called on the return value
1120   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceRect, rect );
1121 }
1122
1123 void UpdateManager::KeepRendering( float durationSeconds )
1124 {
1125   mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds );
1126 }
1127
1128 void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, bool systemLevel )
1129 {
1130   if ( !systemLevel )
1131   {
1132     // just copy the vector of pointers
1133     mImpl->sortedLayers = layers;
1134   }
1135   else
1136   {
1137     mImpl->systemLevelSortedLayers = layers;
1138   }
1139 }
1140
1141 void UpdateManager::SetShaderSaver( ShaderSaver& upstream )
1142 {
1143   mImpl->shaderSaver = &upstream;
1144 }
1145
1146 void UpdateManager::AddSampler( Render::Sampler* sampler )
1147 {
1148   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1149
1150   // Reserve some memory inside the render queue
1151   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1152
1153   // Construct message in the render queue memory; note that delete should not be called on the return value
1154   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddSampler, sampler );
1155 }
1156
1157 void UpdateManager::RemoveSampler( Render::Sampler* sampler )
1158 {
1159   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1160
1161   // Reserve some memory inside the render queue
1162   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1163
1164   // Construct message in the render queue memory; note that delete should not be called on the return value
1165   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveSampler, sampler );
1166 }
1167
1168 void UpdateManager::SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode )
1169 {
1170   typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
1171
1172   // Reserve some memory inside the render queue
1173   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1174
1175   // Construct message in the render queue memory; note that delete should not be called on the return value
1176   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
1177 }
1178
1179 void UpdateManager::SetWrapMode( Render::Sampler* sampler, unsigned int uWrapMode, unsigned int vWrapMode )
1180 {
1181   typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
1182
1183   // Reserve some memory inside the render queue
1184   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1185
1186   // Construct message in the render queue memory; note that delete should not be called on the return value
1187   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, uWrapMode, vWrapMode );
1188 }
1189
1190 void UpdateManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1191 {
1192   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1193
1194   // Reserve some memory inside the render queue
1195   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1196
1197   // Construct message in the render queue memory; note that delete should not be called on the return value
1198   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddPropertyBuffer, propertyBuffer );
1199 }
1200
1201 void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1202 {
1203   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1204
1205   // Reserve some memory inside the render queue
1206   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1207
1208   // Construct message in the render queue memory; note that delete should not be called on the return value
1209   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemovePropertyBuffer, propertyBuffer );
1210 }
1211
1212 void UpdateManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format )
1213 {
1214   typedef MessageValue2< RenderManager, Render::PropertyBuffer*, Render::PropertyBuffer::Format* > DerivedType;
1215
1216   // Reserve some memory inside the render queue
1217   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1218
1219   // Construct message in the render queue memory; note that delete should not be called on the return value
1220   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetPropertyBufferFormat, propertyBuffer, format );
1221 }
1222
1223 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data, size_t size )
1224 {
1225   typedef MessageValue3< RenderManager, Render::PropertyBuffer*, Dali::Vector<char>*, size_t > DerivedType;
1226
1227   // Reserve some memory inside the render queue
1228   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1229
1230   // Construct message in the render queue memory; note that delete should not be called on the return value
1231   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
1232 }
1233
1234 void UpdateManager::AddGeometry( Render::Geometry* geometry )
1235 {
1236   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1237
1238   // Reserve some memory inside the render queue
1239   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1240
1241   // Construct message in the render queue memory; note that delete should not be called on the return value
1242   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddGeometry, geometry );
1243 }
1244
1245 void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
1246 {
1247   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1248
1249   // Reserve some memory inside the render queue
1250   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1251
1252   // Construct message in the render queue memory; note that delete should not be called on the return value
1253   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveGeometry, geometry );
1254 }
1255
1256 void UpdateManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
1257 {
1258   typedef MessageValue2< RenderManager, Render::Geometry*, unsigned int > DerivedType;
1259
1260   // Reserve some memory inside the render queue
1261   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1262
1263   // Construct message in the render queue memory; note that delete should not be called on the return value
1264   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryType, geometry, geometryType );
1265 }
1266
1267 void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
1268 {
1269   typedef IndexBufferMessage< RenderManager > DerivedType;
1270
1271   // Reserve some memory inside the render queue
1272   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1273
1274   // Construct message in the render queue memory; note that delete should not be called on the return value
1275   new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
1276 }
1277
1278 void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1279 {
1280   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1281
1282   // Reserve some memory inside the render queue
1283   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1284
1285   // Construct message in the render queue memory; note that delete should not be called on the return value
1286   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveVertexBuffer, geometry, propertyBuffer );
1287 }
1288
1289 void UpdateManager::AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1290 {
1291   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1292
1293   // Reserve some memory inside the render queue
1294   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1295
1296   // Construct message in the render queue memory; note that delete should not be called on the return value
1297   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddVertexBuffer, geometry, propertyBuffer );
1298 }
1299
1300
1301 } // namespace SceneGraph
1302
1303 } // namespace Internal
1304
1305 } // namespace Dali