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

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