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     rendererContainer[i]->PrepareRender( bufferIndex );
 871   }
 872 }
 873
 874 void UpdateManager::UpdateNodes( BufferIndex bufferIndex )
 875 {
 876   mImpl->nodeDirtyFlags = NothingFlag;
 877
 878   if ( !mImpl->root )
 879   {
 880     return;
 881   }
 882
 883   // Prepare resources, update shaders, for each node
 884   // And add the renderers to the sorted layers. Start from root, which is also a layer
 885   mImpl->nodeDirtyFlags = UpdateNodeTree( *( mImpl->root ),
 886                                           bufferIndex,
 887                                           mImpl->resourceManager,
 888                                           mImpl->renderQueue );
 889
 890   if ( mImpl->systemLevelRoot )
 891   {
 892     mImpl->nodeDirtyFlags |= UpdateNodeTree( *( mImpl->systemLevelRoot ),
 893                                              bufferIndex,
 894                                              mImpl->resourceManager,
 895                                              mImpl->renderQueue );
 896   }
 897 }
 898
 899 unsigned int UpdateManager::Update( float elapsedSeconds,
 900                                     unsigned int lastVSyncTimeMilliseconds,
 901                                     unsigned int nextVSyncTimeMilliseconds )
 902 {
 903   const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
 904
 905   //Clear nodes/resources which were previously discarded
 906   mImpl->discardQueue.Clear( bufferIndex );
 907
 908   //Grab any loaded resources
 909   bool resourceChanged = mImpl->resourceManager.UpdateCache( bufferIndex );
 910
 911   //Process Touches & Gestures
 912   const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 913
 914   const bool updateScene =                                  // The scene-graph requires an update if..
 915       (mImpl->nodeDirtyFlags & RenderableUpdateFlags) ||    // ..nodes were dirty in previous frame OR
 916       IsAnimationRunning()                            ||    // ..at least one animation is running OR
 917       mImpl->messageQueue.IsSceneUpdateRequired()     ||    // ..a message that modifies the scene graph node tree is queued OR
 918       resourceChanged                                 ||    // ..one or more resources were updated/changed OR
 919       gestureUpdated;                                       // ..a gesture property was updated
 920
 921
 922   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 923   // values if the scene was updated in the previous frame.
 924   if( updateScene || mImpl->previousUpdateScene )
 925   {
 926     //Reset properties from the previous update
 927     ResetProperties( bufferIndex );
 928     mImpl->transformManager.ResetToBaseValue();
 929   }
 930
 931   //Process the queued scene messages
 932   mImpl->messageQueue.ProcessMessages( bufferIndex );
 933
 934   //Post Process Ids of resources updated by renderer
 935   mImpl->resourceManager.PostProcessResources( bufferIndex );
 936
 937   //Forward compiled shader programs to event thread for saving
 938   ForwardCompiledShadersToEventThread();
 939
 940   // Although the scene-graph may not require an update, we still need to synchronize double-buffered
 941   // renderer lists if the scene was updated in the previous frame.
 942   // We should not start skipping update steps or reusing lists until there has been two frames where nothing changes
 943   if( updateScene || mImpl->previousUpdateScene )
 944   {
 945     //Animate
 946     Animate( bufferIndex, elapsedSeconds );
 947
 948     //Constraint custom objects
 949     ConstrainCustomObjects( bufferIndex );
 950
 951     //Prepare texture sets and apply constraints to them
 952     PrepareTextureSets( 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     //Process the RenderTasks; this creates the instructions for rendering the next frame.
 983     //reset the update buffer index and make sure there is enough room in the instruction container
 984     mImpl->renderInstructions.ResetAndReserve( bufferIndex,
 985                                                mImpl->taskList.GetTasks().Count() + mImpl->systemLevelTaskList.GetTasks().Count() );
 986
 987     if ( NULL != mImpl->root )
 988     {
 989       ProcessRenderTasks(  bufferIndex,
 990                            mImpl->taskList,
 991                            *mImpl->root,
 992                            mImpl->sortedLayers,
 993                            mImpl->renderSortingHelper,
 994                            mImpl->renderInstructions );
 995
 996       // Process the system-level RenderTasks last
 997       if ( NULL != mImpl->systemLevelRoot )
 998       {
 999         ProcessRenderTasks(  bufferIndex,
1000                              mImpl->systemLevelTaskList,
1001                              *mImpl->systemLevelRoot,
1002                              mImpl->systemLevelSortedLayers,
1003                              mImpl->renderSortingHelper,
1004                              mImpl->renderInstructions );
1005       }
1006     }
1007   }
1008
1009   // check the countdown and notify (note, at the moment this is only done for normal tasks, not for systemlevel tasks)
1010   bool doRenderOnceNotify = false;
1011   mImpl->renderTaskWaiting = false;
1012   const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
1013   for ( RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(), endIter = tasks.End();
1014         endIter != iter; ++iter )
1015   {
1016     RenderTask& renderTask(*(*iter));
1017
1018     renderTask.UpdateState();
1019
1020     if( renderTask.IsWaitingToRender() &&
1021         renderTask.ReadyToRender( bufferIndex ) /*avoid updating forever when source actor is off-stage*/ )
1022     {
1023       mImpl->renderTaskWaiting = true; // keep update/render threads alive
1024     }
1025
1026     if( renderTask.HasRendered() )
1027     {
1028       doRenderOnceNotify = true;
1029     }
1030   }
1031
1032   if( doRenderOnceNotify )
1033   {
1034     DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Notify a render task has finished\n");
1035     mImpl->notificationManager.QueueCompleteNotification( mImpl->taskList.GetCompleteNotificationInterface() );
1036   }
1037
1038   // Macro is undefined in release build.
1039   SNAPSHOT_NODE_LOGGING;
1040
1041   // A ResetProperties() may be required in the next frame
1042   mImpl->previousUpdateScene = updateScene;
1043
1044   // Check whether further updates are required
1045   unsigned int keepUpdating = KeepUpdatingCheck( elapsedSeconds );
1046
1047   // tell the update manager that we're done so the queue can be given to event thread
1048   mImpl->notificationManager.UpdateCompleted();
1049
1050   // The update has finished; swap the double-buffering indices
1051   mSceneGraphBuffers.Swap();
1052
1053   return keepUpdating;
1054 }
1055
1056 unsigned int UpdateManager::KeepUpdatingCheck( float elapsedSeconds ) const
1057 {
1058   // Update the duration set via Stage::KeepRendering()
1059   if ( mImpl->keepRenderingSeconds > 0.0f )
1060   {
1061     mImpl->keepRenderingSeconds -= elapsedSeconds;
1062   }
1063
1064   unsigned int keepUpdatingRequest = KeepUpdating::NOT_REQUESTED;
1065
1066   // If Stage::KeepRendering() has been called, then continue until the duration has elapsed.
1067   // Keep updating until no messages are received and no animations are running.
1068   // If an animation has just finished, update at least once more for Discard end-actions.
1069   // No need to check for renderQueue as there is always a render after update and if that
1070   // render needs another update it will tell the adaptor to call update again
1071
1072   if ( mImpl->keepRenderingSeconds > 0.0f )
1073   {
1074     keepUpdatingRequest |= KeepUpdating::STAGE_KEEP_RENDERING;
1075   }
1076
1077   if ( IsAnimationRunning() ||
1078        mImpl->animationFinishedDuringUpdate )
1079   {
1080     keepUpdatingRequest |= KeepUpdating::ANIMATIONS_RUNNING;
1081   }
1082
1083   if ( mImpl->renderTaskWaiting )
1084   {
1085     keepUpdatingRequest |= KeepUpdating::RENDER_TASK_SYNC;
1086   }
1087
1088   return keepUpdatingRequest;
1089 }
1090
1091 void UpdateManager::SetBackgroundColor( const Vector4& color )
1092 {
1093   typedef MessageValue1< RenderManager, Vector4 > DerivedType;
1094
1095   // Reserve some memory inside the render queue
1096   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1097
1098   // Construct message in the render queue memory; note that delete should not be called on the return value
1099   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetBackgroundColor, color );
1100 }
1101
1102 void UpdateManager::SetDefaultSurfaceRect( const Rect<int>& rect )
1103 {
1104   typedef MessageValue1< RenderManager, Rect<int> > DerivedType;
1105
1106   // Reserve some memory inside the render queue
1107   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1108
1109   // Construct message in the render queue memory; note that delete should not be called on the return value
1110   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetDefaultSurfaceRect, rect );
1111 }
1112
1113 void UpdateManager::KeepRendering( float durationSeconds )
1114 {
1115   mImpl->keepRenderingSeconds = std::max( mImpl->keepRenderingSeconds, durationSeconds );
1116 }
1117
1118 void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, bool systemLevel )
1119 {
1120   if ( !systemLevel )
1121   {
1122     // just copy the vector of pointers
1123     mImpl->sortedLayers = layers;
1124   }
1125   else
1126   {
1127     mImpl->systemLevelSortedLayers = layers;
1128   }
1129 }
1130
1131 void UpdateManager::SetShaderSaver( ShaderSaver& upstream )
1132 {
1133   mImpl->shaderSaver = &upstream;
1134 }
1135
1136 void UpdateManager::AddSampler( Render::Sampler* sampler )
1137 {
1138   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1139
1140   // Reserve some memory inside the render queue
1141   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1142
1143   // Construct message in the render queue memory; note that delete should not be called on the return value
1144   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddSampler, sampler );
1145 }
1146
1147 void UpdateManager::RemoveSampler( Render::Sampler* sampler )
1148 {
1149   typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
1150
1151   // Reserve some memory inside the render queue
1152   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1153
1154   // Construct message in the render queue memory; note that delete should not be called on the return value
1155   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveSampler, sampler );
1156 }
1157
1158 void UpdateManager::SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode )
1159 {
1160   typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
1161
1162   // Reserve some memory inside the render queue
1163   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1164
1165   // Construct message in the render queue memory; note that delete should not be called on the return value
1166   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
1167 }
1168
1169 void UpdateManager::SetWrapMode( Render::Sampler* sampler, unsigned int rWrapMode, unsigned int sWrapMode, unsigned int tWrapMode )
1170 {
1171   typedef MessageValue4< RenderManager, Render::Sampler*, unsigned int, unsigned int, unsigned int > DerivedType;
1172
1173   // Reserve some memory inside the render queue
1174   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1175
1176   // Construct message in the render queue memory; note that delete should not be called on the return value
1177   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode );
1178 }
1179
1180 void UpdateManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1181 {
1182   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1183
1184   // Reserve some memory inside the render queue
1185   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1186
1187   // Construct message in the render queue memory; note that delete should not be called on the return value
1188   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddPropertyBuffer, propertyBuffer );
1189 }
1190
1191 void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
1192 {
1193   typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
1194
1195   // Reserve some memory inside the render queue
1196   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1197
1198   // Construct message in the render queue memory; note that delete should not be called on the return value
1199   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemovePropertyBuffer, propertyBuffer );
1200 }
1201
1202 void UpdateManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format )
1203 {
1204   typedef MessageValue2< RenderManager, Render::PropertyBuffer*, Render::PropertyBuffer::Format* > DerivedType;
1205
1206   // Reserve some memory inside the render queue
1207   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1208
1209   // Construct message in the render queue memory; note that delete should not be called on the return value
1210   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetPropertyBufferFormat, propertyBuffer, format );
1211 }
1212
1213 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data, size_t size )
1214 {
1215   typedef MessageValue3< RenderManager, Render::PropertyBuffer*, Dali::Vector<char>*, size_t > DerivedType;
1216
1217   // Reserve some memory inside the render queue
1218   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1219
1220   // Construct message in the render queue memory; note that delete should not be called on the return value
1221   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
1222 }
1223
1224 void UpdateManager::AddGeometry( Render::Geometry* geometry )
1225 {
1226   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1227
1228   // Reserve some memory inside the render queue
1229   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1230
1231   // Construct message in the render queue memory; note that delete should not be called on the return value
1232   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddGeometry, geometry );
1233 }
1234
1235 void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
1236 {
1237   typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
1238
1239   // Reserve some memory inside the render queue
1240   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1241
1242   // Construct message in the render queue memory; note that delete should not be called on the return value
1243   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveGeometry, geometry );
1244 }
1245
1246 void UpdateManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
1247 {
1248   typedef MessageValue2< RenderManager, Render::Geometry*, unsigned int > DerivedType;
1249
1250   // Reserve some memory inside the render queue
1251   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1252
1253   // Construct message in the render queue memory; note that delete should not be called on the return value
1254   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryType, geometry, geometryType );
1255 }
1256
1257 void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
1258 {
1259   typedef IndexBufferMessage< RenderManager > DerivedType;
1260
1261   // Reserve some memory inside the render queue
1262   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1263
1264   // Construct message in the render queue memory; note that delete should not be called on the return value
1265   new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
1266 }
1267
1268 void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1269 {
1270   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1271
1272   // Reserve some memory inside the render queue
1273   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1274
1275   // Construct message in the render queue memory; note that delete should not be called on the return value
1276   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveVertexBuffer, geometry, propertyBuffer );
1277 }
1278
1279 void UpdateManager::AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
1280 {
1281   typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
1282
1283   // Reserve some memory inside the render queue
1284   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1285
1286   // Construct message in the render queue memory; note that delete should not be called on the return value
1287   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddVertexBuffer, geometry, propertyBuffer );
1288 }
1289
1290 void UpdateManager::AddTexture( Render::NewTexture* texture )
1291 {
1292   typedef MessageValue1< RenderManager, Render::NewTexture* > DerivedType;
1293
1294   // Reserve some memory inside the render queue
1295   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1296
1297   // Construct message in the render queue memory; note that delete should not be called on the return value
1298   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddTexture, texture );
1299 }
1300
1301 void UpdateManager::RemoveTexture( Render::NewTexture* texture)
1302 {
1303   typedef MessageValue1< RenderManager, Render::NewTexture* > DerivedType;
1304
1305   // Reserve some memory inside the render queue
1306   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1307
1308   // Construct message in the render queue memory; note that delete should not be called on the return value
1309   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveTexture, texture );
1310 }
1311
1312 void UpdateManager::UploadTexture( Render::NewTexture* texture, PixelDataPtr pixelData, const NewTexture::UploadParams& params )
1313 {
1314   typedef MessageValue3< RenderManager, Render::NewTexture*, PixelDataPtr, NewTexture::UploadParams > DerivedType;
1315
1316   // Reserve some memory inside the message queue
1317   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1318
1319   // Construct message in the message queue memory; note that delete should not be called on the return value
1320   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params );
1321 }
1322
1323 void UpdateManager::GenerateMipmaps( Render::NewTexture* texture )
1324 {
1325   typedef MessageValue1< RenderManager, Render::NewTexture* > DerivedType;
1326
1327   // Reserve some memory inside the render queue
1328   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1329
1330   // Construct message in the render queue memory; note that delete should not be called on the return value
1331   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::GenerateMipmaps, texture );
1332 }
1333
1334 void UpdateManager::AddFrameBuffer( Render::FrameBuffer* frameBuffer )
1335 {
1336   typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
1337
1338   // Reserve some memory inside the render queue
1339   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1340
1341   // Construct message in the render queue memory; note that delete should not be called on the return value
1342   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddFrameBuffer, frameBuffer );
1343 }
1344
1345 void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
1346 {
1347   typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
1348
1349   // Reserve some memory inside the render queue
1350   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1351
1352   // Construct message in the render queue memory; note that delete should not be called on the return value
1353   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveFrameBuffer, frameBuffer );
1354 }
1355
1356 void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::NewTexture* texture, unsigned int mipmapLevel, unsigned int layer )
1357 {
1358   typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::NewTexture*, unsigned int, unsigned int > DerivedType;
1359
1360   // Reserve some memory inside the render queue
1361   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
1362
1363   // Construct message in the render queue memory; note that delete should not be called on the return value
1364   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer );
1365 }
1366
1367 } // namespace SceneGraph
1368
1369 } // namespace Internal
1370
1371 } // namespace Dali