[Tizen] Fix memory leak issue in dali core
[platform/core/uifw/dali-core.git] / dali / internal / update / manager / update-manager.cpp
old mode 100644 (file)
new mode 100755 (executable)
index 88667d2..c6d67ea
@@ -1,5 +1,5 @@
 /*
 /*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,7 +20,6 @@
 
 // INTERNAL INCLUDES
 #include <dali/public-api/common/stage.h>
 
 // INTERNAL INCLUDES
 #include <dali/public-api/common/stage.h>
-#include <dali/devel-api/common/set-wrapper.h>
 #include <dali/devel-api/common/owner-container.h>
 #include <dali/devel-api/threading/mutex.h>
 
 #include <dali/devel-api/common/owner-container.h>
 #include <dali/devel-api/threading/mutex.h>
 
 #include <dali/internal/update/controllers/render-message-dispatcher.h>
 #include <dali/internal/update/controllers/scene-controller-impl.h>
 #include <dali/internal/update/gestures/scene-graph-pan-gesture.h>
 #include <dali/internal/update/controllers/render-message-dispatcher.h>
 #include <dali/internal/update/controllers/scene-controller-impl.h>
 #include <dali/internal/update/gestures/scene-graph-pan-gesture.h>
-#include <dali/internal/update/manager/object-owner-container.h>
-#include <dali/internal/update/manager/process-render-tasks.h>
+#include <dali/internal/update/manager/render-task-processor.h>
 #include <dali/internal/update/manager/sorted-layers.h>
 #include <dali/internal/update/manager/update-algorithms.h>
 #include <dali/internal/update/manager/update-manager-debug.h>
 #include <dali/internal/update/manager/transform-manager.h>
 #include <dali/internal/update/manager/sorted-layers.h>
 #include <dali/internal/update/manager/update-algorithms.h>
 #include <dali/internal/update/manager/update-manager-debug.h>
 #include <dali/internal/update/manager/transform-manager.h>
-#include <dali/internal/update/node-attachments/scene-graph-camera-attachment.h>
 #include <dali/internal/update/nodes/node.h>
 #include <dali/internal/update/nodes/scene-graph-layer.h>
 #include <dali/internal/update/queue/update-message-queue.h>
 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
 #include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
 #include <dali/internal/update/nodes/node.h>
 #include <dali/internal/update/nodes/scene-graph-layer.h>
 #include <dali/internal/update/queue/update-message-queue.h>
 #include <dali/internal/update/render-tasks/scene-graph-render-task.h>
 #include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
-#include <dali/internal/update/rendering/scene-graph-material.h>
-#include <dali/internal/update/rendering/scene-graph-geometry.h>
-#include <dali/internal/update/resources/resource-manager.h>
-#include <dali/internal/update/touch/touch-resampler.h>
+#include <dali/internal/update/render-tasks/scene-graph-camera.h>
 
 #include <dali/internal/render/common/render-instruction-container.h>
 #include <dali/internal/render/common/render-manager.h>
 #include <dali/internal/render/queue/render-queue.h>
 
 #include <dali/internal/render/common/render-instruction-container.h>
 #include <dali/internal/render/common/render-manager.h>
 #include <dali/internal/render/queue/render-queue.h>
-#include <dali/internal/render/gl-resources/texture-cache.h>
 #include <dali/internal/render/shaders/scene-graph-shader.h>
 #include <dali/internal/render/shaders/scene-graph-shader.h>
-#include <dali/internal/render/renderers/render-sampler.h>
 
 // Un-comment to enable node tree debug logging
 //#define NODE_TREE_LOGGING 1
 
 // Un-comment to enable node tree debug logging
 //#define NODE_TREE_LOGGING 1
@@ -104,16 +96,64 @@ namespace Internal
 namespace SceneGraph
 {
 
 namespace SceneGraph
 {
 
-typedef OwnerContainer< Shader* >              ShaderContainer;
-typedef ShaderContainer::Iterator              ShaderIter;
-typedef ShaderContainer::ConstIterator         ShaderConstIter;
+namespace
+{
+/**
+ * Helper to reset animate-able objects to base values
+ * @param container to iterate over
+ * @param updateBufferIndex to use
+ */
+template< class T >
+inline void ResetToBaseValues( OwnerContainer<T*>& container, BufferIndex updateBufferIndex )
+{
+  // Reset animatable properties to base values
+  typename OwnerContainer<T*>::Iterator iter = container.Begin();
+  const typename OwnerContainer<T*>::ConstIterator endIter = container.End();
+  for ( ; iter != endIter; ++iter )
+  {
+    (*iter)->ResetToBaseValues( updateBufferIndex );
+  }
+}
 
 
+/**
+ * Helper to Erase an object from OwnerContainer using discard queue
+ * @param container to remove from
+ * @param object to remove
+ * @param discardQueue to put the object to
+ * @param updateBufferIndex to use
+ */
+template < class T >
+inline void EraseUsingDiscardQueue( OwnerContainer<T*>& container, T* object, DiscardQueue& discardQueue, BufferIndex updateBufferIndex )
+{
+  DALI_ASSERT_DEBUG( object && "NULL object not allowed" );
+
+  typename OwnerContainer<T*>::Iterator iter = container.Begin();
+  const typename OwnerContainer<T*>::ConstIterator endIter = container.End();
+  for ( ; iter != endIter; ++iter )
+  {
+    if ( *iter == object )
+    {
+      // Transfer ownership to the discard queue, this keeps the object alive, until the render-thread has finished with it
+      discardQueue.Add( updateBufferIndex, container.Release( iter ) );
+      return;
+    }
+  }
+}
+
+}
+
+typedef OwnerContainer< Shader* >              ShaderOwner;
+typedef ShaderOwner::Iterator                  ShaderIter;
 typedef std::vector<Internal::ShaderDataPtr>   ShaderDataBinaryQueue;
 
 typedef std::vector<Internal::ShaderDataPtr>   ShaderDataBinaryQueue;
 
-typedef OwnerContainer<PanGesture*>            GestureContainer;
-typedef GestureContainer::Iterator             GestureIter;
-typedef GestureContainer::ConstIterator        GestureConstIter;
+typedef OwnerContainer< TextureSet* >          TextureSetOwner;
+typedef TextureSetOwner::Iterator              TextureSetIter;
+
+typedef OwnerContainer<Renderer*>              RendererOwner;
+typedef RendererOwner::Iterator                RendererIter;
 
 
+typedef OwnerContainer< Camera* >              CameraOwner;
+typedef OwnerContainer< PropertyOwner* >       CustomObjectOwner;
 
 /**
  * Structure to contain UpdateManager internal data
 
 /**
  * Structure to contain UpdateManager internal data
@@ -123,50 +163,43 @@ struct UpdateManager::Impl
   Impl( NotificationManager& notificationManager,
         CompleteNotificationInterface& animationFinishedNotifier,
         PropertyNotifier& propertyNotifier,
   Impl( NotificationManager& notificationManager,
         CompleteNotificationInterface& animationFinishedNotifier,
         PropertyNotifier& propertyNotifier,
-        ResourceManager& resourceManager,
         DiscardQueue& discardQueue,
         RenderController& renderController,
         RenderManager& renderManager,
         RenderQueue& renderQueue,
         DiscardQueue& discardQueue,
         RenderController& renderController,
         RenderManager& renderManager,
         RenderQueue& renderQueue,
-        TextureCache& textureCache,
-        TouchResampler& touchResampler,
-        SceneGraphBuffers& sceneGraphBuffers )
+        SceneGraphBuffers& sceneGraphBuffers,
+        RenderTaskProcessor& renderTaskProcessor )
   : renderMessageDispatcher( renderManager, renderQueue, sceneGraphBuffers ),
     notificationManager( notificationManager ),
     transformManager(),
     animationFinishedNotifier( animationFinishedNotifier ),
     propertyNotifier( propertyNotifier ),
     shaderSaver( NULL ),
   : renderMessageDispatcher( renderManager, renderQueue, sceneGraphBuffers ),
     notificationManager( notificationManager ),
     transformManager(),
     animationFinishedNotifier( animationFinishedNotifier ),
     propertyNotifier( propertyNotifier ),
     shaderSaver( NULL ),
-    resourceManager( resourceManager ),
     discardQueue( discardQueue ),
     renderController( renderController ),
     sceneController( NULL ),
     renderManager( renderManager ),
     renderQueue( renderQueue ),
     renderInstructions( renderManager.GetRenderInstructionContainer() ),
     discardQueue( discardQueue ),
     renderController( renderController ),
     sceneController( NULL ),
     renderManager( renderManager ),
     renderQueue( renderQueue ),
     renderInstructions( renderManager.GetRenderInstructionContainer() ),
-    touchResampler( touchResampler ),
+    renderTaskProcessor( renderTaskProcessor ),
     backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
     backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
-    taskList( renderMessageDispatcher, resourceManager ),
-    systemLevelTaskList( renderMessageDispatcher, resourceManager ),
+    taskList( renderMessageDispatcher ),
+    systemLevelTaskList( renderMessageDispatcher ),
     root( NULL ),
     systemLevelRoot( NULL ),
     root( NULL ),
     systemLevelRoot( NULL ),
-    renderers( sceneGraphBuffers, discardQueue ),
-    geometries( sceneGraphBuffers, discardQueue ),
-    materials( sceneGraphBuffers, discardQueue ),
+    renderers(),
+    textureSets(),
+    shaders(),
+    panGestureProcessor( NULL ),
     messageQueue( renderController, sceneGraphBuffers ),
     keepRenderingSeconds( 0.0f ),
     messageQueue( renderController, sceneGraphBuffers ),
     keepRenderingSeconds( 0.0f ),
-    animationFinishedDuringUpdate( false ),
     nodeDirtyFlags( TransformFlag ), // set to TransformFlag to ensure full update the first time through Update()
     nodeDirtyFlags( TransformFlag ), // set to TransformFlag to ensure full update the first time through Update()
-    previousUpdateScene( false ),
     frameCounter( 0 ),
     frameCounter( 0 ),
-    renderSortingHelper(),
+    animationFinishedDuringUpdate( false ),
+    previousUpdateScene( false ),
     renderTaskWaiting( false )
   {
     renderTaskWaiting( false )
   {
-    sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue, textureCache );
-
-    renderers.SetSceneController( *sceneController );
-    geometries.SetSceneController( *sceneController );
-    materials.SetSceneController( *sceneController );
+    sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue );
 
     // create first 'dummy' node
     nodes.PushBack(0u);
 
     // create first 'dummy' node
     nodes.PushBack(0u);
@@ -193,7 +226,7 @@ struct UpdateManager::Impl
     for(;iter!=endIter;++iter)
     {
       (*iter)->OnDestroy();
     for(;iter!=endIter;++iter)
     {
       (*iter)->OnDestroy();
-      delete(*iter);
+      Node::Delete(*iter);
     }
 
     // If there is root, reset it, otherwise do nothing as rendering was never started
     }
 
     // If there is root, reset it, otherwise do nothing as rendering was never started
@@ -201,7 +234,7 @@ struct UpdateManager::Impl
     {
       root->OnDestroy();
 
     {
       root->OnDestroy();
 
-      delete root;
+      Node::Delete( root );
       root = NULL;
     }
 
       root = NULL;
     }
 
@@ -209,11 +242,10 @@ struct UpdateManager::Impl
     {
       systemLevelRoot->OnDestroy();
 
     {
       systemLevelRoot->OnDestroy();
 
-      delete systemLevelRoot;
+      Node::Delete( systemLevelRoot );
       systemLevelRoot = NULL;
     }
 
       systemLevelRoot = NULL;
     }
 
-    sceneController->GetTextureCache().SetBufferIndices(NULL); // TODO - Remove
     delete sceneController;
   }
 
     delete sceneController;
   }
 
@@ -224,14 +256,13 @@ struct UpdateManager::Impl
   CompleteNotificationInterface&      animationFinishedNotifier;     ///< Provides notification to applications when animations are finished.
   PropertyNotifier&                   propertyNotifier;              ///< Provides notification to applications when properties are modified.
   ShaderSaver*                        shaderSaver;                   ///< Saves shader binaries.
   CompleteNotificationInterface&      animationFinishedNotifier;     ///< Provides notification to applications when animations are finished.
   PropertyNotifier&                   propertyNotifier;              ///< Provides notification to applications when properties are modified.
   ShaderSaver*                        shaderSaver;                   ///< Saves shader binaries.
-  ResourceManager&                    resourceManager;               ///< resource manager
   DiscardQueue&                       discardQueue;                  ///< Nodes are added here when disconnected from the scene-graph.
   RenderController&                   renderController;              ///< render controller
   SceneControllerImpl*                sceneController;               ///< scene controller
   RenderManager&                      renderManager;                 ///< This is responsible for rendering the results of each "update"
   RenderQueue&                        renderQueue;                   ///< Used to queue messages for the next render
   RenderInstructionContainer&         renderInstructions;            ///< Used to prepare the render instructions
   DiscardQueue&                       discardQueue;                  ///< Nodes are added here when disconnected from the scene-graph.
   RenderController&                   renderController;              ///< render controller
   SceneControllerImpl*                sceneController;               ///< scene controller
   RenderManager&                      renderManager;                 ///< This is responsible for rendering the results of each "update"
   RenderQueue&                        renderQueue;                   ///< Used to queue messages for the next render
   RenderInstructionContainer&         renderInstructions;            ///< Used to prepare the render instructions
-  TouchResampler&                     touchResampler;                ///< Used to resample touch events on every update.
+  RenderTaskProcessor&                renderTaskProcessor;           ///< Handles RenderTasks and RenderInstrucitons
 
   Vector4                             backgroundColor;               ///< The glClear color used at the beginning of each frame.
 
 
   Vector4                             backgroundColor;               ///< The glClear color used at the beginning of each frame.
 
@@ -246,16 +277,16 @@ struct UpdateManager::Impl
   SortedLayerPointers                 sortedLayers;                  ///< A container of Layer pointers sorted by depth
   SortedLayerPointers                 systemLevelSortedLayers;       ///< A separate container of system-level Layers
 
   SortedLayerPointers                 sortedLayers;                  ///< A container of Layer pointers sorted by depth
   SortedLayerPointers                 systemLevelSortedLayers;       ///< A separate container of system-level Layers
 
-  OwnerContainer< PropertyOwner* >    customObjects;                 ///< A container of owned objects (with custom properties)
+  CameraOwner                         cameras;                       ///< A container of cameras
+  CustomObjectOwner                   customObjects;                 ///< A container of owned objects (with custom properties)
 
   AnimationContainer                  animations;                    ///< A container of owned animations
   PropertyNotificationContainer       propertyNotifications;         ///< A container of owner property notifications.
 
 
   AnimationContainer                  animations;                    ///< A container of owned animations
   PropertyNotificationContainer       propertyNotifications;         ///< A container of owner property notifications.
 
-  ObjectOwnerContainer<Renderer>      renderers;
-  ObjectOwnerContainer<Geometry>      geometries;                    ///< A container of geometries
-  ObjectOwnerContainer<Material>      materials;                     ///< A container of materials
-
-  ShaderContainer                     shaders;                       ///< A container of owned shaders
+  RendererOwner                       renderers;                     ///< A container of owned renderers
+  TextureSetOwner                     textureSets;                   ///< A container of owned texture sets
+  ShaderOwner                         shaders;                       ///< A container of owned shaders
+  OwnerPointer<PanGesture>            panGestureProcessor;           ///< Owned pan gesture processor; it lives for the lifecycle of UpdateManager
 
   MessageQueue                        messageQueue;                  ///< The messages queued from the event-thread
   ShaderDataBinaryQueue               renderCompiledShaders;         ///< Shaders compiled on Render thread are inserted here for update thread to pass on to event thread.
 
   MessageQueue                        messageQueue;                  ///< The messages queued from the event-thread
   ShaderDataBinaryQueue               renderCompiledShaders;         ///< Shaders compiled on Render thread are inserted here for update thread to pass on to event thread.
@@ -263,43 +294,39 @@ struct UpdateManager::Impl
   Mutex                               compiledShaderMutex;           ///< lock to ensure no corruption on the renderCompiledShaders
 
   float                               keepRenderingSeconds;          ///< Set via Dali::Stage::KeepRendering
   Mutex                               compiledShaderMutex;           ///< lock to ensure no corruption on the renderCompiledShaders
 
   float                               keepRenderingSeconds;          ///< Set via Dali::Stage::KeepRendering
-  bool                                animationFinishedDuringUpdate; ///< Flag whether any animations finished during the Update()
-
   int                                 nodeDirtyFlags;                ///< cumulative node dirty flags from previous frame
   int                                 nodeDirtyFlags;                ///< cumulative node dirty flags from previous frame
-  bool                                previousUpdateScene;           ///< True if the scene was updated in the previous frame (otherwise it was optimized out)
-
   int                                 frameCounter;                  ///< Frame counter used in debugging to choose which frame to debug and which to ignore.
   int                                 frameCounter;                  ///< Frame counter used in debugging to choose which frame to debug and which to ignore.
-  RendererSortingHelper               renderSortingHelper;           ///< helper used to sort transparent renderers
 
 
-  GestureContainer                    gestures;                      ///< A container of owned gesture detectors
+  bool                                animationFinishedDuringUpdate; ///< Flag whether any animations finished during the Update()
+  bool                                previousUpdateScene;           ///< True if the scene was updated in the previous frame (otherwise it was optimized out)
   bool                                renderTaskWaiting;             ///< A REFRESH_ONCE render task is waiting to be rendered
   bool                                renderTaskWaiting;             ///< A REFRESH_ONCE render task is waiting to be rendered
+
+private:
+
+  Impl( const Impl& ); ///< Undefined
+  Impl& operator=( const Impl& ); ///< Undefined
 };
 
 UpdateManager::UpdateManager( NotificationManager& notificationManager,
                               CompleteNotificationInterface& animationFinishedNotifier,
                               PropertyNotifier& propertyNotifier,
 };
 
 UpdateManager::UpdateManager( NotificationManager& notificationManager,
                               CompleteNotificationInterface& animationFinishedNotifier,
                               PropertyNotifier& propertyNotifier,
-                              ResourceManager& resourceManager,
                               DiscardQueue& discardQueue,
                               RenderController& controller,
                               RenderManager& renderManager,
                               RenderQueue& renderQueue,
                               DiscardQueue& discardQueue,
                               RenderController& controller,
                               RenderManager& renderManager,
                               RenderQueue& renderQueue,
-                              TextureCache& textureCache,
-                              TouchResampler& touchResampler )
+                              RenderTaskProcessor& renderTaskProcessor )
   : mImpl(NULL)
 {
   mImpl = new Impl( notificationManager,
                     animationFinishedNotifier,
                     propertyNotifier,
   : mImpl(NULL)
 {
   mImpl = new Impl( notificationManager,
                     animationFinishedNotifier,
                     propertyNotifier,
-                    resourceManager,
                     discardQueue,
                     controller,
                     renderManager,
                     renderQueue,
                     discardQueue,
                     controller,
                     renderManager,
                     renderQueue,
-                    textureCache,
-                    touchResampler,
-                    mSceneGraphBuffers );
+                    mSceneGraphBuffers,
+                    renderTaskProcessor );
 
 
-  textureCache.SetBufferIndices( &mSceneGraphBuffers );
 }
 
 UpdateManager::~UpdateManager()
 }
 
 UpdateManager::~UpdateManager()
@@ -316,13 +343,13 @@ void UpdateManager::InstallRoot( SceneGraph::Layer* layer, bool systemLevel )
   {
     DALI_ASSERT_DEBUG( mImpl->root == NULL && "Root Node already installed" );
     mImpl->root = layer;
   {
     DALI_ASSERT_DEBUG( mImpl->root == NULL && "Root Node already installed" );
     mImpl->root = layer;
-    mImpl->root->CreateTransform( &mImpl->transformManager);
+    mImpl->root->CreateTransform( &mImpl->transformManager );
   }
   else
   {
     DALI_ASSERT_DEBUG( mImpl->systemLevelRoot == NULL && "System-level Root Node already installed" );
     mImpl->systemLevelRoot = layer;
   }
   else
   {
     DALI_ASSERT_DEBUG( mImpl->systemLevelRoot == NULL && "System-level Root Node already installed" );
     mImpl->systemLevelRoot = layer;
-    mImpl->systemLevelRoot->CreateTransform( &mImpl->transformManager);
+    mImpl->systemLevelRoot->CreateTransform( &mImpl->transformManager );
   }
 
   layer->SetRoot(true);
   }
 
   layer->SetRoot(true);
@@ -340,7 +367,7 @@ void UpdateManager::AddNode( Node* node )
     if(node > (*iter))
     {
       mImpl->nodes.Insert((iter+1), node);
     if(node > (*iter))
     {
       mImpl->nodes.Insert((iter+1), node);
-      node->CreateTransform( &mImpl->transformManager);
+      node->CreateTransform( &mImpl->transformManager );
       break;
     }
   }
       break;
     }
   }
@@ -386,14 +413,17 @@ void UpdateManager::DestroyNode( Node* node )
   node->OnDestroy();
 }
 
   node->OnDestroy();
 }
 
-//@todo MESH_REWORK Extend to allow arbitrary scene objects to connect to each other
-void UpdateManager::AttachToNode( Node* node, NodeAttachment* attachment )
+void UpdateManager::AddCamera( Camera* camera )
 {
 {
-  DALI_ASSERT_DEBUG( node != NULL );
-  DALI_ASSERT_DEBUG( attachment != NULL );
+  DALI_ASSERT_DEBUG( camera != NULL );
 
 
-  // attach node to attachment first so that parent is known by the time attachment is connected
-  node->Attach( *attachment ); // node takes ownership
+  mImpl->cameras.PushBack( camera ); // takes ownership
+}
+
+void UpdateManager::RemoveCamera( const Camera* camera )
+{
+  // Find the camera and destroy it
+  EraseUsingDiscardQueue( mImpl->cameras, const_cast<Camera*>( camera ), mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
 }
 
 void UpdateManager::AddObject( PropertyOwner* object )
 }
 
 void UpdateManager::AddObject( PropertyOwner* object )
@@ -405,23 +435,7 @@ void UpdateManager::AddObject( PropertyOwner* object )
 
 void UpdateManager::RemoveObject( PropertyOwner* object )
 {
 
 void UpdateManager::RemoveObject( PropertyOwner* object )
 {
-  DALI_ASSERT_DEBUG( NULL != object );
-
-  OwnerContainer< PropertyOwner* >& customObjects = mImpl->customObjects;
-
-  // Find the object and destroy it
-  for ( OwnerContainer< PropertyOwner* >::Iterator iter = customObjects.Begin(); iter != customObjects.End(); ++iter )
-  {
-    PropertyOwner* current = *iter;
-    if ( current == object )
-    {
-      customObjects.Erase( iter );
-      return;
-    }
-  }
-
-  // Should not reach here
-  DALI_ASSERT_DEBUG(false);
+  mImpl->customObjects.EraseObject( object );
 }
 
 void UpdateManager::AddAnimation( Animation* animation )
 }
 
 void UpdateManager::AddAnimation( Animation* animation )
@@ -476,18 +490,7 @@ void UpdateManager::AddPropertyNotification( PropertyNotification* propertyNotif
 
 void UpdateManager::RemovePropertyNotification( PropertyNotification* propertyNotification )
 {
 
 void UpdateManager::RemovePropertyNotification( PropertyNotification* propertyNotification )
 {
-  PropertyNotificationContainer &propertyNotifications = mImpl->propertyNotifications;
-  PropertyNotificationIter iter = propertyNotifications.Begin();
-
-  while ( iter != propertyNotifications.End() )
-  {
-    if( *iter == propertyNotification )
-    {
-      propertyNotifications.Erase(iter);
-      break;
-    }
-    ++iter;
-  }
+  mImpl->propertyNotifications.EraseObject( propertyNotification );
 }
 
 void UpdateManager::PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode )
 }
 
 void UpdateManager::PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode )
@@ -496,66 +499,17 @@ void UpdateManager::PropertyNotificationSetNotify( PropertyNotification* propert
   propertyNotification->SetNotifyMode( notifyMode );
 }
 
   propertyNotification->SetNotifyMode( notifyMode );
 }
 
-ObjectOwnerContainer<Geometry>& UpdateManager::GetGeometryOwner()
-{
-  return mImpl->geometries;
-}
-
-ObjectOwnerContainer<Renderer>& UpdateManager::GetRendererOwner()
-{
-  return mImpl->renderers;
-}
-
-
-ObjectOwnerContainer<Material>& UpdateManager::GetMaterialOwner()
-{
-  return mImpl->materials;
-}
-
 void UpdateManager::AddShader( Shader* shader )
 {
   DALI_ASSERT_DEBUG( NULL != shader );
 
 void UpdateManager::AddShader( Shader* shader )
 {
   DALI_ASSERT_DEBUG( NULL != shader );
 
-  if( mImpl->shaders.Count() == 0 )
-  {
-    // the first added shader becomes our default shader
-    // Construct message in the render queue memory; note that delete should not be called on the return value
-    typedef MessageValue1< RenderManager, Shader* > DerivedType;
-
-    // Reserve some memory inside the render queue
-    unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
-
-    // Construct message in the render queue memory; note that delete should not be called on the return value
-    new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetDefaultShader, shader );
-  }
-
   mImpl->shaders.PushBack( shader );
   mImpl->shaders.PushBack( shader );
-
-  // Allows the shader to dispatch texture requests to the cache
-  shader->Initialize( mImpl->renderQueue, mImpl->sceneController->GetTextureCache() );
 }
 
 void UpdateManager::RemoveShader( Shader* shader )
 {
 }
 
 void UpdateManager::RemoveShader( Shader* shader )
 {
-  DALI_ASSERT_DEBUG(shader != NULL);
-
-  ShaderContainer& shaders = mImpl->shaders;
-
   // Find the shader and destroy it
   // Find the shader and destroy it
-  for ( ShaderIter iter = shaders.Begin(); iter != shaders.End(); ++iter )
-  {
-    Shader& current = **iter;
-    if ( &current == shader )
-    {
-      // Transfer ownership to the discard queue
-      // This keeps the shader alive, until the render-thread has finished with it
-      mImpl->discardQueue.Add( mSceneGraphBuffers.GetUpdateBufferIndex(), shaders.Release( iter ) );
-
-      return;
-    }
-  }
-  // Should not reach here
-  DALI_ASSERT_DEBUG(false);
+  EraseUsingDiscardQueue( mImpl->shaders, shader, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
 }
 
 void UpdateManager::SetShaderProgram( Shader* shader,
 }
 
 void UpdateManager::SetShaderProgram( Shader* shader,
@@ -585,45 +539,59 @@ void UpdateManager::SaveBinary( Internal::ShaderDataPtr shaderData )
   }
 }
 
   }
 }
 
-RenderTaskList* UpdateManager::GetRenderTaskList( bool systemLevel )
+void UpdateManager::SetShaderSaver( ShaderSaver& upstream )
 {
 {
-  if ( !systemLevel )
-  {
-    // copy the list, this is only likely to happen once in application life cycle
-    return &(mImpl->taskList);
-  }
-  else
-  {
-    // copy the list, this is only likely to happen once in application life cycle
-    return &(mImpl->systemLevelTaskList);
-  }
+  mImpl->shaderSaver = &upstream;
 }
 
 }
 
-void UpdateManager::AddGesture( PanGesture* gesture )
+void UpdateManager::AddRenderer( Renderer* renderer )
 {
 {
-  DALI_ASSERT_DEBUG( NULL != gesture );
+  DALI_ASSERT_DEBUG( renderer != NULL );
 
 
-  mImpl->gestures.PushBack( gesture );
+  mImpl->renderers.PushBack( renderer );
+
+  renderer->ConnectToSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() );
 }
 
 }
 
-void UpdateManager::RemoveGesture( PanGesture* gesture )
+void UpdateManager::RemoveRenderer( Renderer* renderer )
 {
 {
-  DALI_ASSERT_DEBUG( gesture != NULL );
+  // Find the renderer and destroy it
+  EraseUsingDiscardQueue( mImpl->renderers, renderer, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex() );
+  // Need to remove the render object as well
+  renderer->DisconnectFromSceneGraph( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() );
+}
 
 
-  GestureContainer& gestures = mImpl->gestures;
+void UpdateManager::SetPanGestureProcessor( PanGesture* panGestureProcessor )
+{
+  DALI_ASSERT_DEBUG( NULL != panGestureProcessor );
+
+  mImpl->panGestureProcessor = panGestureProcessor;
+}
+
+void UpdateManager::AddTextureSet( TextureSet* textureSet )
+{
+  DALI_ASSERT_DEBUG( NULL != textureSet );
+
+  mImpl->textureSets.PushBack( textureSet );
+}
+
+void UpdateManager::RemoveTextureSet( TextureSet* textureSet )
+{
+  mImpl->textureSets.EraseObject( textureSet );
+}
 
 
-  // Find the gesture and destroy it
-  for ( GestureIter iter = gestures.Begin(), endIter = gestures.End(); iter != endIter; ++iter )
+RenderTaskList* UpdateManager::GetRenderTaskList( bool systemLevel )
+{
+  if ( !systemLevel )
   {
   {
-    PanGesture& current = **iter;
-    if ( &current == gesture )
-    {
-      mImpl->gestures.Erase( iter );
-      return;
-    }
+    // copy the list, this is only likely to happen once in application life cycle
+    return &(mImpl->taskList);
+  }
+  else
+  {
+    // copy the list, this is only likely to happen once in application life cycle
+    return &(mImpl->systemLevelTaskList);
   }
   }
-  // Should not reach here
-  DALI_ASSERT_DEBUG(false);
 }
 
 unsigned int* UpdateManager::ReserveMessageSlot( std::size_t size, bool updateScene )
 }
 
 unsigned int* UpdateManager::ReserveMessageSlot( std::size_t size, bool updateScene )
@@ -661,56 +629,36 @@ void UpdateManager::ResetProperties( BufferIndex bufferIndex )
   // Reset all the nodes
   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
   // Reset all the nodes
   Vector<Node*>::Iterator iter = mImpl->nodes.Begin()+1;
   Vector<Node*>::Iterator endIter = mImpl->nodes.End();
-  for(;iter != endIter; ++iter)
+  for( ;iter != endIter; ++iter )
   {
     (*iter)->ResetToBaseValues( bufferIndex );
   }
 
   // Reset system-level render-task list properties to base values
   {
     (*iter)->ResetToBaseValues( bufferIndex );
   }
 
   // Reset system-level render-task list properties to base values
-  const RenderTaskList::RenderTaskContainer& systemLevelTasks = mImpl->systemLevelTaskList.GetTasks();
-
-  for (RenderTaskList::RenderTaskContainer::ConstIterator iter = systemLevelTasks.Begin(); iter != systemLevelTasks.End(); ++iter)
-  {
-    (*iter)->ResetToBaseValues( bufferIndex );
-  }
+  ResetToBaseValues( mImpl->systemLevelTaskList.GetTasks(), bufferIndex );
 
   // Reset render-task list properties to base values.
 
   // Reset render-task list properties to base values.
-  const RenderTaskList::RenderTaskContainer& tasks = mImpl->taskList.GetTasks();
-
-  for (RenderTaskList::RenderTaskContainer::ConstIterator iter = tasks.Begin(); iter != tasks.End(); ++iter)
-  {
-    (*iter)->ResetToBaseValues( bufferIndex );
-  }
+  ResetToBaseValues( mImpl->taskList.GetTasks(), bufferIndex );
 
   // Reset custom object properties to base values
 
   // Reset custom object properties to base values
-  for (OwnerContainer<PropertyOwner*>::Iterator iter = mImpl->customObjects.Begin(); iter != mImpl->customObjects.End(); ++iter)
-  {
-    (*iter)->ResetToBaseValues( bufferIndex );
-  }
+  ResetToBaseValues( mImpl->customObjects, bufferIndex );
 
 
-  mImpl->materials.ResetToBaseValues( bufferIndex );
-  mImpl->geometries.ResetToBaseValues( bufferIndex );
-  mImpl->renderers.ResetToBaseValues( bufferIndex );
+  // Reset animatable renderer properties to base values
+  ResetToBaseValues( mImpl->renderers, bufferIndex );
 
   // Reset animatable shader properties to base values
 
   // Reset animatable shader properties to base values
-  for (ShaderIter iter = mImpl->shaders.Begin(); iter != mImpl->shaders.End(); ++iter)
-  {
-    (*iter)->ResetToBaseValues( bufferIndex );
-  }
+  ResetToBaseValues( mImpl->shaders, bufferIndex );
 }
 
 bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds )
 {
   bool gestureUpdated( false );
 
 }
 
 bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds )
 {
   bool gestureUpdated( false );
 
-  // constrain gestures... (in construction order)
-  GestureContainer& gestures = mImpl->gestures;
-
-  for ( GestureIter iter = gestures.Begin(), endIter = gestures.End(); iter != endIter; ++iter )
+  if( mImpl->panGestureProcessor )
   {
   {
-    PanGesture& gesture = **iter;
-    gesture.ResetToBaseValues( bufferIndex ); // Needs to be done every time as gesture data is written directly to an update-buffer rather than via a message
-    gestureUpdated |= gesture.UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
+    // gesture processor only supports default properties
+    mImpl->panGestureProcessor->ResetDefaultProperties( bufferIndex ); // Needs to be done every time as gesture data is written directly to an update-buffer rather than via a message
+    gestureUpdated |= mImpl->panGestureProcessor->UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
   }
 
   return gestureUpdated;
   }
 
   return gestureUpdated;
@@ -784,7 +732,7 @@ void UpdateManager::ConstrainRenderTasks( BufferIndex bufferIndex )
 void UpdateManager::ConstrainShaders( BufferIndex bufferIndex )
 {
   // constrain shaders... (in construction order)
 void UpdateManager::ConstrainShaders( BufferIndex bufferIndex )
 {
   // constrain shaders... (in construction order)
-  ShaderContainer& shaders = mImpl->shaders;
+  ShaderOwner& shaders = mImpl->shaders;
   for ( ShaderIter iter = shaders.Begin(); iter != shaders.End(); ++iter )
   {
     Shader& shader = **iter;
   for ( ShaderIter iter = shaders.Begin(); iter != shaders.End(); ++iter )
   {
     Shader& shader = **iter;
@@ -809,20 +757,6 @@ void UpdateManager::ProcessPropertyNotifications( BufferIndex bufferIndex )
   }
 }
 
   }
 }
 
-void UpdateManager::PrepareMaterials( BufferIndex bufferIndex )
-{
-  ObjectOwnerContainer<Material>::Iterator iter = mImpl->materials.GetObjectContainer().Begin();
-  const ObjectOwnerContainer<Material>::Iterator end = mImpl->materials.GetObjectContainer().End();
-  for( ; iter != end; ++iter )
-  {
-    //Apply constraints
-    ConstrainPropertyOwner( *(*iter), bufferIndex );
-
-    //Prepare material
-    (*iter)->Prepare( mImpl->resourceManager );
-  }
-}
-
 void UpdateManager::ForwardCompiledShadersToEventThread()
 {
   DALI_ASSERT_DEBUG( (mImpl->shaderSaver != 0) && "shaderSaver should be wired-up during startup." );
 void UpdateManager::ForwardCompiledShadersToEventThread()
 {
   DALI_ASSERT_DEBUG( (mImpl->shaderSaver != 0) && "shaderSaver should be wired-up during startup." );
@@ -852,17 +786,13 @@ void UpdateManager::ForwardCompiledShadersToEventThread()
 
 void UpdateManager::UpdateRenderers( BufferIndex bufferIndex )
 {
 
 void UpdateManager::UpdateRenderers( BufferIndex bufferIndex )
 {
-  const OwnerContainer<Renderer*>& rendererContainer( mImpl->renderers.GetObjectContainer() );
-  unsigned int rendererCount( rendererContainer.Size() );
-  for( unsigned int i(0); i<rendererCount; ++i )
+  const unsigned int rendererCount = mImpl->renderers.Count();
+  for( unsigned int i = 0; i < rendererCount; ++i )
   {
     //Apply constraints
   {
     //Apply constraints
-    ConstrainPropertyOwner( *rendererContainer[i], bufferIndex );
+    ConstrainPropertyOwner( *mImpl->renderers[i], bufferIndex );
 
 
-    if( rendererContainer[i]->IsReferenced() )
-    {
-      rendererContainer[i]->PrepareRender( bufferIndex );
-    }
+    mImpl->renderers[i]->PrepareRender( bufferIndex );
   }
 }
 
   }
 }
 
@@ -875,19 +805,17 @@ void UpdateManager::UpdateNodes( BufferIndex bufferIndex )
     return;
   }
 
     return;
   }
 
-  // Prepare resources, update shaders, update attachments, for each node
+  // Prepare resources, update shaders, for each node
   // And add the renderers to the sorted layers. Start from root, which is also a layer
   // And add the renderers to the sorted layers. Start from root, which is also a layer
-  mImpl->nodeDirtyFlags = UpdateNodesAndAttachments( *( mImpl->root ),
-                                                     bufferIndex,
-                                                     mImpl->resourceManager,
-                                                     mImpl->renderQueue );
+  mImpl->nodeDirtyFlags = UpdateNodeTree( *( mImpl->root ),
+                                          bufferIndex,
+                                          mImpl->renderQueue );
 
   if ( mImpl->systemLevelRoot )
   {
 
   if ( mImpl->systemLevelRoot )
   {
-    mImpl->nodeDirtyFlags |= UpdateNodesAndAttachments( *( mImpl->systemLevelRoot ),
-                                                        bufferIndex,
-                                                        mImpl->resourceManager,
-                                                        mImpl->renderQueue );
+    mImpl->nodeDirtyFlags |= UpdateNodeTree( *( mImpl->systemLevelRoot ),
+                                             bufferIndex,
+                                             mImpl->renderQueue );
   }
 }
 
   }
 }
 
@@ -900,18 +828,13 @@ unsigned int UpdateManager::Update( float elapsedSeconds,
   //Clear nodes/resources which were previously discarded
   mImpl->discardQueue.Clear( bufferIndex );
 
   //Clear nodes/resources which were previously discarded
   mImpl->discardQueue.Clear( bufferIndex );
 
-  //Grab any loaded resources
-  bool resourceChanged = mImpl->resourceManager.UpdateCache( bufferIndex );
-
   //Process Touches & Gestures
   //Process Touches & Gestures
-  mImpl->touchResampler.Update();
   const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 
   const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
 
-  const bool updateScene =                                  // The scene-graph requires an update if..
+  bool updateScene = // The scene-graph requires an update if..
       (mImpl->nodeDirtyFlags & RenderableUpdateFlags) ||    // ..nodes were dirty in previous frame OR
       IsAnimationRunning()                            ||    // ..at least one animation is running OR
       mImpl->messageQueue.IsSceneUpdateRequired()     ||    // ..a message that modifies the scene graph node tree is queued OR
       (mImpl->nodeDirtyFlags & RenderableUpdateFlags) ||    // ..nodes were dirty in previous frame OR
       IsAnimationRunning()                            ||    // ..at least one animation is running OR
       mImpl->messageQueue.IsSceneUpdateRequired()     ||    // ..a message that modifies the scene graph node tree is queued OR
-      resourceChanged                                 ||    // ..one or more resources were updated/changed OR
       gestureUpdated;                                       // ..a gesture property was updated
 
 
       gestureUpdated;                                       // ..a gesture property was updated
 
 
@@ -924,11 +847,10 @@ unsigned int UpdateManager::Update( float elapsedSeconds,
     mImpl->transformManager.ResetToBaseValue();
   }
 
     mImpl->transformManager.ResetToBaseValue();
   }
 
-  //Process the queued scene messages
-  mImpl->messageQueue.ProcessMessages( bufferIndex );
-
-  //Post Process Ids of resources updated by renderer
-  mImpl->resourceManager.PostProcessResources( bufferIndex );
+  // Process the queued scene messages. Note, MessageQueue::FlushQueue may be called
+  // between calling IsSceneUpdateRequired() above and here, so updateScene should
+  // be set again
+  updateScene |= mImpl->messageQueue.ProcessMessages( bufferIndex );
 
   //Forward compiled shader programs to event thread for saving
   ForwardCompiledShadersToEventThread();
 
   //Forward compiled shader programs to event thread for saving
   ForwardCompiledShadersToEventThread();
@@ -944,10 +866,7 @@ unsigned int UpdateManager::Update( float elapsedSeconds,
     //Constraint custom objects
     ConstrainCustomObjects( bufferIndex );
 
     //Constraint custom objects
     ConstrainCustomObjects( bufferIndex );
 
-    //Prepare materials and apply constraints to them
-    PrepareMaterials( bufferIndex );
-
-    //Clear the lists of renderable-attachments from the previous update
+    //Clear the lists of renderers from the previous update
     for( size_t i(0); i<mImpl->sortedLayers.size(); ++i )
     {
       mImpl->sortedLayers[i]->ClearRenderables();
     for( size_t i(0); i<mImpl->sortedLayers.size(); ++i )
     {
       mImpl->sortedLayers[i]->ClearRenderables();
@@ -962,10 +881,9 @@ unsigned int UpdateManager::Update( float elapsedSeconds,
     //This will populate each Layer with a list of renderers which are ready.
     UpdateNodes( bufferIndex );
 
     //This will populate each Layer with a list of renderers which are ready.
     UpdateNodes( bufferIndex );
 
-    //Apply constraints to RenderTasks, shaders and geometries
+    //Apply constraints to RenderTasks, shaders
     ConstrainRenderTasks( bufferIndex );
     ConstrainShaders( bufferIndex );
     ConstrainRenderTasks( bufferIndex );
     ConstrainShaders( bufferIndex );
-    mImpl->geometries.ConstrainObjects( bufferIndex );
 
     //Update renderers and apply constraints
     UpdateRenderers( bufferIndex );
 
     //Update renderers and apply constraints
     UpdateRenderers( bufferIndex );
@@ -983,22 +901,20 @@ unsigned int UpdateManager::Update( float elapsedSeconds,
 
     if ( NULL != mImpl->root )
     {
 
     if ( NULL != mImpl->root )
     {
-      ProcessRenderTasks(  bufferIndex,
-                           mImpl->taskList,
-                           *mImpl->root,
-                           mImpl->sortedLayers,
-                           mImpl->renderSortingHelper,
-                           mImpl->renderInstructions );
+      mImpl->renderTaskProcessor.Process( bufferIndex,
+                                        mImpl->taskList,
+                                        *mImpl->root,
+                                        mImpl->sortedLayers,
+                                        mImpl->renderInstructions );
 
       // Process the system-level RenderTasks last
       if ( NULL != mImpl->systemLevelRoot )
       {
 
       // Process the system-level RenderTasks last
       if ( NULL != mImpl->systemLevelRoot )
       {
-        ProcessRenderTasks(  bufferIndex,
-                             mImpl->systemLevelTaskList,
-                             *mImpl->systemLevelRoot,
-                             mImpl->systemLevelSortedLayers,
-                             mImpl->renderSortingHelper,
-                             mImpl->renderInstructions );
+        mImpl->renderTaskProcessor.Process( bufferIndex,
+                                          mImpl->systemLevelTaskList,
+                                          *mImpl->systemLevelRoot,
+                                          mImpl->systemLevelSortedLayers,
+                                          mImpl->renderInstructions );
       }
     }
   }
       }
     }
   }
@@ -1125,14 +1041,26 @@ void UpdateManager::SetLayerDepths( const SortedLayerPointers& layers, bool syst
   }
 }
 
   }
 }
 
-void UpdateManager::SetShaderSaver( ShaderSaver& upstream )
+void UpdateManager::SetDepthIndices( NodeDepths* nodeDepths )
 {
 {
-  mImpl->shaderSaver = &upstream;
+  if( nodeDepths )
+  {
+    // note,this vector is already in depth order. It could be used as-is to
+    // remove sorting in update algorithm. However, it lacks layer boundary markers.
+    for( std::vector<NodeDepthPair>::iterator iter = nodeDepths->nodeDepths.begin(),
+           end = nodeDepths->nodeDepths.end() ;
+         iter != end ; ++iter )
+    {
+      iter->node->SetDepthIndex( iter->sortedDepth );
+    }
+    delete nodeDepths;
+  }
 }
 
 void UpdateManager::AddSampler( Render::Sampler* sampler )
 {
 }
 
 void UpdateManager::AddSampler( Render::Sampler* sampler )
 {
-  typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
+  // Message has ownership of Sampler while in transit from update to render
+  typedef MessageValue1< RenderManager, OwnerPointer< Render::Sampler > > DerivedType;
 
   // Reserve some memory inside the render queue
   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 
   // Reserve some memory inside the render queue
   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
@@ -1163,20 +1091,21 @@ void UpdateManager::SetFilterMode( Render::Sampler* sampler, unsigned int minFil
   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
 }
 
   new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
 }
 
-void UpdateManager::SetWrapMode( Render::Sampler* sampler, unsigned int uWrapMode, unsigned int vWrapMode )
+void UpdateManager::SetWrapMode( Render::Sampler* sampler, unsigned int rWrapMode, unsigned int sWrapMode, unsigned int tWrapMode )
 {
 {
-  typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
+  typedef MessageValue4< RenderManager, Render::Sampler*, unsigned int, unsigned int, unsigned int > DerivedType;
 
   // Reserve some memory inside the render queue
   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 
   // Construct message in the render queue memory; note that delete should not be called on the return value
 
   // Reserve some memory inside the render queue
   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 
   // Construct message in the render queue memory; note that delete should not be called on the return value
-  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, uWrapMode, vWrapMode );
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetWrapMode, sampler, rWrapMode, sWrapMode, tWrapMode );
 }
 
 void UpdateManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
 {
 }
 
 void UpdateManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
 {
-  typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
+  // Message has ownership of format while in transit from update -> render
+  typedef MessageValue1< RenderManager, OwnerPointer< Render::PropertyBuffer > > DerivedType;
 
   // Reserve some memory inside the render queue
   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 
   // Reserve some memory inside the render queue
   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
@@ -1198,7 +1127,8 @@ void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer
 
 void UpdateManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format )
 {
 
 void UpdateManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format )
 {
-  typedef MessageValue2< RenderManager, Render::PropertyBuffer*, Render::PropertyBuffer::Format* > DerivedType;
+  // Message has ownership of format while in transit from update -> render
+  typedef MessageValue2< RenderManager, Render::PropertyBuffer*, OwnerPointer< Render::PropertyBuffer::Format > > DerivedType;
 
   // Reserve some memory inside the render queue
   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 
   // Reserve some memory inside the render queue
   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
@@ -1209,7 +1139,8 @@ void UpdateManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuff
 
 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data, size_t size )
 {
 
 void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data, size_t size )
 {
-  typedef MessageValue3< RenderManager, Render::PropertyBuffer*, Dali::Vector<char>*, size_t > DerivedType;
+  // Message has ownership of format while in transit from update -> render
+  typedef MessageValue3< RenderManager, Render::PropertyBuffer*, OwnerPointer< Dali::Vector<char> >, size_t > DerivedType;
 
   // Reserve some memory inside the render queue
   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
 
   // Reserve some memory inside the render queue
   unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
@@ -1218,6 +1149,151 @@ void UpdateManager::SetPropertyBufferData( Render::PropertyBuffer* propertyBuffe
   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
 }
 
   new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
 }
 
+void UpdateManager::AddGeometry( Render::Geometry* geometry )
+{
+  // Message has ownership of format while in transit from update -> render
+  typedef MessageValue1< RenderManager, OwnerPointer< Render::Geometry > > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddGeometry, geometry );
+}
+
+void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
+{
+  typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveGeometry, geometry );
+}
+
+void UpdateManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
+{
+  typedef MessageValue2< RenderManager, Render::Geometry*, unsigned int > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::SetGeometryType, geometry, geometryType );
+}
+
+void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
+{
+  typedef IndexBufferMessage< RenderManager > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager, geometry, indices );
+}
+
+void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
+{
+  typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveVertexBuffer, geometry, propertyBuffer );
+}
+
+void UpdateManager::AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
+{
+  typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddVertexBuffer, geometry, propertyBuffer );
+}
+
+void UpdateManager::AddTexture( Render::Texture* texture )
+{
+  // Message has ownership of Texture while in transit from update -> render
+  typedef MessageValue1< RenderManager, OwnerPointer< Render::Texture > > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddTexture, texture );
+}
+
+void UpdateManager::RemoveTexture( Render::Texture* texture)
+{
+  typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveTexture, texture );
+}
+
+void UpdateManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
+{
+  typedef MessageValue3< RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > DerivedType;
+
+  // Reserve some memory inside the message queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the message queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager, &RenderManager::UploadTexture, texture, pixelData, params );
+}
+
+void UpdateManager::GenerateMipmaps( Render::Texture* texture )
+{
+  typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::GenerateMipmaps, texture );
+}
+
+void UpdateManager::AddFrameBuffer( Render::FrameBuffer* frameBuffer )
+{
+  typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AddFrameBuffer, frameBuffer );
+}
+
+void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
+{
+  typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::RemoveFrameBuffer, frameBuffer );
+}
+
+void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, unsigned int mipmapLevel, unsigned int layer )
+{
+  typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::Texture*, unsigned int, unsigned int > DerivedType;
+
+  // Reserve some memory inside the render queue
+  unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+  // Construct message in the render queue memory; note that delete should not be called on the return value
+  new (slot) DerivedType( &mImpl->renderManager,  &RenderManager::AttachColorTextureToFrameBuffer, frameBuffer, texture, mipmapLevel, layer );
+}
+
 } // namespace SceneGraph
 
 } // namespace Internal
 } // namespace SceneGraph
 
 } // namespace Internal