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