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