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

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