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

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