dali/internal/update/manager/update-manager.h

   1 #ifndef DALI_INTERNAL_SCENE_GRAPH_UPDATE_MANAGER_H
   2 #define DALI_INTERNAL_SCENE_GRAPH_UPDATE_MANAGER_H
   3
   4 /*
   5  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/common/vector-wrapper.h>
  23 #include <dali/public-api/common/dali-common.h>
  24
  25 #include <dali/internal/common/message.h>
  26 #include <dali/internal/common/type-abstraction-enums.h>
  27 #include <dali/internal/common/shader-saver.h>
  28 #include <dali/internal/event/common/event-thread-services.h>
  29 #include <dali/internal/update/animation/scene-graph-animation.h>
  30 #include <dali/internal/update/common/property-resetter.h>
  31 #include <dali/internal/update/common/scene-graph-buffers.h>
  32 #include <dali/internal/update/common/scene-graph-property-notification.h>
  33 #include <dali/internal/update/nodes/node.h>
  34 #include <dali/internal/update/nodes/scene-graph-layer.h>
  35 #include <dali/internal/update/rendering/scene-graph-renderer.h>  // for OwnerPointer< Renderer >
  36 #include <dali/internal/update/rendering/scene-graph-texture-set.h> // for OwnerPointer< TextureSet >
  37 #include <dali/internal/update/gestures/scene-graph-pan-gesture.h>
  38 #include <dali/internal/update/render-tasks/scene-graph-camera.h>
  39 #include <dali/internal/render/shaders/scene-graph-shader.h>   // for OwnerPointer< Shader >
  40 #include <dali/internal/render/renderers/render-property-buffer.h>
  41 #include <dali/internal/event/rendering/texture-impl.h>
  42
  43 namespace Dali
  44 {
  45
  46 namespace Integration
  47 {
  48 class GlSyncAbstraction;
  49 class RenderController;
  50
  51 } // namespace Integration
  52
  53 namespace Internal
  54 {
  55
  56 class PropertyNotifier;
  57 class NotificationManager;
  58 class CompleteNotificationInterface;
  59 class TouchResampler;
  60
  61 namespace Render
  62 {
  63 struct Sampler;
  64 class FrameBuffer;
  65 }
  66 // value types used by messages
  67 template <> struct ParameterType< PropertyNotification::NotifyMode >
  68 : public BasicType< PropertyNotification::NotifyMode > {};
  69
  70 namespace SceneGraph
  71 {
  72
  73 class Animation;
  74 class DiscardQueue;
  75 class RenderManager;
  76 class RenderTaskList;
  77 class RenderTaskProcessor;
  78 class RenderQueue;
  79 class PropertyBuffer;
  80
  81 struct NodeDepthPair
  82 {
  83   SceneGraph::Node* node;
  84   uint32_t sortedDepth;
  85   NodeDepthPair( SceneGraph::Node* node, uint32_t sortedDepth )
  86   : node(node),
  87     sortedDepth(sortedDepth)
  88   {
  89   }
  90 };
  91
  92 struct NodeDepths
  93 {
  94   NodeDepths()
  95   {
  96   }
  97
  98   void Add( SceneGraph::Node* node, uint32_t sortedDepth )
  99   {
 100     nodeDepths.push_back( NodeDepthPair( node, sortedDepth ) );
 101   }
 102
 103   std::vector<NodeDepthPair> nodeDepths;
 104 };
 105
 106
 107 /**
 108  * UpdateManager maintains a scene graph i.e. a tree of nodes as well as
 109  * other scene graph property owning objects.
 110  * It controls the Update traversal, in which nodes are repositioned/animated,
 111  * and organizes the the culling and rendering of the scene.
 112  * It also maintains the lifecycle of nodes and other property owners that are
 113  * disconnected from the scene graph.
 114  */
 115 class UpdateManager : public ShaderSaver
 116 {
 117 public:
 118
 119   /**
 120    * Construct a new UpdateManager.
 121    * @param[in] notificationManager This should be notified when animations have finished.
 122    * @param[in] animationPlaylist The CompleteNotificationInterface that handles the animations
 123    * @param[in] propertyNotifier The PropertyNotifier
 124    * @param[in] discardQueue Nodes are added here when disconnected from the scene-graph.
 125    * @param[in] controller After messages are flushed, we request a render from the RenderController.
 126    * @param[in] renderManager This is responsible for rendering the results of each "update".
 127    * @param[in] renderQueue Used to queue messages for the next render.
 128    * @param[in] renderTaskProcessor Handles RenderTasks and RenderInstrucitons.
 129    */
 130   UpdateManager( NotificationManager& notificationManager,
 131                  CompleteNotificationInterface& animationPlaylist,
 132                  PropertyNotifier& propertyNotifier,
 133                  DiscardQueue& discardQueue,
 134                  Integration::RenderController& controller,
 135                  RenderManager& renderManager,
 136                  RenderQueue& renderQueue,
 137                  RenderTaskProcessor& renderTaskProcessor );
 138
 139   /**
 140    * Destructor.
 141    */
 142   virtual ~UpdateManager();
 143
 144   // Node connection methods
 145
 146   /**
 147    * Installs a new layer as the root node.
 148    * @pre The UpdateManager does not already have an installed root node.
 149    * @pre The layer is of derived Node type Layer.
 150    * @pre The layer does not have a parent.
 151    * @param[in] layer The new root node.
 152    * @param[in] systemLevel True if using the system-level overlay.
 153    * @post The node is owned by UpdateManager.
 154    */
 155   void InstallRoot( OwnerPointer<Layer>& layer, bool systemLevel );
 156
 157   /**
 158    * Add a Node; UpdateManager takes ownership.
 159    * @pre The node does not have a parent.
 160    * @note even though nodes are pool allocated, they also contain other heap allocated data, thus using OwnerPointer when transferring the data
 161    * @param[in] node The node to add.
 162    */
 163   void AddNode( OwnerPointer<Node>& node );
 164
 165   /**
 166    * Connect a Node to the scene-graph.
 167    * A disconnected Node has has no parent or children, and its properties cannot be animated/constrained.
 168    * @pre The node does not already have a parent.
 169    * @param[in] parent The new parent node.
 170    */
 171   void ConnectNode( Node* parent, Node* node );
 172
 173   /**
 174    * Disconnect a Node from the scene-graph.
 175    * A disconnected Node has has no parent or children, and its properties cannot be animated/constrained.
 176    * @pre The node has a parent.
 177    * @param[in] node The node to disconnect.
 178    */
 179   void DisconnectNode( Node* node );
 180
 181   /**
 182    * Destroy a Node owned by UpdateManager.
 183    * This is not immediate; Nodes are passed to the RenderQueue to allow GL resources to be deleted.
 184    * In the following update, the previously queued Nodes may be deleted.
 185    * @pre The node has been disconnected from the scene-graph i.e. has no parent or children.
 186    * @param[in] node The node to destroy.
 187    */
 188   void DestroyNode( Node* node );
 189
 190   /**
 191    * Add a camera on scene
 192    * @param[in] camera The camera to add
 193    */
 194   void AddCamera( OwnerPointer< Camera >& camera );
 195
 196   /**
 197    * Remove a camera from scene
 198    * @param[in] camera to remove
 199    */
 200   void RemoveCamera( const Camera* camera );
 201
 202   /**
 203    * Add a newly created object.
 204    * @param[in] object The object to add.
 205    * @post The object is owned by UpdateManager.
 206    */
 207   void AddObject( OwnerPointer<PropertyOwner>& object );
 208
 209   /**
 210    * Remove an object.
 211    * @param[in] object The object to remove.
 212    */
 213   void RemoveObject( PropertyOwner* object );
 214
 215   // Animations
 216
 217   /**
 218    * Add a newly created animation.
 219    * @param[in] animation The animation to add.
 220    * @post The animation is owned by UpdateManager.
 221    */
 222   void AddAnimation( OwnerPointer< SceneGraph::Animation >& animation );
 223
 224   /**
 225    * Stop an animation.
 226    * @param[in] animation The animation to stop.
 227    */
 228   void StopAnimation( Animation* animation );
 229
 230   /**
 231    * Remove an animation.
 232    * @param[in] animation The animation to remove.
 233    */
 234   void RemoveAnimation( Animation* animation );
 235
 236   /**
 237    * Query whether any animations are currently running.
 238    * @return True if any animations are running.
 239    */
 240   bool IsAnimationRunning() const;
 241
 242   /**
 243    * Add a property resetter. UpdateManager takes ownership of the object.
 244    * It will be killed by UpdateManager when the associated animator or
 245    * constraint has finished; or the property owner of the property is destroyed.
 246    */
 247   void AddPropertyResetter( OwnerPointer<PropertyResetterBase>& propertyResetter );
 248
 249   // Property Notification
 250
 251   /**
 252    * Add a newly created property notification
 253    * @param[in] propertyNotification The notification to add
 254    * @post The propertyNotification is owned by UpdateManager.
 255    */
 256   void AddPropertyNotification( OwnerPointer< PropertyNotification >& propertyNotification );
 257
 258   /**
 259    * Remove a property notification
 260    * @param[in] propertyNotification The notification to remove
 261    */
 262   void RemovePropertyNotification( PropertyNotification* propertyNotification );
 263
 264   /**
 265    * Set Notify state for PropertyNotification
 266    * @param[in] propertyNotification The notification to remove
 267    * @param[in] notifyMode The notification mode.
 268    */
 269   void PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode );
 270
 271   // Shaders
 272
 273   /**
 274    * Add a newly created shader.
 275    * @param[in] shader The shader to add.
 276    * @post The shader is owned by the UpdateManager.
 277    */
 278   void AddShader( OwnerPointer< Shader >& shader );
 279
 280   /**
 281    * Remove a shader.
 282    * @pre The shader has been added to the UpdateManager.
 283    * @param[in] shader The shader to remove.
 284    * @post The shader is destroyed.
 285    */
 286   void RemoveShader( Shader* shader );
 287
 288   /**
 289    * Set the shader program for a Shader object
 290    * @param[in] shader        The shader to modify
 291    * @param[in] shaderData    Source code, hash over source, and optional compiled binary for the shader program
 292    * @param[in] modifiesGeometry True if the vertex shader modifies geometry
 293    */
 294   void SetShaderProgram( Shader* shader, Internal::ShaderDataPtr shaderData, bool modifiesGeometry );
 295
 296   /**
 297    * @brief Accept compiled shaders passed back on render thread for saving.
 298    * @param[in] shaderData Source code, hash over source, and corresponding compiled binary to be saved.
 299    */
 300   virtual void SaveBinary( Internal::ShaderDataPtr shaderData );
 301
 302   /**
 303    * @brief Set the destination for compiled shader binaries to be passed on to.
 304    * The dispatcher passed in will be called from the update thread.
 305    * @param[in] upstream A sink for ShaderDatas to be passed into.
 306    */
 307   void SetShaderSaver( ShaderSaver& upstream );
 308
 309   // Renderers
 310
 311   /**
 312    * Add a new renderer to scene
 313    * @param renderer to add
 314    */
 315   void AddRenderer( OwnerPointer< Renderer >& renderer );
 316
 317   /**
 318    * Add a renderer from scene
 319    * @param renderer to remove
 320    */
 321   void RemoveRenderer( Renderer* renderer );
 322
 323   // Gestures
 324
 325   /**
 326    * Set the pan gesture processor.
 327    * Pan Gesture processor lives for the lifetime of UpdateManager
 328    * @param[in] gesture The gesture processor.
 329    * @post The gestureProcessor is owned by the UpdateManager.
 330    */
 331   void SetPanGestureProcessor( PanGesture* gestureProcessor );
 332
 333   // Textures
 334
 335   /**
 336    * Add a newly created TextureSet.
 337    * @param[in] textureSet The texture set to add.
 338    * @post The TextureSet is owned by the UpdateManager.
 339    */
 340   void AddTextureSet( OwnerPointer< TextureSet >& textureSet );
 341
 342   /**
 343    * Remove a TextureSet.
 344    * @pre The TextureSet has been added to the UpdateManager.
 345    * @param[in] textureSet The TextureSet to remove.
 346    * @post The TextureSet is destroyed.
 347    */
 348   void RemoveTextureSet( TextureSet* textureSet );
 349
 350   // Render tasks
 351
 352   /**
 353    * Get the scene graph side list of RenderTasks.
 354    * @param[in] systemLevel True if using the system-level overlay.
 355    * @return The list of render tasks
 356    */
 357   RenderTaskList* GetRenderTaskList( bool systemLevel );
 358
 359 // Message queue handling
 360
 361   /**
 362    * Reserve space for another message in the queue; this must then be initialized by the caller.
 363    * The message will be read from the update-thread after the next FlushMessages is called.
 364    * @post Calling this method may invalidate any previously returned slots.
 365    * @param[in] size The message size with respect to the size of type "char".
 366    * @param[in] updateScene A flag, when true denotes that the message will cause the scene-graph node tree to require an update.
 367    * @note the default value of updateScene should match that in EventThreadServices::ReserveMessageSlot.
 368    * @return A pointer to the first char allocated for the message.
 369    */
 370   unsigned int* ReserveMessageSlot( std::size_t size, bool updateScene = true );
 371
 372   /**
 373    * @return the current event-buffer index.
 374    */
 375   BufferIndex GetEventBufferIndex() const
 376   {
 377     // inlined as its called often from event thread
 378     return mSceneGraphBuffers.GetEventBufferIndex();
 379   }
 380
 381   /**
 382    * Called by the event-thread to signal that FlushQueue will be called
 383    * e.g. when it has finished event processing.
 384    */
 385   void EventProcessingStarted();
 386
 387   /**
 388    * Flush the set of messages, which were previously stored with QueueMessage().
 389    * Calls to this thread-safe method should be minimized, to avoid thread blocking.
 390    *
 391    * @return True if there are messages to process.
 392    */
 393   bool FlushQueue();
 394
 395   /**
 396    * Add a new sampler to RenderManager
 397    * @param[in] sampler The sampler to add
 398    * @post Sends a message to RenderManager to add the sampler.
 399    * The sampler will be owned by RenderManager
 400    */
 401   void AddSampler( OwnerPointer< Render::Sampler >& sampler );
 402
 403   /**
 404    * Removes an existing sampler from RenderManager
 405    * @param[in] sampler The sampler to remove
 406    * @post The sampler will be destroyed in the render thread
 407    */
 408   void RemoveSampler( Render::Sampler* sampler );
 409
 410   /**
 411    * Sets the filter modes for an existing sampler
 412    * @param[in] sampler The sampler
 413    * @param[in] minFilterMode The filter to use under minification
 414    * @param[in] magFilterMode The filter to use under magnification
 415    */
 416   void SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode );
 417
 418   /**
 419    * Sets the wrap mode for an existing sampler
 420    * @param[in] sampler The sampler
 421    * @param[in] rWrapMode Wrapping mode in z direction
 422    * @param[in] sWrapMode Wrapping mode in x direction
 423    * @param[in] tWrapMode Wrapping mode in y direction
 424    */
 425   void SetWrapMode( Render::Sampler* sampler, unsigned int rWrapMode, unsigned int sWrapMode, unsigned int tWrapMode );
 426
 427   /**
 428    * Add a new property buffer to RenderManager
 429    * @param[in] propertryBuffer The property buffer to add
 430    * @post Sends a message to RenderManager to add the property buffer.
 431    * The property buffer will be owned by RenderManager
 432    */
 433   void AddPropertyBuffer( OwnerPointer< Render::PropertyBuffer >& propertryBuffer );
 434
 435   /**
 436    * Removes an existing PropertyBuffer from RenderManager
 437    * @param[in] propertryBuffer The property buffer to remove
 438    * @post The property buffer will be destroyed in the render thread
 439    */
 440   void RemovePropertyBuffer( Render::PropertyBuffer* propertryBuffer );
 441
 442   /**
 443    * Sets the format of an existing property buffer
 444    * @param[in] propertyBuffer The property buffer.
 445    * @param[in] format The new format of the buffer
 446    * @post Sends a message to RenderManager to set the new format to the property buffer.
 447    */
 448   void SetPropertyBufferFormat( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Render::PropertyBuffer::Format>& format );
 449
 450   /**
 451    * Sets the data of an existing property buffer
 452    * @param[in] propertyBuffer The property buffer.
 453    * @param[in] data The new data of the buffer
 454    * @param[in] size The new size of the buffer
 455    * @post Sends a message to RenderManager to set the new data to the property buffer.
 456    */
 457   void SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, OwnerPointer< Vector<char> >& data, size_t size );
 458
 459   /**
 460    * Adds a geometry to the RenderManager
 461    * @param[in] geometry The geometry to add
 462    * @post Sends a message to RenderManager to add the Geometry
 463    * The geometry will be owned by RenderManager
 464    */
 465   void AddGeometry( OwnerPointer< Render::Geometry >& geometry );
 466
 467   /**
 468    * Removes an existing Geometry from RenderManager
 469    * @param[in] geometry The geometry to remove
 470    * @post The geometry will be destroyed in the render thread
 471    */
 472   void RemoveGeometry( Render::Geometry* geometry );
 473
 474   /**
 475    * Sets the geometry type of an existing Geometry
 476    * @param[in] geometry The geometry
 477    * @param[in] geometryType The type of the geometry
 478    */
 479   void SetGeometryType( Render::Geometry* geometry, unsigned int geometryType );
 480
 481   /**
 482    * Sets the index buffer to be used by a geometry
 483    * @param[in] geometry The geometry
 484    * @param[in] indices A vector containing the indices for the geometry
 485    */
 486   void SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices );
 487
 488   /**
 489    * Adds a vertex buffer to a geometry
 490    * @param[in] geometry The geometry
 491    * @param[in] propertyBuffer The property buffer
 492    */
 493   void AttachVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer );
 494
 495   /**
 496    * Removes a vertex buffer from a geometry
 497    * @param[in] geometry The geometry
 498    * @param[in] propertyBuffer The property buffer
 499    */
 500   void RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer );
 501
 502   /**
 503    * Adds a texture to the render manager
 504    * @param[in] texture The texture to add
 505    * The texture will be owned by RenderManager
 506    */
 507   void AddTexture( OwnerPointer< Render::Texture >& texture );
 508
 509   /**
 510    * Removes a texture from the render manager
 511    * @param[in] texture The texture to remove
 512    * @post The texture will be destroyed in the render thread
 513    */
 514   void RemoveTexture( Render::Texture* texture );
 515
 516   /**
 517    * Uploads data to a texture owned by the RenderManager
 518    * @param[in] texture The texture
 519    * @param[in] pixelData The pixel data object
 520    * @param[in] params The parameters for the upload
 521    */
 522   void UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params );
 523
 524   /**
 525    * Generates mipmaps for a texture owned by the RenderManager
 526    * @param[in] texture The texture
 527    */
 528   void GenerateMipmaps( Render::Texture* texture );
 529
 530   /**
 531    * Adds a framebuffer to the render manager
 532    * @param[in] frameBuffer The framebuffer to add
 533    * The framebuffer will be owned by RenderManager
 534    */
 535   void AddFrameBuffer( Render::FrameBuffer* frameBuffer );
 536
 537   /**
 538    * Removes a FrameBuffer from the render manager
 539    * @param[in] frameBuffer The FrameBuffer to remove
 540    * @post The FrameBuffer will be destroyed in the render thread
 541    */
 542   void RemoveFrameBuffer( Render::FrameBuffer* frameBuffer );
 543
 544   /**
 545    * Attach a texture as color output to an existing FrameBuffer
 546    * @param[in] frameBuffer The FrameBuffer
 547    * @param[in] texture The texture that will be used as output when rendering
 548    * @param[in] mipmapLevel The mipmap of the texture to be attached
 549    * @param[in] layer Indicates which layer of a cube map or array texture to attach. Unused for 2D textures
 550    */
 551   void AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, unsigned int mipmapLevel, unsigned int face );
 552
 553 public:
 554
 555   /**
 556    * Performs an Update traversal on the scene-graph.
 557    * @param[in] elapsedSeconds The elapsed time that should be applied to animations.
 558    * @param[in] lastVSyncTimeMilliseconds The last time, in milliseconds, that we had a VSync.
 559    * @param[in] nextVSyncTimeMilliseconds The estimated time, in milliseconds, of the next VSync.
 560    * @param[in] renderToFboEnabled Whether rendering into the Frame Buffer Object is enabled.
 561    * @param[in] isRenderingToFbo   Whether this frame is being rendered into the Frame Buffer Object.
 562    * @return True if further updates are required e.g. during animations.
 563    */
 564   unsigned int Update( float elapsedSeconds,
 565                        unsigned int lastVSyncTimeMilliseconds,
 566                        unsigned int nextVSyncTimeMilliseconds,
 567                        bool renderToFboEnabled,
 568                        bool isRenderingToFbo );
 569
 570   /**
 571    * Set the background color i.e. the glClear color used at the beginning of each frame.
 572    * @param[in] color The new background color.
 573    */
 574   void SetBackgroundColor(const Vector4& color);
 575
 576   /**
 577    * Set the default surface rect.
 578    * @param[in] rect The rect value representing the surface.
 579    */
 580   void SetDefaultSurfaceRect( const Rect<int>& rect );
 581
 582   /**
 583    * @copydoc Dali::Stage::KeepRendering()
 584    */
 585   void KeepRendering( float durationSeconds );
 586
 587   /**
 588    * Sets the depths of all layers.
 589    * @param layers The layers in depth order.
 590    * @param[in] systemLevel True if using the system-level overlay.
 591    */
 592   void SetLayerDepths( const std::vector< Layer* >& layers, bool systemLevel );
 593
 594   /**
 595    * Set the depth indices of all nodes (in LayerUI's)
 596    * @param[in] nodeDepths A vector of nodes and associated depth indices
 597    */
 598   void SetDepthIndices( OwnerPointer< NodeDepths >& nodeDepths );
 599
 600   /**
 601    * Query wheter the default surface rect is changed or not.
 602    * @return true if the default surface rect is changed.
 603    */
 604   bool IsDefaultSurfaceRectChanged();
 605
 606 private:
 607
 608   // Undefined
 609   UpdateManager(const UpdateManager&);
 610
 611   // Undefined
 612   UpdateManager& operator=(const UpdateManager& rhs);
 613
 614   /**
 615    * Helper to check whether the update-thread should keep going.
 616    * @param[in] elapsedSeconds The time in seconds since the previous update.
 617    * @return True if the update-thread should keep going.
 618    */
 619   unsigned int KeepUpdatingCheck( float elapsedSeconds ) const;
 620
 621   /**
 622    * Helper to reset all Node properties
 623    * @param[in] bufferIndex to use
 624    */
 625   void ResetProperties( BufferIndex bufferIndex );
 626
 627   /**
 628    * Perform gesture updates.
 629    * @param[in] bufferIndex to use
 630    * @param[in] lastVSyncTime  The last VSync time in milliseconds.
 631    * @param[in] nextVSyncTime  The estimated time of the next VSync in milliseconds.
 632    * @return true, if any properties were updated.
 633    */
 634   bool ProcessGestures( BufferIndex bufferIndex, unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds );
 635
 636   /**
 637    * Perform animation updates
 638    * @param[in] bufferIndex to use
 639    * @param[in] elapsedSeconds time since last frame
 640    */
 641   void Animate( BufferIndex bufferIndex, float elapsedSeconds );
 642
 643   /**
 644    * Applies constraints to CustomObjects
 645    * @param[in] bufferIndex to use
 646    */
 647   void ConstrainCustomObjects( BufferIndex bufferIndex );
 648
 649   /**
 650    * Applies constraints to RenderTasks
 651    * @param[in] bufferIndex to use
 652    */
 653   void ConstrainRenderTasks( BufferIndex bufferIndex );
 654
 655   /**
 656    * Applies constraints to Shaders
 657    * @param[in] bufferIndex to use
 658    */
 659   void ConstrainShaders( BufferIndex bufferIndex );
 660
 661   /**
 662    * Perform property notification updates
 663    * @param[in] bufferIndex to use
 664    */
 665   void ProcessPropertyNotifications( BufferIndex bufferIndex );
 666
 667   /**
 668    * Pass shader binaries queued here on to event thread.
 669    */
 670   void ForwardCompiledShadersToEventThread();
 671
 672   /**
 673    * Update node shaders, opacity, geometry etc.
 674    * @param[in] bufferIndex to use
 675    */
 676   void UpdateNodes( BufferIndex bufferIndex );
 677
 678   /**
 679    * Update Renderers
 680    * @param[in] bufferIndex to use
 681    */
 682   void UpdateRenderers( BufferIndex bufferIndex );
 683
 684 private:
 685
 686   // needs to be direct member so that getter for event buffer can be inlined
 687   SceneGraphBuffers mSceneGraphBuffers;
 688
 689   struct Impl;
 690   Impl* mImpl;
 691
 692 };
 693
 694 // Messages for UpdateManager
 695
 696 inline void InstallRootMessage( UpdateManager& manager, OwnerPointer<Layer>& root, bool systemLevel )
 697 {
 698   // Message has ownership of Layer while in transit from event -> update
 699   typedef MessageValue2< UpdateManager, OwnerPointer<Layer>, bool > LocalType;
 700
 701   // Reserve some memory inside the message queue
 702   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 703
 704   // Construct message in the message queue memory; note that delete should not be called on the return value
 705   new (slot) LocalType( &manager, &UpdateManager::InstallRoot, root, systemLevel );
 706 }
 707
 708 inline void AddNodeMessage( UpdateManager& manager, OwnerPointer<Node>& node )
 709 {
 710   // Message has ownership of Node while in transit from event -> update
 711   typedef MessageValue1< UpdateManager, OwnerPointer<Node> > LocalType;
 712
 713   // Reserve some memory inside the message queue
 714   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 715
 716   // Construct message in the message queue memory; note that delete should not be called on the return value
 717   new (slot) LocalType( &manager, &UpdateManager::AddNode, node );
 718 }
 719
 720 inline void ConnectNodeMessage( UpdateManager& manager, const Node& constParent, const Node& constChild )
 721 {
 722   // Update thread can edit the object
 723   Node& parent = const_cast< Node& >( constParent );
 724   Node& child = const_cast< Node& >( constChild );
 725
 726   typedef MessageValue2< UpdateManager, Node*, Node* > LocalType;
 727
 728   // Reserve some memory inside the message queue
 729   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 730
 731   // Construct message in the message queue memory; note that delete should not be called on the return value
 732   new (slot) LocalType( &manager, &UpdateManager::ConnectNode, &parent, &child );
 733 }
 734
 735 inline void DisconnectNodeMessage( UpdateManager& manager, const Node& constNode )
 736 {
 737   // Scene graph thread can modify this object.
 738   Node& node = const_cast< Node& >( constNode );
 739
 740   typedef MessageValue1< UpdateManager, Node* > LocalType;
 741
 742   // Reserve some memory inside the message queue
 743   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 744
 745   // Construct message in the message queue memory; note that delete should not be called on the return value
 746   new (slot) LocalType( &manager, &UpdateManager::DisconnectNode, &node );
 747 }
 748
 749 inline void DestroyNodeMessage( UpdateManager& manager, const Node& constNode )
 750 {
 751   // Scene graph thread can destroy this object.
 752   Node& node = const_cast< Node& >( constNode );
 753
 754   typedef MessageValue1< UpdateManager, Node* > LocalType;
 755
 756   // Reserve some memory inside the message queue
 757   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 758
 759   // Construct message in the message queue memory; note that delete should not be called on the return value
 760   new (slot) LocalType( &manager, &UpdateManager::DestroyNode, &node );
 761 }
 762
 763 inline void AddCameraMessage( UpdateManager& manager, OwnerPointer< Camera >& camera )
 764 {
 765   // Message has ownership of Camera while in transit from event -> update
 766   typedef MessageValue1< UpdateManager, OwnerPointer< Camera > > LocalType;
 767
 768   // Reserve some memory inside the message queue
 769   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 770
 771   // Construct message in the message queue memory; note that delete should not be called on the return value
 772   new (slot) LocalType( &manager, &UpdateManager::AddCamera, camera );
 773 }
 774
 775 inline void RemoveCameraMessage( UpdateManager& manager, const Camera* camera )
 776 {
 777   typedef MessageValue1< UpdateManager, const Camera* > LocalType;
 778
 779   // Reserve some memory inside the message queue
 780   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 781
 782   // Construct message in the message queue memory; note that delete should not be called on the return value
 783   new (slot) LocalType( &manager, &UpdateManager::RemoveCamera, camera );
 784 }
 785
 786 inline void AddObjectMessage( UpdateManager& manager, OwnerPointer<PropertyOwner>& object )
 787 {
 788   // Message has ownership of object while in transit from event -> update
 789   typedef MessageValue1< UpdateManager, OwnerPointer<PropertyOwner> > LocalType;
 790
 791   // Reserve some memory inside the message queue
 792   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 793
 794   // Construct message in the message queue memory; note that delete should not be called on the return value
 795   new (slot) LocalType( &manager, &UpdateManager::AddObject, object );
 796 }
 797
 798 inline void RemoveObjectMessage( UpdateManager& manager, PropertyOwner* object )
 799 {
 800   typedef MessageValue1< UpdateManager, PropertyOwner* > LocalType;
 801
 802   // Reserve some memory inside the message queue
 803   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 804
 805   // Construct message in the message queue memory; note that delete should not be called on the return value
 806   new (slot) LocalType( &manager, &UpdateManager::RemoveObject, object );
 807 }
 808
 809 inline void AddAnimationMessage( UpdateManager& manager, OwnerPointer< SceneGraph::Animation >& animation )
 810 {
 811   typedef MessageValue1< UpdateManager, OwnerPointer< SceneGraph::Animation > > LocalType;
 812
 813   // Reserve some memory inside the message queue
 814   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 815
 816   // Construct message in the message queue memory; note that delete should not be called on the return value
 817   new (slot) LocalType( &manager, &UpdateManager::AddAnimation, animation );
 818 }
 819
 820 inline void StopAnimationMessage( UpdateManager& manager, const Animation& constAnimation )
 821 {
 822   // The scene-graph thread owns this object so it can safely edit it.
 823   Animation& animation = const_cast< Animation& >( constAnimation );
 824
 825   typedef MessageValue1< UpdateManager, Animation* > LocalType;
 826
 827   // Reserve some memory inside the message queue
 828   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 829
 830   // Construct message in the message queue memory; note that delete should not be called on the return value
 831   new (slot) LocalType( &manager, &UpdateManager::StopAnimation, &animation );
 832 }
 833
 834 inline void RemoveAnimationMessage( UpdateManager& manager, const Animation& constAnimation )
 835 {
 836   // The scene-graph thread owns this object so it can safely edit it.
 837   Animation& animation = const_cast< Animation& >( constAnimation );
 838
 839   typedef MessageValue1< UpdateManager, Animation* > LocalType;
 840
 841   // Reserve some memory inside the message queue
 842   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 843
 844   // Construct message in the message queue memory; note that delete should not be called on the return value
 845   new (slot) LocalType( &manager, &UpdateManager::RemoveAnimation, &animation );
 846 }
 847
 848 inline void AddPropertyNotificationMessage( UpdateManager& manager, OwnerPointer< PropertyNotification >& propertyNotification )
 849 {
 850   // Message has ownership of PropertyNotification while in transit from event -> update
 851   typedef MessageValue1< UpdateManager, OwnerPointer< PropertyNotification > > LocalType;
 852
 853   // Reserve some memory inside the message queue
 854   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 855
 856   // Construct message in the message queue memory; note that delete should not be called on the return value
 857   new (slot) LocalType( &manager, &UpdateManager::AddPropertyNotification, propertyNotification );
 858 }
 859
 860 inline void RemovePropertyNotificationMessage( UpdateManager& manager, const PropertyNotification& constPropertyNotification )
 861 {
 862   // The scene-graph thread owns this object so it can safely edit it.
 863   PropertyNotification& propertyNotification = const_cast< PropertyNotification& >( constPropertyNotification );
 864
 865   typedef MessageValue1< UpdateManager, PropertyNotification* > LocalType;
 866
 867   // Reserve some memory inside the message queue
 868   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 869
 870   // Construct message in the message queue memory; note that delete should not be called on the return value
 871   new (slot) LocalType( &manager, &UpdateManager::RemovePropertyNotification, &propertyNotification );
 872 }
 873
 874 inline void PropertyNotificationSetNotifyModeMessage( UpdateManager& manager,
 875                                                       const PropertyNotification* constPropertyNotification,
 876                                                       PropertyNotification::NotifyMode notifyMode )
 877 {
 878   // The scene-graph thread owns this object so it can safely edit it.
 879   PropertyNotification* propertyNotification = const_cast< PropertyNotification* >( constPropertyNotification );
 880
 881   typedef MessageValue2< UpdateManager, PropertyNotification*, PropertyNotification::NotifyMode > LocalType;
 882
 883   // Reserve some memory inside the message queue
 884   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 885
 886   // Construct message in the message queue memory; note that delete should not be called on the return value
 887   new (slot) LocalType( &manager, &UpdateManager::PropertyNotificationSetNotify, propertyNotification, notifyMode );
 888 }
 889
 890 // The render thread can safely change the Shader
 891 inline void AddShaderMessage( UpdateManager& manager, OwnerPointer< Shader >& shader )
 892 {
 893   typedef MessageValue1< UpdateManager, OwnerPointer< Shader > > LocalType;
 894
 895   // Reserve some memory inside the message queue
 896   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 897
 898   // Construct message in the message queue memory; note that delete should not be called on the return value
 899   new (slot) LocalType( &manager, &UpdateManager::AddShader, shader );
 900 }
 901
 902 // The render thread can safely change the Shader
 903 inline void RemoveShaderMessage( UpdateManager& manager, Shader& shader )
 904 {
 905   typedef MessageValue1< UpdateManager, Shader* > LocalType;
 906
 907   // Reserve some memory inside the message queue
 908   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 909
 910   // Construct message in the message queue memory; note that delete should not be called on the return value
 911   new (slot) LocalType( &manager, &UpdateManager::RemoveShader, &shader );
 912 }
 913
 914 inline void SetShaderProgramMessage( UpdateManager& manager,
 915                                      Shader& shader,
 916                                      Internal::ShaderDataPtr shaderData,
 917                                      bool modifiesGeometry )
 918 {
 919   typedef MessageValue3< UpdateManager, Shader*, Internal::ShaderDataPtr, bool > LocalType;
 920
 921   // Reserve some memory inside the message queue
 922   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 923
 924   // Construct message in the message queue memory; note that delete should not be called on the return value
 925   new (slot) LocalType( &manager, &UpdateManager::SetShaderProgram, &shader, shaderData, modifiesGeometry );
 926 }
 927
 928 inline void SetBackgroundColorMessage( UpdateManager& manager, const Vector4& color )
 929 {
 930   typedef MessageValue1< UpdateManager, Vector4 > LocalType;
 931
 932   // Reserve some memory inside the message queue
 933   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 934
 935   // Construct message in the message queue memory; note that delete should not be called on the return value
 936   new (slot) LocalType( &manager, &UpdateManager::SetBackgroundColor, color );
 937 }
 938
 939 inline void SetDefaultSurfaceRectMessage( UpdateManager& manager, const Rect<int>& rect  )
 940 {
 941   typedef MessageValue1< UpdateManager, Rect<int> > LocalType;
 942
 943   // Reserve some memory inside the message queue
 944   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 945
 946   // Construct message in the message queue memory; note that delete should not be called on the return value
 947   new (slot) LocalType( &manager, &UpdateManager::SetDefaultSurfaceRect, rect );
 948 }
 949
 950 inline void KeepRenderingMessage( UpdateManager& manager, float durationSeconds )
 951 {
 952   typedef MessageValue1< UpdateManager, float > LocalType;
 953
 954   // Reserve some memory inside the message queue
 955   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 956
 957   // Construct message in the message queue memory; note that delete should not be called on the return value
 958   new (slot) LocalType( &manager, &UpdateManager::KeepRendering, durationSeconds );
 959 }
 960
 961 /**
 962  * Create a message for setting the depth of a layer
 963  * @param[in] manager The update manager
 964  * @param[in] layers list of layers
 965  * @param[in] systemLevel True if the layers are added via the SystemOverlay API
 966  */
 967 inline void SetLayerDepthsMessage( UpdateManager& manager, const std::vector< Layer* >& layers, bool systemLevel )
 968 {
 969   typedef MessageValue2< UpdateManager, std::vector< Layer* >, bool > LocalType;
 970
 971   // Reserve some memory inside the message queue
 972   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 973
 974   // Construct message in the message queue memory; note that delete should not be called on the return value
 975   new (slot) LocalType( &manager, &UpdateManager::SetLayerDepths, layers, systemLevel );
 976 }
 977
 978 inline void AddRendererMessage( UpdateManager& manager, OwnerPointer< Renderer >& object )
 979 {
 980   typedef MessageValue1< UpdateManager, OwnerPointer< Renderer > > LocalType;
 981
 982   // Reserve some memory inside the message queue
 983   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 984   // Construct message in the message queue memory; note that delete should not be called on the return value
 985   new (slot) LocalType( &manager, &UpdateManager::AddRenderer, object );
 986 }
 987
 988 inline void RemoveRendererMessage( UpdateManager& manager, Renderer& object )
 989 {
 990   typedef MessageValue1< UpdateManager, Renderer* > LocalType;
 991
 992   // Reserve some memory inside the message queue
 993   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
 994   // Construct message in the message queue memory; note that delete should not be called on the return value
 995   new (slot) LocalType( &manager, &UpdateManager::RemoveRenderer, &object );
 996 }
 997
 998 // The render thread can safely change the Shader
 999 inline void AddTextureSetMessage( UpdateManager& manager, OwnerPointer< TextureSet >& textureSet )
1000 {
1001   typedef MessageValue1< UpdateManager, OwnerPointer< TextureSet > > LocalType;
1002
1003   // Reserve some memory inside the message queue
1004   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1005
1006   // Construct message in the message queue memory; note that delete should not be called on the return value
1007   new (slot) LocalType( &manager, &UpdateManager::AddTextureSet, textureSet );
1008 }
1009
1010 // The render thread can safely change the Shader
1011 inline void RemoveTextureSetMessage( UpdateManager& manager, TextureSet& textureSet )
1012 {
1013   typedef MessageValue1< UpdateManager, TextureSet* > LocalType;
1014
1015   // Reserve some memory inside the message queue
1016   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1017
1018   // Construct message in the message queue memory; note that delete should not be called on the return value
1019   new (slot) LocalType( &manager, &UpdateManager::RemoveTextureSet, &textureSet );
1020 }
1021
1022 inline void AddSamplerMessage( UpdateManager& manager, OwnerPointer< Render::Sampler >& sampler )
1023 {
1024   // Message has ownership of Sampler while in transit from event -> update
1025   typedef MessageValue1< UpdateManager, OwnerPointer< Render::Sampler > > LocalType;
1026
1027   // Reserve some memory inside the message queue
1028   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1029
1030   // Construct message in the message queue memory; note that delete should not be called on the return value
1031   new (slot) LocalType( &manager, &UpdateManager::AddSampler, sampler );
1032 }
1033
1034 inline void RemoveSamplerMessage( UpdateManager& manager, Render::Sampler& sampler )
1035 {
1036   typedef MessageValue1< UpdateManager, Render::Sampler* > LocalType;
1037
1038   // Reserve some memory inside the message queue
1039   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1040
1041   // Construct message in the message queue memory; note that delete should not be called on the return value
1042   new (slot) LocalType( &manager, &UpdateManager::RemoveSampler, &sampler );
1043 }
1044
1045 inline void SetFilterModeMessage( UpdateManager& manager, Render::Sampler& sampler, unsigned int minFilterMode, unsigned int magFilterMode )
1046 {
1047   typedef MessageValue3< UpdateManager, Render::Sampler*, unsigned int, unsigned int > LocalType;
1048
1049   // Reserve some memory inside the message queue
1050   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1051
1052   // Construct message in the message queue memory; note that delete should not be called on the return value
1053   new (slot) LocalType( &manager, &UpdateManager::SetFilterMode, &sampler, minFilterMode, magFilterMode );
1054 }
1055
1056 inline void SetWrapModeMessage( UpdateManager& manager, Render::Sampler& sampler, unsigned int rWrapMode, unsigned int sWrapMode, unsigned int tWrapMode )
1057 {
1058   typedef MessageValue4< UpdateManager, Render::Sampler*, unsigned int, unsigned int, unsigned int > LocalType;
1059
1060   // Reserve some memory inside the message queue
1061   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1062
1063   // Construct message in the message queue memory; note that delete should not be called on the return value
1064   new (slot) LocalType( &manager, &UpdateManager::SetWrapMode, &sampler, rWrapMode, sWrapMode, tWrapMode );
1065 }
1066
1067 inline void AddPropertyBuffer( UpdateManager& manager, OwnerPointer< Render::PropertyBuffer >& propertyBuffer )
1068 {
1069   // Message has ownership of propertyBuffer while in transit from event -> update
1070   typedef MessageValue1< UpdateManager, OwnerPointer< Render::PropertyBuffer > > LocalType;
1071
1072   // Reserve some memory inside the message queue
1073   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1074
1075   // Construct message in the message queue memory; note that delete should not be called on the return value
1076   new (slot) LocalType( &manager, &UpdateManager::AddPropertyBuffer, propertyBuffer );
1077 }
1078
1079 inline void RemovePropertyBuffer( UpdateManager& manager, Render::PropertyBuffer& propertyBuffer )
1080 {
1081   typedef MessageValue1< UpdateManager, Render::PropertyBuffer*  > LocalType;
1082
1083   // Reserve some memory inside the message queue
1084   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1085
1086   // Construct message in the message queue memory; note that delete should not be called on the return value
1087   new (slot) LocalType( &manager, &UpdateManager::RemovePropertyBuffer, &propertyBuffer );
1088 }
1089
1090 inline void SetPropertyBufferFormat( UpdateManager& manager, Render::PropertyBuffer& propertyBuffer, OwnerPointer< Render::PropertyBuffer::Format>& format )
1091 {
1092   // Message has ownership of PropertyBuffer::Format while in transit from event -> update
1093   typedef MessageValue2< UpdateManager, Render::PropertyBuffer*, OwnerPointer< Render::PropertyBuffer::Format> > LocalType;
1094
1095   // Reserve some memory inside the message queue
1096   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1097
1098   // Construct message in the message queue memory; note that delete should not be called on the return value
1099   new (slot) LocalType( &manager, &UpdateManager::SetPropertyBufferFormat, &propertyBuffer, format );
1100 }
1101
1102 inline void SetPropertyBufferData( UpdateManager& manager, Render::PropertyBuffer& propertyBuffer, OwnerPointer< Vector<char> >& data, size_t size )
1103 {
1104   // Message has ownership of PropertyBuffer data while in transit from event -> update
1105   typedef MessageValue3< UpdateManager, Render::PropertyBuffer*, OwnerPointer< Vector<char> >, size_t  > LocalType;
1106
1107   // Reserve some memory inside the message queue
1108   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1109
1110   // Construct message in the message queue memory; note that delete should not be called on the return value
1111   new (slot) LocalType( &manager, &UpdateManager::SetPropertyBufferData, &propertyBuffer, data, size );
1112 }
1113
1114 inline void AddGeometry( UpdateManager& manager, OwnerPointer< Render::Geometry >& geometry )
1115 {
1116   // Message has ownership of Geometry while in transit from event -> update
1117   typedef MessageValue1< UpdateManager, OwnerPointer< Render::Geometry > > LocalType;
1118
1119   // Reserve some memory inside the message queue
1120   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1121
1122   // Construct message in the message queue memory; note that delete should not be called on the return value
1123   new (slot) LocalType( &manager, &UpdateManager::AddGeometry, geometry );
1124 }
1125
1126 inline void RemoveGeometry( UpdateManager& manager, Render::Geometry& geometry )
1127 {
1128   typedef MessageValue1< UpdateManager, Render::Geometry*  > LocalType;
1129
1130   // Reserve some memory inside the message queue
1131   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1132
1133   // Construct message in the message queue memory; note that delete should not be called on the return value
1134   new (slot) LocalType( &manager, &UpdateManager::RemoveGeometry, &geometry );
1135 }
1136
1137 inline void AttachVertexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, const Render::PropertyBuffer& vertexBuffer )
1138 {
1139   typedef MessageValue2< UpdateManager, Render::Geometry*, Render::PropertyBuffer* > LocalType;
1140
1141   // Reserve some memory inside the message queue
1142   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1143
1144   // Construct message in the message queue memory; note that delete should not be called on the return value
1145   new (slot) LocalType( &manager, &UpdateManager::AttachVertexBuffer, &geometry, const_cast<Render::PropertyBuffer*>(&vertexBuffer) );
1146 }
1147
1148 inline void RemoveVertexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, const Render::PropertyBuffer& vertexBuffer )
1149 {
1150   typedef MessageValue2< UpdateManager, Render::Geometry*, Render::PropertyBuffer* > LocalType;
1151
1152   // Reserve some memory inside the message queue
1153   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1154
1155   // Construct message in the message queue memory; note that delete should not be called on the return value
1156   new (slot) LocalType( &manager, &UpdateManager::RemoveVertexBuffer, &geometry, const_cast<Render::PropertyBuffer*>(&vertexBuffer) );
1157 }
1158
1159 // Custom message type for SetIndexBuffer() used to move data with Vector::Swap()
1160 template< typename T >
1161 class IndexBufferMessage : public MessageBase
1162 {
1163 public:
1164
1165   /**
1166    * Constructor which does a Vector::Swap()
1167    */
1168   IndexBufferMessage( T* manager, Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
1169   : MessageBase(),
1170     mManager( manager ),
1171     mRenderGeometry( geometry )
1172   {
1173     mIndices.Swap( indices );
1174   }
1175
1176   /**
1177    * Virtual destructor
1178    */
1179   virtual ~IndexBufferMessage()
1180   {
1181   }
1182
1183   /**
1184    * @copydoc MessageBase::Process
1185    */
1186   virtual void Process( BufferIndex /*bufferIndex*/ )
1187   {
1188     DALI_ASSERT_DEBUG( mManager && "Message does not have an object" );
1189     mManager->SetIndexBuffer( mRenderGeometry, mIndices );
1190   }
1191
1192 private:
1193
1194   T* mManager;
1195   Render::Geometry* mRenderGeometry;
1196   Dali::Vector<unsigned short> mIndices;
1197 };
1198
1199 inline void SetIndexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, Dali::Vector<unsigned short>& indices )
1200 {
1201   typedef IndexBufferMessage< UpdateManager > LocalType;
1202
1203   // Reserve some memory inside the message queue
1204   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1205
1206   // Construct message in the message queue memory; note that delete should not be called on the return value
1207   new (slot) LocalType( &manager, &geometry, indices );
1208 }
1209
1210 inline void SetGeometryTypeMessage( UpdateManager& manager, Render::Geometry& geometry, unsigned int geometryType )
1211 {
1212   typedef MessageValue2< UpdateManager, Render::Geometry*, unsigned int > LocalType;
1213
1214   // Reserve some memory inside the message queue
1215   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1216
1217   // Construct message in the message queue memory; note that delete should not be called on the return value
1218   new (slot) LocalType( &manager, &UpdateManager::SetGeometryType, &geometry, geometryType );
1219 }
1220
1221 inline void AddTexture( UpdateManager& manager, OwnerPointer< Render::Texture >& texture )
1222 {
1223   // Message has ownership of Texture while in transit from event -> update
1224   typedef MessageValue1< UpdateManager, OwnerPointer< Render::Texture > > LocalType;
1225
1226   // Reserve some memory inside the message queue
1227   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1228
1229   // Construct message in the message queue memory; note that delete should not be called on the return value
1230   new (slot) LocalType( &manager, &UpdateManager::AddTexture, texture );
1231 }
1232
1233 inline void RemoveTexture( UpdateManager& manager, Render::Texture& texture )
1234 {
1235   typedef MessageValue1< UpdateManager, Render::Texture*  > LocalType;
1236
1237   // Reserve some memory inside the message queue
1238   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1239
1240   // Construct message in the message queue memory; note that delete should not be called on the return value
1241   new (slot) LocalType( &manager, &UpdateManager::RemoveTexture, &texture );
1242 }
1243
1244 inline void UploadTextureMessage( UpdateManager& manager, Render::Texture& texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
1245 {
1246   typedef MessageValue3< UpdateManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > LocalType;
1247
1248   // Reserve some memory inside the message queue
1249   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1250
1251   // Construct message in the message queue memory; note that delete should not be called on the return value
1252   new (slot) LocalType( &manager, &UpdateManager::UploadTexture, &texture, pixelData, params );
1253 }
1254
1255 inline void GenerateMipmapsMessage( UpdateManager& manager, Render::Texture& texture )
1256 {
1257   typedef MessageValue1< UpdateManager, Render::Texture*  > LocalType;
1258
1259   // Reserve some memory inside the message queue
1260   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1261
1262   // Construct message in the message queue memory; note that delete should not be called on the return value
1263   new (slot) LocalType( &manager, &UpdateManager::GenerateMipmaps, &texture );
1264 }
1265
1266
1267 inline void AddFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer )
1268 {
1269   typedef MessageValue1< UpdateManager, Render::FrameBuffer*  > LocalType;
1270
1271   // Reserve some memory inside the message queue
1272   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1273
1274   // Construct message in the message queue memory; note that delete should not be called on the return value
1275   new (slot) LocalType( &manager, &UpdateManager::AddFrameBuffer, &frameBuffer );
1276 }
1277
1278 inline void RemoveFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer )
1279 {
1280   typedef MessageValue1< UpdateManager, Render::FrameBuffer*  > LocalType;
1281
1282   // Reserve some memory inside the message queue
1283   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1284
1285   // Construct message in the message queue memory; note that delete should not be called on the return value
1286   new (slot) LocalType( &manager, &UpdateManager::RemoveFrameBuffer, &frameBuffer );
1287 }
1288
1289 inline void AttachColorTextureToFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer, Render::Texture* texture, unsigned int mipmapLevel, unsigned int layer )
1290 {
1291   typedef MessageValue4< UpdateManager, Render::FrameBuffer*, Render::Texture*, unsigned int, unsigned int  > LocalType;
1292
1293   // Reserve some memory inside the message queue
1294   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1295
1296   // Construct message in the message queue memory; note that delete should not be called on the return value
1297   new (slot) LocalType( &manager, &UpdateManager::AttachColorTextureToFrameBuffer, &frameBuffer, texture, mipmapLevel, layer );
1298 }
1299
1300 inline void SetDepthIndicesMessage( UpdateManager& manager, OwnerPointer< NodeDepths >& nodeDepths )
1301 {
1302   typedef MessageValue1< UpdateManager, OwnerPointer< NodeDepths > > LocalType;
1303
1304   // Reserve some memory inside the message queue
1305   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1306
1307   // Construct message in the message queue memory; note that delete should not be called on the return value
1308   new (slot) LocalType( &manager, &UpdateManager::SetDepthIndices, nodeDepths );
1309 }
1310
1311 inline void AddResetterMessage( UpdateManager& manager, OwnerPointer<PropertyResetterBase> resetter )
1312 {
1313   typedef MessageValue1< UpdateManager, OwnerPointer<PropertyResetterBase> > LocalType;
1314
1315   // Reserve some memory inside the message queue
1316   unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
1317
1318   // Construct message in the message queue memory; note that delete should not be called on the return value
1319   new (slot) LocalType( &manager, &UpdateManager::AddPropertyResetter, resetter );
1320 }
1321
1322
1323 } // namespace SceneGraph
1324
1325 } // namespace Internal
1326
1327 } // namespace Dali
1328
1329 #endif // DALI_INTERNAL_SCENE_GRAPH_UPDATE_MANAGER_H