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