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

   1 /*
   2  * Copyright (c) 2015 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/node-attachments/scene-graph-camera-attachment.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/touch/touch-resampler.h>
  62
  63 #include <dali/internal/render/common/render-instruction-container.h>
  64 #include <dali/internal/render/common/render-manager.h>
  65 #include <dali/internal/render/queue/render-queue.h>
  66 #include <dali/internal/render/gl-resources/texture-cache.h>
  67 #include <dali/internal/render/shaders/scene-graph-shader.h>
  68 #include <dali/internal/render/renderers/render-sampler.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, textureCache );
 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     sceneController->GetTextureCache().SetBufferIndices(NULL); // TODO - Remove
 216     delete sceneController;
 217   }
 218
 219   SceneGraphBuffers                   sceneGraphBuffers;             ///< Used to keep track of which buffers are being written or read
 220   RenderMessageDispatcher             renderMessageDispatcher;       ///< Used for passing messages to the render-thread
 221   NotificationManager&                notificationManager;           ///< Queues notification messages for the event-thread.
 222   TransformManager                    transformManager;              ///< Used to update the transformation matrices of the nodes
 223   CompleteNotificationInterface&      animationFinishedNotifier;     ///< Provides notification to applications when animations are finished.
 224   PropertyNotifier&                   propertyNotifier;              ///< Provides notification to applications when properties are modified.
 225   ShaderSaver*                        shaderSaver;                   ///< Saves shader binaries.
 226   ResourceManager&                    resourceManager;               ///< resource manager
 227   DiscardQueue&                       discardQueue;                  ///< Nodes are added here when disconnected from the scene-graph.
 228   RenderController&                   renderController;              ///< render controller
 229   SceneControllerImpl*                sceneController;               ///< scene controller
 230   RenderManager&                      renderManager;                 ///< This is responsible for rendering the results of each "update"
 231   RenderQueue&                        renderQueue;                   ///< Used to queue messages for the next render
 232   RenderInstructionContainer&         renderInstructions;            ///< Used to prepare the render instructions
 233   TouchResampler&                     touchResampler;                ///< Used to resample touch events on every update.
 234
 235   Vector4                             backgroundColor;               ///< The glClear color used at the beginning of each frame.
 236
 237   RenderTaskList                      taskList;                      ///< The list of scene graph render-tasks
 238   RenderTaskList                      systemLevelTaskList;           ///< Separate render-tasks for system-level content
 239
 240   Layer*                              root;                          ///< The root node (root is a layer)
 241   Layer*                              systemLevelRoot;               ///< A separate root-node for system-level content
 242
 243   Vector<Node*>                       nodes;                         ///< A container of all instantiated nodes
 244
 245   SortedLayerPointers                 sortedLayers;                  ///< A container of Layer pointers sorted by depth
 246   SortedLayerPointers                 systemLevelSortedLayers;       ///< A separate container of system-level Layers
 247
 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 //@todo MESH_REWORK Extend to allow arbitrary scene objects to connect to each other
 388 void UpdateManager::AttachToNode( Node* node, NodeAttachment* attachment )
 389 {
 390   DALI_ASSERT_DEBUG( node != NULL );
 391   DALI_ASSERT_DEBUG( attachment != NULL );
 392
 393   // attach node to attachment first so that parent is known by the time attachment is connected
 394   node->Attach( *attachment ); // node takes ownership
 395 }
 396
 397 void UpdateManager::AddObject( PropertyOwner* object )
 398 {
 399   DALI_ASSERT_DEBUG( NULL != object );
 400
 401   mImpl->customObjects.PushBack( object );
 402 }
 403
 404 void UpdateManager::RemoveObject( PropertyOwner* object )
 405 {
 406   DALI_ASSERT_DEBUG( NULL != object );
 407
 408   OwnerContainer< PropertyOwner* >& customObjects = mImpl->customObjects;
 409
 410   // Find the object and destroy it
 411   for ( OwnerContainer< PropertyOwner* >::Iterator iter = customObjects.Begin(); iter != customObjects.End(); ++iter )
 412   {
 413     PropertyOwner* current = *iter;
 414     if ( current == object )
 415     {
 416       customObjects.Erase( iter );
 417       return;
 418     }
 419   }
 420
 421   // Should not reach here
 422   DALI_ASSERT_DEBUG(false);
 423 }
 424
 425 void UpdateManager::AddAnimation( Animation* animation )
 426 {
 427   mImpl->animations.PushBack( animation );
 428 }
 429
 430 void UpdateManager::StopAnimation( Animation* animation )
 431 {
 432   DALI_ASSERT_DEBUG( animation && "NULL animation called to stop" );
 433
 434   bool animationFinished = animation->Stop( mSceneGraphBuffers.GetUpdateBufferIndex() );
 435
 436   mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || animationFinished;
 437 }
 438
 439 void UpdateManager::RemoveAnimation( Animation* animation )
 440 {
 441   DALI_ASSERT_DEBUG( animation && "NULL animation called to remove" );
 442
 443   animation->OnDestroy( mSceneGraphBuffers.GetUpdateBufferIndex() );
 444
 445   DALI_ASSERT_DEBUG( animation->GetState() == Animation::Destroyed );
 446 }
 447
 448 bool UpdateManager::IsAnimationRunning() const
 449 {
 450   bool isRunning(false);
 451   AnimationContainer& animations = mImpl->animations;
 452
 453   // Find any animation that isn't stopped or paused
 454
 455   const AnimationIter endIter = animations.End();
 456   for ( AnimationIter iter = animations.Begin(); !isRunning && iter != endIter; ++iter )
 457   {
 458     const Animation::State state = (*iter)->GetState();
 459
 460     if (state != Animation::Stopped &&
 461         state != Animation::Paused)
 462     {
 463       isRunning = true;
 464     }
 465   }
 466
 467   return isRunning;
 468 }
 469
 470 void UpdateManager::AddPropertyNotification( PropertyNotification* propertyNotification )
 471 {
 472   mImpl->propertyNotifications.PushBack( propertyNotification );
 473 }
 474
 475 void UpdateManager::RemovePropertyNotification( PropertyNotification* propertyNotification )
 476 {
 477   PropertyNotificationContainer &propertyNotifications = mImpl->propertyNotifications;
 478   PropertyNotificationIter iter = propertyNotifications.Begin();
 479
 480   while ( iter != propertyNotifications.End() )
 481   {
 482     if( *iter == propertyNotification )
 483     {
 484       propertyNotifications.Erase(iter);
 485       break;
 486     }
 487     ++iter;
 488   }
 489 }
 490
 491 void UpdateManager::PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode )
 492 {
 493   DALI_ASSERT_DEBUG( propertyNotification && "propertyNotification scene graph object missing" );
 494   propertyNotification->SetNotifyMode( notifyMode );
 495 }
 496
 497 ObjectOwnerContainer<Renderer>& UpdateManager::GetRendererOwner()
 498 {
 499   return mImpl->renderers;
 500 }
 501
 502 void UpdateManager::AddShader( Shader* shader )
 503 {
 504   DALI_ASSERT_DEBUG( NULL != shader );
 505
 506   if( mImpl->shaders.Count() == 0 )
 507   {
 508     // the first added shader becomes our default shader
 509     // Construct message in the render queue memory; note that delete should not be called on the return value
 510     typedef MessageValue1< RenderManager, Shader* > DerivedType;
 511
 512     // Reserve some memory inside the render queue
 513     unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 514
 515     // Construct message in the render queue memory; note that delete should not be called on the return value
 516     new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetDefaultShader, shader );
 517   }
 518
 519   mImpl->shaders.PushBack( shader );
 520 }
 521
 522 void UpdateManager::RemoveShader( Shader* shader )
 523 {
 524   DALI_ASSERT_DEBUG(shader != NULL);
 525
 526   ShaderContainer& shaders = mImpl->shaders;
 527
 528   // Find the shader and destroy it
 529   for ( ShaderIter iter = shaders.Begin(); iter != shaders.End(); ++iter )
 530   {
 531     Shader& current = **iter;
 532     if ( &current == shader )
 533     {
 534       // Transfer ownership to the discard queue
 535       // This keeps the shader alive, until the render-thread has finished with it
 536       mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), shaders.Release( iter ) );
 537
 538       return;
 539     }
 540   }
 541   // Should not reach here
 542   DALI_ASSERT_DEBUG(false);
 543 }
 544
 545 void UpdateManager::SetShaderProgram( Shader* shader,
 546                                       Internal::ShaderDataPtr shaderData, bool modifiesGeometry )
 547 {
 548   if( shaderData )
 549   {
 550
 551     typedef MessageValue3< Shader, Internal::ShaderDataPtr, ProgramCache*, bool> DerivedType;
 552
 553     // Reserve some memory inside the render queue
 554     unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 555
 556     // Construct message in the render queue memory; note that delete should not be called on the return value
 557     new (slot) DerivedType( shader, &Shader::SetProgram, shaderData, mImpl->renderManager.GetProgramCache(), modifiesGeometry );
 558   }
 559 }
 560
 561 void UpdateManager::SaveBinary( Internal::ShaderDataPtr shaderData )
 562 {
 563   DALI_ASSERT_DEBUG( shaderData && "No NULL shader data pointers please." );
 564   DALI_ASSERT_DEBUG( shaderData->GetBufferSize() > 0 && "Shader binary empty so nothing to save." );
 565   {
 566     // lock as update might be sending previously compiled shaders to event thread
 567     Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
 568     mImpl->renderCompiledShaders.push_back( shaderData );
 569   }
 570 }
 571
 572 RenderTaskList* UpdateManager::GetRenderTaskList( bool systemLevel )
 573 {
 574   if ( !systemLevel )
 575   {
 576     // copy the list, this is only likely to happen once in application life cycle
 577     return &(mImpl->taskList);
 578   }
 579   else
 580   {
 581     // copy the list, this is only likely to happen once in application life cycle
 582     return &(mImpl->systemLevelTaskList);
 583   }
 584 }
 585
 586 void UpdateManager::AddGesture( PanGesture* gesture )
 587 {
 588   DALI_ASSERT_DEBUG( NULL != gesture );
 589
 590   mImpl->gestures.PushBack( gesture );
 591 }
 592
 593 void UpdateManager::RemoveGesture( PanGesture* gesture )
 594 {
 595   DALI_ASSERT_DEBUG( gesture != NULL );
 596
 597   GestureContainer& gestures = mImpl->gestures;
 598
 599   // Find the gesture and destroy it
 600   for ( GestureIter iter = gestures.Begin(), endIter = gestures.End(); iter != endIter; ++iter )
 601   {
 602     PanGesture& current = **iter;
 603     if ( &current == gesture )
 604     {
 605       mImpl->gestures.Erase( iter );
 606       return;
 607     }
 608   }
 609   // Should not reach here
 610   DALI_ASSERT_DEBUG(false);
 611 }
 612
 613 void UpdateManager::AddTextureSet( TextureSet* textureSet )
 614 {
 615   DALI_ASSERT_DEBUG( NULL != textureSet );
 616   mImpl->textureSets.PushBack( textureSet );
 617 }
 618
 619 void UpdateManager::RemoveTextureSet( TextureSet* textureSet )
 620 {
 621   DALI_ASSERT_DEBUG(textureSet != NULL);
 622   size_t textureSetCount( mImpl->textureSets.Size() );
 623   for( size_t i(0); i<textureSetCount; ++i )
 624   {
 625     if( textureSet == mImpl->textureSets[i] )
 626     {
 627       mImpl->textureSets.Remove( mImpl->textureSets.Begin() + i );
 628       return;
 629     }
 630   }
 631 }
 632
 633 unsigned int* UpdateManager::ReserveMessageSlot( std::size_t size, bool updateScene )
 634 {
 635   return mImpl->messageQueue.ReserveMessageSlot( size, updateScene );
 636 }
 637
 638 void UpdateManager::EventProcessingStarted()
 639 {
 640   mImpl->messageQueue.EventProcessingStarted();
 641 }
 642
 643 bool UpdateManager::FlushQueue()
 644 {
 645   return mImpl->messageQueue.FlushQueue();
 646 }
 647
 648 void UpdateManager::ResetProperties( BufferIndex bufferIndex )
 649 {
 650   // Clear the "animations finished" flag; This should be set if any (previously playing) animation is stopped
 651   mImpl->animationFinishedDuringUpdate = false;
 652
 653   // Animated properties have to be reset to their original value each frame
 654
 655   // Reset root properties
 656   if ( mImpl->root )
 657   {
 658     mImpl->root->ResetToBaseValues( bufferIndex );
 659   }
 660   if ( mImpl->systemLevelRoot )
 661   {
 662     mImpl->systemLevelRoot->ResetToBaseValues( bufferIndex );
 663   }
 664
 665   // Reset all the nodes
 666   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
 667   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
 668   for(;iter != endIter; ++iter)
 669   {
 670     (*iter)->ResetToBaseValues( bufferIndex );
 671   }
 672
 673   // Reset system-level render-task list properties to base values
 674   const RenderTaskList::RenderTaskContainer& systemLevelTasks = mImpl->systemLevelTaskList.GetTasks();
 675
 676   for (RenderTaskList::RenderTaskContainer::ConstIterator iter = systemLevelTasks.Begin(); iter != systemLevelTasks.End(); ++iter)
 677   {
 678     (*iter)->ResetToBaseValues( bufferIndex );
 679   }
 680
 681   // Reset render-task list properties to base values.
 682   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
 683
 684   for (RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(); iter != tasks.End(); ++iter)
 685   {
 686     (*iter)->ResetToBaseValues( bufferIndex );
 687   }
 688
 689   // Reset custom object properties to base values
 690   for (OwnerContainer<PropertyOwner*>::Iterator iter = mImpl->customObjects.Begin(); iter != mImpl->customObjects.End(); ++iter)
 691   {
 692     (*iter)->ResetToBaseValues( bufferIndex );
 693   }
 694
 695   mImpl->renderers.ResetToBaseValues( bufferIndex );
 696
 697   // Reset animatable shader properties to base values
 698   for (ShaderIter iter = mImpl->shaders.Begin(); iter != mImpl->shaders.End(); ++iter)
 699   {
 700     (*iter)->ResetToBaseValues( bufferIndex );
 701   }
 702 }
 703
 704 bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds )
 705 {
 706   bool gestureUpdated( false );
 707
 708   // constrain gestures... (in construction order)
 709   GestureContainer& gestures = mImpl->gestures;
 710
 711   for ( GestureIter iter = gestures.Begin(), endIter = gestures.End(); iter != endIter; ++iter )
 712   {
 713     PanGesture& gesture = **iter;
 714     gesture.ResetToBaseValues( bufferIndex ); // Needs to be done every time as gesture data is written directly to an update-buffer rather than via a message
 715     gestureUpdated |= gesture.UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 716   }
 717
 718   return gestureUpdated;
 719 }
 720
 721 void UpdateManager::Animate( BufferIndex bufferIndex, float elapsedSeconds )
 722 {
 723   AnimationContainer &animations = mImpl->animations;
 724   AnimationIter iter = animations.Begin();
 725   bool animationLooped = false;
 726   while ( iter != animations.End() )
 727   {
 728     Animation* animation = *iter;
 729     bool finished = false;
 730     bool looped = false;
 731     animation->Update( bufferIndex, elapsedSeconds, looped, finished );
 732
 733     mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || finished;
 734     animationLooped = animationLooped || looped;
 735
 736     // Remove animations that had been destroyed but were still waiting for an update
 737     if (animation->GetState() == Animation::Destroyed)
 738     {
 739       iter = animations.Erase(iter);
 740     }
 741     else
 742     {
 743       ++iter;
 744     }
 745   }
 746
 747   // queue the notification on finished or looped (to update loop count)
 748   if ( mImpl->animationFinishedDuringUpdate || animationLooped )
 749   {
 750     // The application should be notified by NotificationManager, in another thread
 751     mImpl->notificationManager.QueueCompleteNotification( &mImpl->animationFinishedNotifier );
 752   }
 753 }
 754
 755 void UpdateManager::ConstrainCustomObjects( BufferIndex bufferIndex )
 756 {
 757   //Constrain custom objects (in construction order)
 758   OwnerContainer< PropertyOwner* >& customObjects = mImpl->customObjects;
 759   const OwnerContainer< PropertyOwner* >::Iterator endIter = customObjects.End();
 760   for ( OwnerContainer< PropertyOwner* >::Iterator iter = customObjects.Begin(); endIter != iter; ++iter )
 761   {
 762     PropertyOwner& object = **iter;
 763     ConstrainPropertyOwner( object, bufferIndex );
 764   }
 765 }
 766
 767 void UpdateManager::ConstrainRenderTasks( BufferIndex bufferIndex )
 768 {
 769   // Constrain system-level render-tasks
 770   const RenderTaskList::RenderTaskContainer& systemLevelTasks = mImpl->systemLevelTaskList.GetTasks();
 771   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = systemLevelTasks.Begin(); iter != systemLevelTasks.End(); ++iter )
 772   {
 773     RenderTask& task = **iter;
 774     ConstrainPropertyOwner( task, bufferIndex );
 775   }
 776
 777   // Constrain render-tasks
 778   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
 779   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(); iter != tasks.End(); ++iter )
 780   {
 781     RenderTask& task = **iter;
 782     ConstrainPropertyOwner( task, bufferIndex );
 783   }
 784 }
 785
 786 void UpdateManager::ConstrainShaders( BufferIndex bufferIndex )
 787 {
 788   // constrain shaders... (in construction order)
 789   ShaderContainer& shaders = mImpl->shaders;
 790   for ( ShaderIter iter = shaders.Begin(); iter != shaders.End(); ++iter )
 791   {
 792     Shader& shader = **iter;
 793     ConstrainPropertyOwner( shader, bufferIndex );
 794   }
 795 }
 796
 797 void UpdateManager::ProcessPropertyNotifications( BufferIndex bufferIndex )
 798 {
 799   PropertyNotificationContainer &notifications = mImpl->propertyNotifications;
 800   PropertyNotificationIter iter = notifications.Begin();
 801
 802   while ( iter != notifications.End() )
 803   {
 804     PropertyNotification* notification = *iter;
 805     bool valid = notification->Check( bufferIndex );
 806     if(valid)
 807     {
 808       mImpl->notificationManager.QueueMessage( PropertyChangedMessage( mImpl->propertyNotifier, notification, notification->GetValidity() ) );
 809     }
 810     ++iter;
 811   }
 812 }
 813
 814 void UpdateManager::PrepareTextureSets( BufferIndex bufferIndex )
 815 {
 816   size_t textureSetCount( mImpl->textureSets.Size() );
 817   for( size_t i(0); i<textureSetCount; ++i )
 818   {
 819     //Prepare texture set
 820     mImpl->textureSets[i]->Prepare( mImpl->resourceManager );
 821   }
 822 }
 823
 824 void UpdateManager::ForwardCompiledShadersToEventThread()
 825 {
 826   DALI_ASSERT_DEBUG( (mImpl->shaderSaver != 0) && "shaderSaver should be wired-up during startup." );
 827   if( mImpl->shaderSaver )
 828   {
 829     // lock and swap the queues
 830     {
 831       // render might be attempting to send us more binaries at the same time
 832       Mutex::ScopedLock lock( mImpl->compiledShaderMutex );
 833       mImpl->renderCompiledShaders.swap( mImpl->updateCompiledShaders );
 834     }
 835
 836     if( mImpl->updateCompiledShaders.size() > 0 )
 837     {
 838       ShaderSaver& factory = *mImpl->shaderSaver;
 839       ShaderDataBinaryQueue::iterator i   = mImpl->updateCompiledShaders.begin();
 840       ShaderDataBinaryQueue::iterator end = mImpl->updateCompiledShaders.end();
 841       for( ; i != end; ++i )
 842       {
 843         mImpl->notificationManager.QueueMessage( ShaderCompiledMessage( factory, *i ) );
 844       }
 845       // we don't need them in update anymore
 846       mImpl->updateCompiledShaders.clear();
 847     }
 848   }
 849 }
 850
 851 void UpdateManager::UpdateRenderers( BufferIndex bufferIndex )
 852 {
 853   const OwnerContainer<Renderer*>& rendererContainer( mImpl->renderers.GetObjectContainer() );
 854   unsigned int rendererCount( rendererContainer.Size() );
 855   for( unsigned int i(0); i<rendererCount; ++i )
 856   {
 857     //Apply constraints
 858     ConstrainPropertyOwner( *rendererContainer[i], bufferIndex );
 859
 860     if( rendererContainer[i]->IsReferenced() )
 861     {
 862       rendererContainer[i]->PrepareRender( bufferIndex );
 863     }
 864   }
 865 }
 866
 867 void UpdateManager::UpdateNodes( BufferIndex bufferIndex )
 868 {
 869   mImpl->nodeDirtyFlags = NothingFlag;
 870
 871   if ( !mImpl->root )
 872   {
 873     return;
 874   }
 875
 876   // Prepare resources, update shaders, update attachments, for each node
 877   // And add the renderers to the sorted layers. Start from root, which is also a layer
 878   mImpl->nodeDirtyFlags = UpdateNodesAndAttachments( *( mImpl->root ),
 879                                                      bufferIndex,
 880                                                      mImpl->resourceManager,
 881                                                      mImpl->renderQueue );
 882
 883   if ( mImpl->systemLevelRoot )
 884   {
 885     mImpl->nodeDirtyFlags |= UpdateNodesAndAttachments( *( mImpl->systemLevelRoot ),
 886                                                         bufferIndex,
 887                                                         mImpl->resourceManager,
 888                                                         mImpl->renderQueue );
 889   }
 890 }
 891
 892 unsigned int UpdateManager::Update( float elapsedSeconds,
 893                                     unsigned int lastVSyncTimeMilliseconds,
 894                                     unsigned int nextVSyncTimeMilliseconds )
 895 {
 896   const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
 897
 898   //Clear nodes/resources which were previously discarded
 899   mImpl->discardQueue.Clear( bufferIndex );
 900
 901   //Grab any loaded resources
 902   bool resourceChanged = mImpl->resourceManager.UpdateCache( bufferIndex );
 903
 904   //Process Touches & Gestures
 905   mImpl->touchResampler.Update();
 906   const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 907
 908   const bool updateScene =                                  // The scene-graph requires an update if..
 909       (mImpl->nodeDirtyFlags & RenderableUpdateFlags) ||    // ..nodes were dirty in previous frame OR
 910       IsAnimationRunning()                            ||    // ..at least one animation is running OR
 911       mImpl->messageQueue.IsSceneUpdateRequired()     ||    // ..a message that modifies the scene graph node tree is queued OR
 912       resourceChanged                                 ||    // ..one or more resources were updated/changed OR
 913       gestureUpdated;                                       // ..a gesture property was updated
 914
 915
 916   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 917   // values if the scene was updated in the previous frame.
 918   if( updateScene || mImpl->previousUpdateScene )
 919   {
 920     //Reset properties from the previous update
 921     ResetProperties( bufferIndex );
 922     mImpl->transformManager.ResetToBaseValue();
 923   }
 924
 925   //Process the queued scene messages
 926   mImpl->messageQueue.ProcessMessages( bufferIndex );
 927
 928   //Post Process Ids of resources updated by renderer
 929   mImpl->resourceManager.PostProcessResources( bufferIndex );
 930
 931   //Forward compiled shader programs to event thread for saving
 932   ForwardCompiledShadersToEventThread();
 933
 934   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 935   // renderer lists if the scene was updated in the previous frame.
 936   // We should not start skipping update steps or reusing lists until there has been two frames where nothing changes
 937   if( updateScene || mImpl->previousUpdateScene )
 938   {
 939     //Animate
 940     Animate( bufferIndex, elapsedSeconds );
 941
 942     //Constraint custom objects
 943     ConstrainCustomObjects( bufferIndex );
 944
 945     //Prepare texture sets and apply constraints to them
 946     PrepareTextureSets( bufferIndex );
 947
 948     //Clear the lists of renderable-attachments from the previous update
 949     for( size_t i(0); i<mImpl->sortedLayers.size(); ++i )
 950     {
 951       mImpl->sortedLayers[i]->ClearRenderables();
 952     }
 953
 954     for( size_t i(0); i<mImpl->systemLevelSortedLayers.size(); ++i )
 955     {
 956       mImpl->systemLevelSortedLayers[i]->ClearRenderables();
 957     }
 958
 959     //Update node hierarchy, apply constraints and perform sorting / culling.
 960     //This will populate each Layer with a list of renderers which are ready.
 961     UpdateNodes( bufferIndex );
 962
 963     //Apply constraints to RenderTasks, shaders
 964     ConstrainRenderTasks( bufferIndex );
 965     ConstrainShaders( bufferIndex );
 966
 967     //Update renderers and apply constraints
 968     UpdateRenderers( bufferIndex );
 969
 970     //Update the trnasformations of all the nodes
 971     mImpl->transformManager.Update();
 972
 973     //Process Property Notifications
 974     ProcessPropertyNotifications( bufferIndex );
 975
 976     //Process the RenderTasks; this creates the instructions for rendering the next frame.
 977     //reset the update buffer index and make sure there is enough room in the instruction container
 978     mImpl->renderInstructions.ResetAndReserve( bufferIndex,
 979                                                mImpl->taskList.GetTasks().Count() + mImpl->systemLevelTaskList.GetTasks().Count() );
 980
 981     if ( NULL != mImpl->root )
 982     {
 983       ProcessRenderTasks(  bufferIndex,
 984                            mImpl->taskList,
 985                            *mImpl->root,
 986                            mImpl->sortedLayers,
 987                            mImpl->renderSortingHelper,
 988                            mImpl->renderInstructions );
 989
 990       // Process the system-level RenderTasks last
 991       if ( NULL != mImpl->systemLevelRoot )
 992       {
 993         ProcessRenderTasks(  bufferIndex,
 994                              mImpl->systemLevelTaskList,
 995                              *mImpl->systemLevelRoot,
 996                              mImpl->systemLevelSortedLayers,
 997                              mImpl->renderSortingHelper,
 998                              mImpl->renderInstructions );
 999       }
1000     }
1001   }
1002
1003   // check the countdown and notify (note, at the moment this is only done for normal tasks, not for systemlevel tasks)
1004   bool doRenderOnceNotify = false;
1005   mImpl->renderTaskWaiting = false;
1006   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
1007   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(), endIter = tasks.End();
1008         endIter != iter; ++iter )
1009   {
1010     RenderTask& renderTask(*(*iter));
1011
1012     renderTask.UpdateState();
1013
1014     if( renderTask.IsWaitingToRender() &&
1015         renderTask.ReadyToRender( bufferIndex ) /*avoid updating forever when source actor is off-stage*/ )
1016     {
1017       mImpl->renderTaskWaiting = true; // keep update/render threads alive
1018     }
1019
1020     if( renderTask.HasRendered() )
1021     {
1022       doRenderOnceNotify = true;
1023     }
1024   }
1025
1026   if( doRenderOnceNotify )
1027   {
1028     DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n");
1029     mImpl->notificationManager.QueueCompleteNotification( mImpl->taskList.GetCompleteNotificationInterface() );
1030   }
1031
1032   // Macro is undefined in release build.
1033   SNAPSHOT_NODE_LOGGING;
1034
1035   // A ResetProperties() may be required in the next frame
1036   mImpl->previousUpdateScene = updateScene;
1037
1038   // Check whether further updates are required
1039   unsigned int keepUpdating = KeepUpdatingCheck( elapsedSeconds );
1040
1041   // tell the update manager that we're done so the queue can be given to event thread
1042   mImpl->notificationManager.UpdateCompleted();
1043
1044   // The update has finished; swap the double-buffering indices
1045   mSceneGraphBuffers.Swap();
1046
1047   return keepUpdating;
1048 }
1049
1050 unsigned int UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const
1051 {
1052   // Update the duration set via Stage::KeepRendering()
1053   if ( mImpl->keepRenderingSeconds > 0.0f )
1054   {
1055     mImpl->keepRenderingSeconds -= elapsedSeconds;
1056   }
1057
1058   unsigned int keepUpdatingRequest = KeepUpdating::NOT_REQUESTED;
1059
1060   // If Stage::KeepRendering() has been called, then continue until the duration has elapsed.
1061   // Keep updating until no messages are received and no animations are running.
1062   // If an animation has just finished, update at least once more for Discard end-actions.
1063   // No need to check for renderQueue as there is always a render after update and if that
1064   // render needs another update it will tell the adaptor to call update again
1065
1066   if ( mImpl->keepRenderingSeconds > 0.0f )
1067   {
1068     keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING;
1069   }
1070
1071   if ( IsAnimationRunning() ||
1072        mImpl->animationFinishedDuringUpdate )
1073   {
1074     keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING;
1075   }
1076
1077   if ( mImpl->renderTaskWaiting )
1078   {
1079     keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC;
1080   }
1081
1082   return keepUpdatingRequest;
1083 }
1084
1085 void UpdateManager::SetBackgroundColor( const Vector4& color )
1086 {
1087   typedef MessageValue1< RenderManager, Vector4 > DerivedType;
1088
1089   // Reserve some memory inside the render queue
1090   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1091
1092   // Construct message in the render queue memory; note that delete should not be called on the return value
1093   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetBackgroundColor, color );
1094 }
1095
1096 void UpdateManager::SetDefaultSurfaceRect( const Rect<int>& rect )
1097 {
1098   typedef MessageValue1< RenderManager, Rect<int> > DerivedType;
1099
1100   // Reserve some memory inside the render queue
1101   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1102
1103   // Construct message in the render queue memory; note that delete should not be called on the return value
1104   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceRect, rect );
1105 }
1106
1107 void UpdateManager::KeepRendering( float durationSeconds )
1108 {
1109   mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds );
1110 }
1111
1112 void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, bool systemLevel )
1113 {
1114   if ( !systemLevel )
1115   {
1116     // just copy the vector of pointers
1117     mImpl->sortedLayers = layers;
1118   }
1119   else
1120   {
1121     mImpl->systemLevelSortedLayers = layers;
1122   }
1123 }
1124
1125 void UpdateManager::SetShaderSaver( ShaderSaver& upstream )
1126 {
1127   mImpl->shaderSaver = &upstream;
1128 }
1129
1130 void UpdateManager::AddSampler( Render::Sampler* sampler )
1131 {
1132   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1133
1134   // Reserve some memory inside the render queue
1135   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1136
1137   // Construct message in the render queue memory; note that delete should not be called on the return value
1138   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddSampler, sampler );
1139 }
1140
1141 void UpdateManager::RemoveSampler( Render::Sampler* sampler )
1142 {
1143   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1144
1145   // Reserve some memory inside the render queue
1146   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1147
1148   // Construct message in the render queue memory; note that delete should not be called on the return value
1149   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveSampler, sampler );
1150 }
1151
1152 void UpdateManager::SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode )
1153 {
1154   typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
1155
1156   // Reserve some memory inside the render queue
1157   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1158
1159   // Construct message in the render queue memory; note that delete should not be called on the return value
1160   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
1161 }
1162
1163 void UpdateManager::SetWrapMode( Render::Sampler* sampler, unsigned int uWrapMode, unsigned int vWrapMode )
1164 {
1165   typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
1166
1167   // Reserve some memory inside the render queue
1168   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1169
1170   // Construct message in the render queue memory; note that delete should not be called on the return value
1171   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, uWrapMode, vWrapMode );
1172 }
1173
1174 void UpdateManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1175 {
1176   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1177
1178   // Reserve some memory inside the render queue
1179   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1180
1181   // Construct message in the render queue memory; note that delete should not be called on the return value
1182   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddPropertyBuffer, propertyBuffer );
1183 }
1184
1185 void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1186 {
1187   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1188
1189   // Reserve some memory inside the render queue
1190   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1191
1192   // Construct message in the render queue memory; note that delete should not be called on the return value
1193   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemovePropertyBuffer, propertyBuffer );
1194 }
1195
1196 void UpdateManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format )
1197 {
1198   typedef MessageValue2< RenderManager, Render::PropertyBuffer*, Render::PropertyBuffer::Format* > DerivedType;
1199
1200   // Reserve some memory inside the render queue
1201   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1202
1203   // Construct message in the render queue memory; note that delete should not be called on the return value
1204   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetPropertyBufferFormat, propertyBuffer, format );
1205 }
1206
1207 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data, size_t size )
1208 {
1209   typedef MessageValue3< RenderManager, Render::PropertyBuffer*, Dali::Vector<char>*, size_t > DerivedType;
1210
1211   // Reserve some memory inside the render queue
1212   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1213
1214   // Construct message in the render queue memory; note that delete should not be called on the return value
1215   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
1216 }
1217
1218 void UpdateManager::AddGeometry( Render::Geometry* geometry )
1219 {
1220   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1221
1222   // Reserve some memory inside the render queue
1223   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1224
1225   // Construct message in the render queue memory; note that delete should not be called on the return value
1226   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddGeometry, geometry );
1227 }
1228
1229 void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
1230 {
1231   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1232
1233   // Reserve some memory inside the render queue
1234   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1235
1236   // Construct message in the render queue memory; note that delete should not be called on the return value
1237   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveGeometry, geometry );
1238 }
1239
1240 void UpdateManager::SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest )
1241 {
1242   typedef MessageValue2< RenderManager, Render::Geometry*, bool > DerivedType;
1243
1244   // Reserve some memory inside the render queue
1245   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1246
1247   // Construct message in the render queue memory; note that delete should not be called on the return value
1248   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryRequiresDepthTest, geometry, requiresDepthTest );
1249 }
1250
1251 void UpdateManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
1252 {
1253   typedef MessageValue2< RenderManager, Render::Geometry*, unsigned int > DerivedType;
1254
1255   // Reserve some memory inside the render queue
1256   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1257
1258   // Construct message in the render queue memory; note that delete should not be called on the return value
1259   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryType, geometry, geometryType );
1260 }
1261
1262 void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
1263 {
1264   typedef IndexBufferMessage< RenderManager > DerivedType;
1265
1266   // Reserve some memory inside the render queue
1267   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1268
1269   // Construct message in the render queue memory; note that delete should not be called on the return value
1270   new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
1271 }
1272
1273 void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1274 {
1275   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1276
1277   // Reserve some memory inside the render queue
1278   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1279
1280   // Construct message in the render queue memory; note that delete should not be called on the return value
1281   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveVertexBuffer, geometry, propertyBuffer );
1282 }
1283
1284 void UpdateManager::AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1285 {
1286   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1287
1288   // Reserve some memory inside the render queue
1289   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1290
1291   // Construct message in the render queue memory; note that delete should not be called on the return value
1292   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddVertexBuffer, geometry, propertyBuffer );
1293 }
1294
1295
1296 } // namespace SceneGraph
1297
1298 } // namespace Internal
1299
1300 } // namespace Dali