Added a RendererCache and utilise it for ImageRenderer.

Tidied up ControlRenderer::DoInitialize methods.
Added ControlRerenderer::SetCachedRendererKey method to set a key and enable base ControlRenderer to cache core renderers from this key.
Added  RendererFactoryCache::Get/Save/RemoveRenderer methods.

Change-Id: I48753b8fe18293ca53477e149f00018c50122bb0

diff --git a/dali-toolkit/devel-api/controls/renderer-factory/control-renderer.h b/dali-toolkit/devel-api/controls/renderer-factory/control-renderer.h
index fe26fab..e95d906 100644 (file)
--- a/dali-toolkit/devel-api/controls/renderer-factory/control-renderer.h
+++ b/dali-toolkit/devel-api/controls/renderer-factory/control-renderer.h
@@ -116,6 +116,7 @@ public:
    * This function should be called when the control put on stage.
    *
    * @param[in] actor The actor applying this renderer.
    * This function should be called when the control put on stage.
    *
    * @param[in] actor The actor applying this renderer.

+   * @post SetOffStage should be called with the same actor when the control is put off stage otherwise memory will be leaked

    */
   void SetOnStage( Actor& actor );
 
    */
   void SetOnStage( Actor& actor );
 

diff --git a/dali-toolkit/internal/controls/renderers/border/border-renderer.cpp b/dali-toolkit/internal/controls/renderers/border/border-renderer.cpp
index 5456c32..ad46c2f 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/border/border-renderer.cpp
+++ b/dali-toolkit/internal/controls/renderers/border/border-renderer.cpp
@@ -75,8 +75,8 @@ const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
 );
 }
 
 );
 }
 

-BorderRenderer::BorderRenderer()
-: ControlRenderer(),
+BorderRenderer::BorderRenderer( RendererFactoryCache& factoryCache )
+: ControlRenderer( factoryCache ),

   mBorderColor( Color::TRANSPARENT ),
   mBorderSize( 0.f ),
   mBorderColorIndex( Property::INVALID_INDEX ),
   mBorderColor( Color::TRANSPARENT ),
   mBorderSize( 0.f ),
   mBorderColorIndex( Property::INVALID_INDEX ),


@@ -88,10 +88,8 @@ BorderRenderer::~BorderRenderer()
 {
 }
 
 {
 }
 

-void BorderRenderer::DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
+void BorderRenderer::DoInitialize( const Property::Map& propertyMap )

 {
 {

-  Initialize( factoryCache );
-

   Property::Value* color = propertyMap.Find( COLOR_NAME );
   if( !( color && color->Get(mBorderColor) ) )
   {
   Property::Value* color = propertyMap.Find( COLOR_NAME );
   if( !( color && color->Get(mBorderColor) ) )
   {


@@ -130,20 +128,35 @@ void BorderRenderer::DoCreatePropertyMap( Property::Map& map ) const
   map.Insert( SIZE_NAME, mBorderSize );
 }
 
   map.Insert( SIZE_NAME, mBorderSize );
 }
 

-void BorderRenderer::Initialize( RendererFactoryCache& factoryCache)
+void BorderRenderer::InitializeRenderer( Renderer& renderer )

 {
 {

-  mImpl->mGeometry = factoryCache.GetGeometry( RendererFactoryCache::BORDER_GEOMETRY );
-  if( !(mImpl->mGeometry) )
+  Geometry geometry = mFactoryCache.GetGeometry( RendererFactoryCache::BORDER_GEOMETRY );
+  if( !geometry )
+  {
+    geometry =  CreateBorderGeometry();
+    mFactoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, geometry );
+  }
+
+  Shader shader = mFactoryCache.GetShader( RendererFactoryCache::BORDER_SHADER );
+  if( !shader )

   {
   {

-    mImpl->mGeometry =  CreateBorderGeometry();
-    factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, mImpl->mGeometry );
+    shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+    mFactoryCache.SaveShader( RendererFactoryCache::COLOR_SHADER, shader );

   }
 
   }
 

-  mImpl->mShader = factoryCache.GetShader( RendererFactoryCache::BORDER_SHADER );
-  if( !(mImpl->mShader) )
+  if( !renderer )

   {
   {

-    mImpl->mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
-    factoryCache.SaveShader( RendererFactoryCache::COLOR_SHADER, mImpl->mShader );
+    Material material = Material::New( shader );
+    renderer = Renderer::New( geometry, material );
+  }
+  else
+  {
+    mImpl->mRenderer.SetGeometry( geometry );
+    Material material = mImpl->mRenderer.GetMaterial();
+    if( material )
+    {
+      material.SetShader( shader );
+    }

   }
 }
 
   }
 }
 

diff --git a/dali-toolkit/internal/controls/renderers/border/border-renderer.h b/dali-toolkit/internal/controls/renderers/border/border-renderer.h
index 9c53935..859cf01 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/border/border-renderer.h
+++ b/dali-toolkit/internal/controls/renderers/border/border-renderer.h
@@ -49,8 +49,10 @@ public:
 
   /**
    * @brief Constructor.
 
   /**
    * @brief Constructor.

+   *
+   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object

    */
    */

-  BorderRenderer();
+  BorderRenderer( RendererFactoryCache& factoryCache );

 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().
 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().


@@ -60,16 +62,22 @@ public:
 public:  // from ControlRenderer
 
   /**
 public:  // from ControlRenderer
 
   /**

+   * @copydoc ControlRenderer::SetClipRect
+   */
+  virtual void SetClipRect( const Rect<int>& clipRect );
+
+protected:
+
+  /**

    * @copydoc ControlRenderer::DoInitialize
    */
    * @copydoc ControlRenderer::DoInitialize
    */

-  virtual void DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap );
+  virtual void DoInitialize( const Property::Map& propertyMap );

 
   /**
 
   /**

-   * @copydoc ControlRenderer::SetClipRect
+   * @copydoc ControlRenderer::InitializeRenderer

    */
    */

-  virtual void SetClipRect( const Rect<int>& clipRect );
+  virtual void InitializeRenderer( Renderer& renderer );

 
 

-protected:

   /**
    * @copydoc ControlRenderer::DoSetOnStage
    */
   /**
    * @copydoc ControlRenderer::DoSetOnStage
    */


@@ -83,13 +91,6 @@ protected:
 public:
 
   /**
 public:
 
   /**

-   * Request the geometry and shader from the cache, if not available, create and save to the cache for sharing.
-   *
-   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object
-   */
-  void Initialize( RendererFactoryCache& factoryCache );
-
-  /**

    * Set the color of the border.
    * @param[in] color The border color.
    */
    * Set the color of the border.
    * @param[in] color The border color.
    */

diff --git a/dali-toolkit/internal/controls/renderers/color/color-renderer.cpp b/dali-toolkit/internal/controls/renderers/color/color-renderer.cpp
index 68164ea..4ca785d 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/color/color-renderer.cpp
+++ b/dali-toolkit/internal/controls/renderers/color/color-renderer.cpp
@@ -67,8 +67,8 @@ const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
 );
 }
 
 );
 }
 

-ColorRenderer::ColorRenderer()
-: ControlRenderer(),
+ColorRenderer::ColorRenderer( RendererFactoryCache& factoryCache )
+: ControlRenderer( factoryCache ),

   mBlendColorIndex( Property::INVALID_INDEX )
 {
 }
   mBlendColorIndex( Property::INVALID_INDEX )
 {
 }


@@ -77,10 +77,8 @@ ColorRenderer::~ColorRenderer()
 {
 }
 
 {
 }
 

-void ColorRenderer::DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
+void ColorRenderer::DoInitialize( const Property::Map& propertyMap )

 {
 {

-  Initialize( factoryCache );
-

   Property::Value* color = propertyMap.Find( COLOR_NAME );
   if( !( color && color->Get(mBlendColor) ) )
   {
   Property::Value* color = propertyMap.Find( COLOR_NAME );
   if( !( color && color->Get(mBlendColor) ) )
   {


@@ -114,29 +112,41 @@ void ColorRenderer::DoCreatePropertyMap( Property::Map& map ) const
   map.Insert( COLOR_NAME, mBlendColor );
 }
 
   map.Insert( COLOR_NAME, mBlendColor );
 }
 

-void ColorRenderer::DoSetOnStage( Actor& actor )
+void ColorRenderer::InitializeRenderer( Renderer& renderer )

 {
 {

-  mBlendColorIndex = (mImpl->mRenderer).RegisterProperty( COLOR_UNIFORM_NAME, mBlendColor );
-  if( mBlendColor.a < 1.f )
+  Geometry geometry = mFactoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
+  if( !geometry )

   {
   {

-    (mImpl->mRenderer).GetMaterial().SetBlendMode( BlendingMode::ON );
+    geometry =  RendererFactoryCache::CreateQuadGeometry();
+    mFactoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, geometry );

   }
   }

-}

 
 

-void ColorRenderer::Initialize( RendererFactoryCache& factoryCache)
-{
-  mImpl->mGeometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
-  if( !(mImpl->mGeometry) )
+  Shader shader = mFactoryCache.GetShader( RendererFactoryCache::COLOR_SHADER );
+  if( !shader )
+  {
+    shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+    mFactoryCache.SaveShader( RendererFactoryCache::COLOR_SHADER, shader );
+  }
+
+  if( !renderer )
+  {
+    Material material = Material::New( shader );
+    renderer = Renderer::New( geometry, material );
+  }
+  else

   {
   {

-    mImpl->mGeometry =  RendererFactoryCache::CreateQuadGeometry();
-    factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, mImpl->mGeometry );
+    mImpl->mRenderer.SetGeometry( geometry );
+    Material material = mImpl->mRenderer.GetMaterial();
+    if( material )
+    {
+      material.SetShader( shader );
+    }

   }
 
   }
 

-  mImpl->mShader = factoryCache.GetShader( RendererFactoryCache::COLOR_SHADER );
-  if( !(mImpl->mShader) )
+  mBlendColorIndex = renderer.RegisterProperty( COLOR_UNIFORM_NAME, mBlendColor );
+  if( mBlendColor.a < 1.f )

   {
   {

-    mImpl->mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
-    factoryCache.SaveShader( RendererFactoryCache::COLOR_SHADER, mImpl->mShader );
+    renderer.GetMaterial().SetBlendMode( BlendingMode::ON );

   }
 }
 
   }
 }
 

diff --git a/dali-toolkit/internal/controls/renderers/color/color-renderer.h b/dali-toolkit/internal/controls/renderers/color/color-renderer.h
index ae5ccca..82071b5 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/color/color-renderer.h
+++ b/dali-toolkit/internal/controls/renderers/color/color-renderer.h
@@ -45,8 +45,10 @@ public:
 
   /**
    * @brief Constructor.
 
   /**
    * @brief Constructor.

+   *
+   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object

    */
    */

-  ColorRenderer();
+  ColorRenderer( RendererFactoryCache& factoryCache );

 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().
 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().


@@ -56,11 +58,6 @@ public:
 public:  // from ControlRenderer
 
   /**
 public:  // from ControlRenderer
 
   /**

-   * @copydoc ControlRenderer::DoInitialize
-   */
-  virtual void DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap );
-
-  /**

    * @copydoc ControlRenderer::SetSize
    */
   virtual void SetSize( const Vector2& size );
    * @copydoc ControlRenderer::SetSize
    */
   virtual void SetSize( const Vector2& size );


@@ -81,19 +78,18 @@ public:  // from ControlRenderer
   virtual void DoCreatePropertyMap( Property::Map& map ) const;
 
 protected:
   virtual void DoCreatePropertyMap( Property::Map& map ) const;
 
 protected:

+

   /**
   /**

-   * @copydoc ControlRenderer::DoSetOnStage
+   * @copydoc ControlRenderer::DoInitialize

    */
    */

-  virtual void DoSetOnStage( Actor& actor );
-
-public:
+  virtual void DoInitialize( const Property::Map& propertyMap );

 
   /**
 
   /**

-   * Request the geometry and shader from the cache, if not available, create and save to the cache for sharing.
-   *
-   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object
+   * @copydoc ControlRenderer::InitializeRenderer

    */
    */

-  void Initialize( RendererFactoryCache& factoryCache );
+  virtual void InitializeRenderer( Renderer& renderer );
+
+public:

 
   /**
    * Set the color for rendering.
 
   /**
    * Set the color for rendering.

diff --git a/dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h b/dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h
index 47095c9..c080be2 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h
+++ b/dali-toolkit/internal/controls/renderers/control-renderer-data-impl.h
@@ -47,8 +47,8 @@ struct Internal::ControlRenderer::Impl
     void CreatePropertyMap( Property::Map& map ) const;
   };
 
     void CreatePropertyMap( Property::Map& map ) const;
   };
 

-  Geometry mGeometry;
-  Shader   mShader;
+  std::string mCachedRendererKey;  ///< The key to use for caching of the renderer. If it is empty then no caching will occur
+  RendererFactoryCache::CachedRendererPtr mCachedRenderer; ///< The current cached renderer from the Factory Cache. mCachedRenderer == null whilst this control render is offstage

   Renderer mRenderer;
 
   CustomShader* mCustomShader;
   Renderer mRenderer;
 
   CustomShader* mCustomShader;

diff --git a/dali-toolkit/internal/controls/renderers/control-renderer-impl.cpp b/dali-toolkit/internal/controls/renderers/control-renderer-impl.cpp
index 91343a4..18374e1 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/control-renderer-impl.cpp
+++ b/dali-toolkit/internal/controls/renderers/control-renderer-impl.cpp
@@ -45,8 +45,9 @@ namespace Toolkit
 namespace Internal
 {
 
 namespace Internal
 {
 

-ControlRenderer::ControlRenderer()
-: mImpl( new Impl() )
+ControlRenderer::ControlRenderer( RendererFactoryCache& factoryCache )
+: mImpl( new Impl() ),
+  mFactoryCache( factoryCache )

 {
 }
 
 {
 }
 


@@ -55,7 +56,7 @@ ControlRenderer::~ControlRenderer()
   delete mImpl;
 }
 
   delete mImpl;
 }
 

-void ControlRenderer::Initialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
+void ControlRenderer::Initialize( const Property::Map& propertyMap )

 {
   if( mImpl->mCustomShader )
   {
 {
   if( mImpl->mCustomShader )
   {


@@ -73,7 +74,12 @@ void ControlRenderer::Initialize( RendererFactoryCache& factoryCache, const Prop
       }
     }
   }
       }
     }
   }

-  DoInitialize( factoryCache, propertyMap );
+  DoInitialize( propertyMap );
+
+  if( mImpl->mIsOnStage )
+  {
+    InitializeRenderer( mImpl->mRenderer );
+  }

 }
 
 void ControlRenderer::SetSize( const Vector2& size )
 }
 
 void ControlRenderer::SetSize( const Vector2& size )


@@ -115,10 +121,57 @@ float ControlRenderer::GetDepthIndex() const
   return mImpl->mDepthIndex;
 }
 
   return mImpl->mDepthIndex;
 }
 

+void ControlRenderer::SetCachedRendererKey( const std::string& cachedRendererKey )
+{
+  if( mImpl->mCachedRendererKey == cachedRendererKey )
+  {
+    return;
+  }
+  if( !mImpl->mIsOnStage )
+  {
+    mImpl->mCachedRendererKey = cachedRendererKey;
+  }
+  else
+  {
+    //remove the cached renderer from the cache if we and the cache are the only things that hold a reference to it
+    if( mImpl->mCachedRenderer && mImpl->mCachedRenderer->ReferenceCount() == 2 )
+    {
+      mFactoryCache.RemoveRenderer( mImpl->mCachedRenderer->mKey );
+    }
+    mImpl->mCachedRenderer.Reset();
+
+    //add the new renderer
+    mImpl->mCachedRendererKey = cachedRendererKey;
+    if( !mImpl->mCachedRendererKey.empty() && !mImpl->mCustomShader )
+    {
+      DALI_ASSERT_DEBUG( mImpl->mRenderer && "The control render is on stage but it doesn't have a valid renderer.");
+      mImpl->mCachedRenderer = mFactoryCache.SaveRenderer( mImpl->mCachedRendererKey, mImpl->mRenderer );
+    }
+  }
+}
+

 void ControlRenderer::SetOnStage( Actor& actor )
 {
 void ControlRenderer::SetOnStage( Actor& actor )
 {

-  Material material = Material::New( mImpl->mShader );
-  mImpl->mRenderer = Renderer::New( mImpl->mGeometry, material );
+  if( !mImpl->mCachedRendererKey.empty() && !mImpl->mCustomShader )
+  {
+    mImpl->mCachedRenderer = mFactoryCache.GetRenderer( mImpl->mCachedRendererKey );
+    if( !mImpl->mCachedRenderer || !mImpl->mCachedRenderer->mRenderer )
+    {
+      InitializeRenderer( mImpl->mRenderer );
+      mImpl->mCachedRenderer = mFactoryCache.SaveRenderer( mImpl->mCachedRendererKey, mImpl->mRenderer );
+    }
+
+    if( mImpl->mCachedRenderer && mImpl->mCachedRenderer->mRenderer )
+    {
+      mImpl->mRenderer = mImpl->mCachedRenderer->mRenderer;
+    }
+  }
+
+  if( !mImpl->mRenderer )
+  {
+    InitializeRenderer( mImpl->mRenderer );
+  }
+

   mImpl->mRenderer.SetDepthIndex( mImpl->mDepthIndex );
   actor.AddRenderer( mImpl->mRenderer );
   mImpl->mIsOnStage = true;
   mImpl->mRenderer.SetDepthIndex( mImpl->mDepthIndex );
   actor.AddRenderer( mImpl->mRenderer );
   mImpl->mIsOnStage = true;


@@ -132,6 +185,13 @@ void ControlRenderer::SetOffStage( Actor& actor )
   {
     DoSetOffStage( actor );
 
   {
     DoSetOffStage( actor );
 

+    //remove the cached renderer from the cache if we and the cache are the only things that hold a reference to it
+    if( mImpl->mCachedRenderer && mImpl->mCachedRenderer->ReferenceCount() == 2 )
+    {
+      mFactoryCache.RemoveRenderer( mImpl->mCachedRenderer->mKey );
+    }
+    mImpl->mCachedRenderer.Reset();
+

     actor.RemoveRenderer( mImpl->mRenderer );
     mImpl->mRenderer.Reset();
 
     actor.RemoveRenderer( mImpl->mRenderer );
     mImpl->mRenderer.Reset();
 

diff --git a/dali-toolkit/internal/controls/renderers/control-renderer-impl.h b/dali-toolkit/internal/controls/renderers/control-renderer-impl.h
index 4dea2d9..10a13dc 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/control-renderer-impl.h
+++ b/dali-toolkit/internal/controls/renderers/control-renderer-impl.h
@@ -27,6 +27,7 @@
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
 #include <dali-toolkit/devel-api/controls/renderer-factory/control-renderer.h>
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
 #include <dali-toolkit/devel-api/controls/renderer-factory/control-renderer.h>

+#include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>

 
 namespace Dali
 {
 
 namespace Dali
 {


@@ -37,8 +38,6 @@ namespace Toolkit
 namespace Internal
 {
 
 namespace Internal
 {
 

-class RendererFactoryCache;
-

 /**
  * Base class for all Control rendering logic. A control may have multiple control renderers.
  *
 /**
  * Base class for all Control rendering logic. A control may have multiple control renderers.
  *


@@ -68,10 +67,9 @@ public:
    *  request the geometry and shader from the cache, if not available, create and save to the cache for sharing;
    *  record the property values.
    *
    *  request the geometry and shader from the cache, if not available, create and save to the cache for sharing;
    *  record the property values.
    *

-   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object

    * @param[in] propertyMap The properties for the requested ControlRenderer object.
    */
    * @param[in] propertyMap The properties for the requested ControlRenderer object.
    */

-  void Initialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap );
+  void Initialize( const Property::Map& propertyMap );

 
   /**
    * @copydoc Toolkit::ControlRenderer::SetSize
 
   /**
    * @copydoc Toolkit::ControlRenderer::SetSize


@@ -137,8 +135,10 @@ protected:
 
   /**
    * @brief Constructor.
 
   /**
    * @brief Constructor.

+   *
+   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object

    */
    */

-  ControlRenderer();
+  ControlRenderer( RendererFactoryCache& factoryCache );

 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().
 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().


@@ -159,7 +159,14 @@ protected:
    * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object
    * @param[in] propertyMap The properties for the requested ControlRenderer object.
    */
    * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object
    * @param[in] propertyMap The properties for the requested ControlRenderer object.
    */

-  virtual void DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap ) = 0;
+  virtual void DoInitialize( const Property::Map& propertyMap ) = 0;
+
+  /**
+   * @brief Initialises a renderer ready to be put on stage.
+   *
+   * @param[inout] renderer The Renderer to initialise. If the renderer is not empty then re-initialise the renderer
+   */
+  virtual void InitializeRenderer( Renderer& renderer ) = 0;

 
 protected:
 
 
 protected:
 


@@ -177,6 +184,15 @@ protected:
    */
   virtual void DoSetOffStage( Actor& actor );
 
    */
   virtual void DoSetOffStage( Actor& actor );
 

+protected:
+
+  /**
+   * @brief Sets the key to use for caching the renderer. If this is empty then no caching will occur
+   *
+   * @param[in] cachedRendererKey The key to use for caching the renderer.
+   */
+  void SetCachedRendererKey( const std::string& cachedRendererKey );
+

 private:
 
   // Undefined
 private:
 
   // Undefined


@@ -188,6 +204,7 @@ private:
 protected:
   struct Impl;
   Impl* mImpl;
 protected:
   struct Impl;
   Impl* mImpl;

+  RendererFactoryCache& mFactoryCache;

 };
 
 } // namespace Internal
 };
 
 } // namespace Internal

diff --git a/dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.cpp b/dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.cpp
index 71d1a38..30a587f 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.cpp
+++ b/dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.cpp
@@ -178,8 +178,9 @@ Sampler::WrapMode GetWrapMode( Gradient::SpreadMethod spread )
 }
 
 
 }
 
 

-GradientRenderer::GradientRenderer()
-:mGradientTransformIndex( Property::INVALID_INDEX )
+GradientRenderer::GradientRenderer( RendererFactoryCache& factoryCache )
+: ControlRenderer( factoryCache ),
+  mGradientType( LINEAR )

 {
 }
 
 {
 }
 


@@ -187,15 +188,8 @@ GradientRenderer::~GradientRenderer()
 {
 }
 
 {
 }
 

-void GradientRenderer::DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
+void GradientRenderer::DoInitialize( const Property::Map& propertyMap )

 {
 {

-  mImpl->mGeometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
-  if( !(mImpl->mGeometry) )
-  {
-    mImpl->mGeometry =  RendererFactoryCache::CreateQuadGeometry();
-    factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, mImpl->mGeometry );
-  }
-

   Gradient::GradientUnits gradientUnits = Gradient::OBJECT_BOUNDING_BOX;
   Property::Value* unitsValue = propertyMap.Find( GRADIENT_UNITS_NAME );
   std::string units;
   Gradient::GradientUnits gradientUnits = Gradient::OBJECT_BOUNDING_BOX;
   Property::Value* unitsValue = propertyMap.Find( GRADIENT_UNITS_NAME );
   std::string units;


@@ -206,22 +200,13 @@ void GradientRenderer::DoInitialize( RendererFactoryCache& factoryCache, const P
     gradientUnits = Gradient::USER_SPACE_ON_USE;
   }
 
     gradientUnits = Gradient::USER_SPACE_ON_USE;
   }
 

-  Type gradientType = LINEAR;
+  mGradientType = LINEAR;

   if( propertyMap.Find( GRADIENT_RADIUS_NAME ))
   {
   if( propertyMap.Find( GRADIENT_RADIUS_NAME ))
   {

-    gradientType = RADIAL;
-  }
-
-  RendererFactoryCache::ShaderType shaderType = GetShaderType( gradientType, gradientUnits );
-
-  mImpl->mShader = factoryCache.GetShader( shaderType );
-  if( !(mImpl->mShader) )
-  {
-    mImpl->mShader = Shader::New( VERTEX_SHADER[gradientUnits], FRAGMENT_SHADER[gradientType] );
-    factoryCache.SaveShader( shaderType, mImpl->mShader );
+    mGradientType = RADIAL;

   }
 
   }
 

-  if( NewGradient(gradientType, propertyMap) )
+  if( NewGradient( mGradientType, propertyMap ) )

   {
     mGradient->SetGradientUnits( gradientUnits );
     mGradientTransform = mGradient->GetAlignmentTransform();
   {
     mGradient->SetGradientUnits( gradientUnits );
     mGradientTransform = mGradient->GetAlignmentTransform();


@@ -304,20 +289,48 @@ void GradientRenderer::DoCreatePropertyMap( Property::Map& map ) const
   }
 }
 
   }
 }
 

-void GradientRenderer::DoSetOnStage( Actor& actor )
+void GradientRenderer::InitializeRenderer( Dali::Renderer& renderer )

 {
 {

-  mGradientTransformIndex = (mImpl->mRenderer).RegisterProperty( UNIFORM_ALIGNMENT_MATRIX_NAME, mGradientTransform );
+  Geometry geometry = mFactoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY );
+  if( !geometry )
+  {
+    geometry =  RendererFactoryCache::CreateQuadGeometry();
+    mFactoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, geometry );
+  }
+
+  Gradient::GradientUnits gradientUnits = mGradient->GetGradientUnits();
+  RendererFactoryCache::ShaderType shaderType = GetShaderType( mGradientType, gradientUnits );
+  Shader shader = mFactoryCache.GetShader( shaderType );
+  if( !shader )
+  {
+    shader = Shader::New( VERTEX_SHADER[gradientUnits], FRAGMENT_SHADER[ mGradientType ] );
+    mFactoryCache.SaveShader( shaderType, shader );
+  }
+
+  Material material;
+  if( !renderer )
+  {
+    material = Material::New( shader );
+    renderer = Renderer::New( geometry, material );
+  }
+  else
+  {
+    mImpl->mRenderer.SetGeometry( geometry );
+    material = mImpl->mRenderer.GetMaterial();
+    if( material )
+    {
+      material.SetShader( shader );
+    }
+  }

 
   Dali::BufferImage lookupTexture = mGradient->GenerateLookupTexture();
   Sampler sampler = Sampler::New( lookupTexture, UNIFORM_TEXTULRE_NAME );
   Sampler::WrapMode wrap = GetWrapMode( mGradient->GetSpreadMethod() );
   sampler.SetWrapMode(  wrap, wrap  );
 
 
   Dali::BufferImage lookupTexture = mGradient->GenerateLookupTexture();
   Sampler sampler = Sampler::New( lookupTexture, UNIFORM_TEXTULRE_NAME );
   Sampler::WrapMode wrap = GetWrapMode( mGradient->GetSpreadMethod() );
   sampler.SetWrapMode(  wrap, wrap  );
 

-  Material material = (mImpl->mRenderer).GetMaterial();
-  if( material )
-  {
-    material.AddSampler( sampler );
-  }
+  material.AddSampler( sampler );
+
+  renderer.RegisterProperty( UNIFORM_ALIGNMENT_MATRIX_NAME, mGradientTransform );

 }
 
 bool GradientRenderer::NewGradient(Type gradientType, const Property::Map& propertyMap)
 }
 
 bool GradientRenderer::NewGradient(Type gradientType, const Property::Map& propertyMap)

diff --git a/dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.h b/dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.h
index 0c087a2..deed3aa 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.h
+++ b/dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.h
@@ -82,8 +82,10 @@ public:
 
   /**
    * @brief Constructor.
 
   /**
    * @brief Constructor.

+   *
+   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object

    */
    */

-  GradientRenderer();
+  GradientRenderer( RendererFactoryCache& factoryCache );

 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().
 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().


@@ -93,11 +95,6 @@ public:
 public:  // from ControlRenderer
 
   /**
 public:  // from ControlRenderer
 
   /**

-   * @copydoc ControlRenderer::DoInitialize
-   */
-  virtual void DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap );
-
-  /**

    * @copydoc ControlRenderer::SetSize
    */
   virtual void SetSize( const Vector2& size );
    * @copydoc ControlRenderer::SetSize
    */
   virtual void SetSize( const Vector2& size );


@@ -119,9 +116,14 @@ public:  // from ControlRenderer
 
 protected:
   /**
 
 protected:
   /**

-   * @copydoc ControlRenderer::DoSetOnStage
+   * @copydoc ControlRenderer::DoInitialize
+   */
+  virtual void DoInitialize( const Property::Map& propertyMap );
+
+  /**
+   * @copydoc ControlRenderer::InitializeRenderer

    */
    */

-  virtual void DoSetOnStage( Actor& actor );
+  virtual void InitializeRenderer( Renderer& renderer );

 
 private:
 
 
 private:
 


@@ -150,8 +152,8 @@ private:
 private:
 
   Matrix3 mGradientTransform;
 private:
 
   Matrix3 mGradientTransform;

-  Property::Index mGradientTransformIndex;

   IntrusivePtr<Gradient> mGradient;
   IntrusivePtr<Gradient> mGradient;

+  Type mGradientType;

 };
 
 } // namespace Internal
 };
 
 } // namespace Internal

diff --git a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
index 9e07fc9..b595a48 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
+++ b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp
@@ -186,8 +186,8 @@ Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gri
 
 } //unnamed namespace
 
 
 } //unnamed namespace
 

-ImageRenderer::ImageRenderer()
-: ControlRenderer(),
+ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache )
+: ControlRenderer( factoryCache ),

   mDesiredSize(),
   mFittingMode( FittingMode::DEFAULT ),
   mSamplingMode( SamplingMode::DEFAULT )
   mDesiredSize(),
   mFittingMode( FittingMode::DEFAULT ),
   mSamplingMode( SamplingMode::DEFAULT )


@@ -198,16 +198,15 @@ ImageRenderer::~ImageRenderer()
 {
 }
 
 {
 }
 

-void ImageRenderer::DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
+void ImageRenderer::DoInitialize( const Property::Map& propertyMap )

 {
 {

-  Initialize(factoryCache);
-

   Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
   if( imageURLValue )
   {
     imageURLValue->Get( mImageUrl );
     if( !mImageUrl.empty() )
     {
   Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
   if( imageURLValue )
   {
     imageURLValue->Get( mImageUrl );
     if( !mImageUrl.empty() )
     {

+      SetCachedRendererKey( mImageUrl );

       mImage.Reset();
     }
 
       mImage.Reset();
     }
 


@@ -346,6 +345,58 @@ void ImageRenderer::SetOffset( const Vector2& offset )
 {
 }
 
 {
 }
 

+void ImageRenderer::InitializeRenderer( Renderer& renderer )
+{
+  Geometry geometry;
+  Shader shader;
+  if( !mImpl->mCustomShader )
+  {
+    geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+
+    shader = mFactoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
+    if( !shader )
+    {
+      shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+      mFactoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader );
+    }
+  }
+  else
+  {
+    geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
+
+    if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
+    {
+      shader = mFactoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
+      if( !shader )
+      {
+        shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+        mFactoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader );
+      }
+    }
+    else
+    {
+      shader  = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
+                             mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER : mImpl->mCustomShader->mFragmentShader,
+                             mImpl->mCustomShader->mHints );
+    }
+  }
+
+  if( !renderer )
+  {
+    Material material = Material::New( shader );
+    renderer = Renderer::New( geometry, material );
+  }
+  else
+  {
+    renderer.SetGeometry( geometry );
+    Material material = renderer.GetMaterial();
+    if( material )
+    {
+      material.SetShader( shader );
+    }
+  }
+}
+

 void ImageRenderer::DoSetOnStage( Actor& actor )
 {
   if( !mImageUrl.empty() && !mImage )
 void ImageRenderer::DoSetOnStage( Actor& actor )
 {
   if( !mImageUrl.empty() && !mImage )


@@ -461,53 +512,6 @@ void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const
   }
 }
 
   }
 }
 

-void ImageRenderer::Initialize( RendererFactoryCache& factoryCache )
-{
-  if( !mImpl->mCustomShader )
-  {
-    mImpl->mGeometry = CreateGeometry( factoryCache, ImageDimensions( 1, 1 ) );
-
-    mImpl->mShader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
-
-    if( !mImpl->mShader )
-    {
-      mImpl->mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
-      factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, mImpl->mShader );
-    }
-  }
-  else
-  {
-    mImpl->mGeometry = CreateGeometry( factoryCache, mImpl->mCustomShader->mGridSize );
-
-    if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
-    {
-      mImpl->mShader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER );
-
-      if( !mImpl->mShader )
-      {
-        mImpl->mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
-        factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, mImpl->mShader );
-      }
-    }
-    else
-    {
-      mImpl->mShader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
-                                    mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER : mImpl->mCustomShader->mFragmentShader,
-                                    mImpl->mCustomShader->mHints );
-    }
-  }
-
-  if( mImpl->mRenderer )
-  {
-    mImpl->mRenderer.SetGeometry( mImpl->mGeometry );
-    Material material = mImpl->mRenderer.GetMaterial();
-    if( material )
-    {
-      material.SetShader( mImpl->mShader );
-    }
-  }
-}
-

 void ImageRenderer::SetImage( const std::string& imageUrl )
 {
   SetImage( imageUrl, 0, 0, Dali::FittingMode::DEFAULT, Dali::SamplingMode::DEFAULT );
 void ImageRenderer::SetImage( const std::string& imageUrl )
 {
   SetImage( imageUrl, 0, 0, Dali::FittingMode::DEFAULT, Dali::SamplingMode::DEFAULT );


@@ -518,6 +522,7 @@ void ImageRenderer::SetImage( const std::string& imageUrl, int desiredWidth, int
   if( mImageUrl != imageUrl )
   {
     mImageUrl = imageUrl;
   if( mImageUrl != imageUrl )
   {
     mImageUrl = imageUrl;

+    SetCachedRendererKey( mImageUrl );

     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
     mFittingMode = fittingMode;
     mSamplingMode = samplingMode;
     mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
     mFittingMode = fittingMode;
     mSamplingMode = samplingMode;

diff --git a/dali-toolkit/internal/controls/renderers/image/image-renderer.h b/dali-toolkit/internal/controls/renderers/image/image-renderer.h
index 367ae31..f408fb2 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/image/image-renderer.h
+++ b/dali-toolkit/internal/controls/renderers/image/image-renderer.h
@@ -74,8 +74,10 @@ public:
 
   /**
    * @brief Constructor.
 
   /**
    * @brief Constructor.

+   *
+   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object

    */
    */

-  ImageRenderer();
+  ImageRenderer( RendererFactoryCache& factoryCache );

 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().
 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().


@@ -85,11 +87,6 @@ public:
 public:  // from ControlRenderer
 
   /**
 public:  // from ControlRenderer
 
   /**

-   * @copydoc ControlRenderer::DoInitialize
-   */
-  virtual void DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap );
-
-  /**

    * @copydoc ControlRenderer::SetSize
    */
   virtual void SetSize( const Vector2& size );
    * @copydoc ControlRenderer::SetSize
    */
   virtual void SetSize( const Vector2& size );


@@ -116,6 +113,11 @@ public:  // from ControlRenderer
 
 protected:
   /**
 
 protected:
   /**

+   * @copydoc ControlRenderer::DoInitialize
+   */
+  virtual void DoInitialize( const Property::Map& propertyMap );
+
+  /**

    * @copydoc ControlRenderer::DoSetOnStage
    */
   virtual void DoSetOnStage( Actor& actor );
    * @copydoc ControlRenderer::DoSetOnStage
    */
   virtual void DoSetOnStage( Actor& actor );


@@ -125,14 +127,12 @@ protected:
    */
   virtual void DoSetOffStage( Actor& actor );
 
    */
   virtual void DoSetOffStage( Actor& actor );
 

-public:
-

   /**
   /**

-   * Request the geometry and shader from the cache, if not available, create and save to the cache for sharing.
-   *
-   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object
+   * @copydoc ControlRenderer::InitializeRenderer

    */
    */

-  void Initialize( RendererFactoryCache& factoryCache );
+  virtual void InitializeRenderer( Renderer& renderer );
+
+public:

 
   /**
    * @brief Sets the image of this renderer to the resource at imageUrl
 
   /**
    * @brief Sets the image of this renderer to the resource at imageUrl

diff --git a/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.cpp b/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.cpp
index 842a099..63e2f5d 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.cpp
+++ b/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.cpp
@@ -150,8 +150,8 @@ void AddVertex( Vector< Vector2 >& vertices, unsigned int x, unsigned int y )
 
 /////////////////NPatchRenderer////////////////
 
 
 /////////////////NPatchRenderer////////////////
 

-NPatchRenderer::NPatchRenderer()
-: ControlRenderer(),
+NPatchRenderer::NPatchRenderer( RendererFactoryCache& factoryCache )
+: ControlRenderer( factoryCache ),

   mBorderOnly( false )
 {
 }
   mBorderOnly( false )
 {
 }


@@ -160,10 +160,8 @@ NPatchRenderer::~NPatchRenderer()
 {
 }
 
 {
 }
 

-void NPatchRenderer::DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
+void NPatchRenderer::DoInitialize( const Property::Map& propertyMap )

 {
 {

-  Initialize(factoryCache);
-

   Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
   if( imageURLValue )
   {
   Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
   if( imageURLValue )
   {


@@ -217,6 +215,51 @@ void NPatchRenderer::SetOffset( const Vector2& offset )
   //ToDo: renderer applies the offset
 }
 
   //ToDo: renderer applies the offset
 }
 

+void NPatchRenderer::InitializeRenderer( Renderer& renderer )
+{
+  Geometry geometry;
+  if( !mBorderOnly )
+  {
+    geometry = mFactoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY );
+    if( !geometry )
+    {
+      geometry = CreateGeometry( Uint16Pair( 3, 3 ) );
+      mFactoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY, geometry );
+    }
+  }
+  else
+  {
+    geometry = mFactoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY );
+    if( !geometry )
+    {
+      geometry = CreateGeometryBorder( Uint16Pair( 3, 3 ) );
+      mFactoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY, geometry );
+    }
+  }
+
+  Shader shader = mFactoryCache.GetShader( RendererFactoryCache::NINE_PATCH_SHADER );
+  if( !shader )
+  {
+    shader = Shader::New( VERTEX_SHADER_3X3, FRAGMENT_SHADER );
+    mFactoryCache.SaveShader( RendererFactoryCache::NINE_PATCH_SHADER, shader );
+  }
+
+  if( !renderer )
+  {
+    Material material = Material::New( shader );
+    renderer = Renderer::New( geometry, material );
+  }
+  else
+  {
+    mImpl->mRenderer.SetGeometry( geometry );
+    Material material = mImpl->mRenderer.GetMaterial();
+    if( material )
+    {
+      material.SetShader( shader );
+    }
+  }
+}
+

 void NPatchRenderer::DoSetOnStage( Actor& actor )
 {
   if( !mCroppedImage )
 void NPatchRenderer::DoSetOnStage( Actor& actor )
 {
   if( !mCroppedImage )


@@ -258,35 +301,6 @@ void NPatchRenderer::DoCreatePropertyMap( Property::Map& map ) const
   map.Insert( BORDER_ONLY, mBorderOnly );
 }
 
   map.Insert( BORDER_ONLY, mBorderOnly );
 }
 

-void NPatchRenderer::Initialize( RendererFactoryCache& factoryCache )
-{
-  mNinePatchGeometry = factoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY );
-  if( !(mNinePatchGeometry) )
-  {
-    mNinePatchGeometry = CreateGeometry( Uint16Pair( 3, 3 ) );
-    factoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY, mNinePatchGeometry );
-  }
-
-  mNinePatchBorderGeometry = factoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY );
-  if( !(mNinePatchBorderGeometry) )
-  {
-    mNinePatchBorderGeometry = CreateGeometryBorder( Uint16Pair( 3, 3 ) );
-    factoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY, mNinePatchBorderGeometry );
-  }
-
-  mNinePatchShader = factoryCache.GetShader( RendererFactoryCache::NINE_PATCH_SHADER );
-  if( !mNinePatchShader )
-  {
-    mNinePatchShader = Shader::New( VERTEX_SHADER_3X3, FRAGMENT_SHADER );
-    factoryCache.SaveShader( RendererFactoryCache::NINE_PATCH_SHADER, mNinePatchShader );
-  }
-
-  mImpl->mGeometry = mNinePatchGeometry;
-  mImpl->mShader = mNinePatchShader;
-
-  mImageUrl.clear();
-}
-

 void NPatchRenderer::SetImage( const std::string& imageUrl, bool borderOnly )
 {
   mBorderOnly = borderOnly;
 void NPatchRenderer::SetImage( const std::string& imageUrl, bool borderOnly )
 {
   mBorderOnly = borderOnly;


@@ -338,13 +352,6 @@ void NPatchRenderer::InitialiseFromImage( NinePatchImage nPatch )
 
   mStretchPixelsX = nPatch.GetStretchPixelsX();
   mStretchPixelsY = nPatch.GetStretchPixelsY();
 
   mStretchPixelsX = nPatch.GetStretchPixelsX();
   mStretchPixelsY = nPatch.GetStretchPixelsY();

-
-  if( mStretchPixelsX.Size() > 0 && mStretchPixelsY.Size() > 0 )
-  {
-    //only 9 patch supported for now
-    mImpl->mGeometry = !mBorderOnly ? mNinePatchGeometry : mNinePatchBorderGeometry;
-    mImpl->mShader = mNinePatchShader;
-  }

 }
 
 void NPatchRenderer::CreateErrorImage()
 }
 
 void NPatchRenderer::CreateErrorImage()


@@ -367,9 +374,6 @@ void NPatchRenderer::CreateErrorImage()
   mStretchPixelsX.PushBack( Uint16Pair( 0, mImageSize.GetWidth() ) );
   mStretchPixelsY.Clear();
   mStretchPixelsY.PushBack( Uint16Pair( 0, mImageSize.GetHeight() ) );
   mStretchPixelsX.PushBack( Uint16Pair( 0, mImageSize.GetWidth() ) );
   mStretchPixelsY.Clear();
   mStretchPixelsY.PushBack( Uint16Pair( 0, mImageSize.GetHeight() ) );

-
-  mImpl->mGeometry = mNinePatchGeometry;
-  mImpl->mShader = mNinePatchShader;

 }
 
 void NPatchRenderer::ApplyImageToSampler()
 }
 
 void NPatchRenderer::ApplyImageToSampler()

diff --git a/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.h b/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.h
index 6e5bd5d..77ba2a4 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.h
+++ b/dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.h
@@ -55,8 +55,10 @@ public:
 
   /**
    * @brief Constructor.
 
   /**
    * @brief Constructor.

+   *
+   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object

    */
    */

-  NPatchRenderer();
+  NPatchRenderer( RendererFactoryCache& factoryCache );

 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().
 
   /**
    * @brief A reference counted object may only be deleted by calling Unreference().


@@ -66,11 +68,6 @@ public:
 public:  // from ControlRenderer
 
   /**
 public:  // from ControlRenderer
 
   /**

-   * @copydoc ControlRenderer::DoInitialize
-   */
-  virtual void DoInitialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap );
-
-  /**

    * @copydoc ControlRenderer::GetNaturalSize
    */
   virtual void GetNaturalSize( Vector2& naturalSize ) const;
    * @copydoc ControlRenderer::GetNaturalSize
    */
   virtual void GetNaturalSize( Vector2& naturalSize ) const;


@@ -91,6 +88,17 @@ public:  // from ControlRenderer
   virtual void DoCreatePropertyMap( Property::Map& map ) const;
 
 protected:
   virtual void DoCreatePropertyMap( Property::Map& map ) const;
 
 protected:

+
+  /**
+   * @copydoc ControlRenderer::DoInitialize
+   */
+  virtual void DoInitialize( const Property::Map& propertyMap );
+
+  /**
+   * @copydoc ControlRenderer::InitializeRenderer
+   */
+  virtual void InitializeRenderer( Renderer& renderer );
+

   /**
    * @copydoc ControlRenderer::DoSetOnStage
    */
   /**
    * @copydoc ControlRenderer::DoSetOnStage
    */


@@ -104,13 +112,6 @@ protected:
 public:
 
   /**
 public:
 
   /**

-   * Request the geometry and shader from the cache, if not available, create and save to the cache for sharing.
-   *
-   * @param[in] factoryCache A pointer pointing to the RendererFactoryCache object
-   */
-  void Initialize( RendererFactoryCache& factoryCache );
-
-  /**

    * @brief Sets the 9 patch image of this renderer to the resource at imageUrl
    * The renderer will load the image synchronously when the associated actor is put on stage, and destroy the image when it is off stage
    *
    * @brief Sets the 9 patch image of this renderer to the resource at imageUrl
    * The renderer will load the image synchronously when the associated actor is put on stage, and destroy the image when it is off stage
    *


@@ -184,7 +185,6 @@ private:
   Image mCroppedImage;
   Geometry mNinePatchGeometry;
   Geometry mNinePatchBorderGeometry;
   Image mCroppedImage;
   Geometry mNinePatchGeometry;
   Geometry mNinePatchBorderGeometry;

-  Shader mNinePatchShader;

 
   std::string mImageUrl; ///< The url to the image resource to render if the renderer was set from an image resource url, empty otherwise
   NinePatchImage::StretchRanges mStretchPixelsX;
 
   std::string mImageUrl; ///< The url to the image resource to render if the renderer was set from an image resource url, empty otherwise
   NinePatchImage::StretchRanges mStretchPixelsX;

diff --git a/dali-toolkit/internal/controls/renderers/renderer-factory-cache.cpp b/dali-toolkit/internal/controls/renderers/renderer-factory-cache.cpp
index 41bc77c..a22f541 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/renderer-factory-cache.cpp
+++ b/dali-toolkit/internal/controls/renderers/renderer-factory-cache.cpp
@@ -17,7 +17,10 @@
 // CLASS HEADER
 #include "renderer-factory-cache.h"
 
 // CLASS HEADER
 #include "renderer-factory-cache.h"
 

-// Internal HEADER
+// EXTERNAL HEADER
+#include <dali/devel-api/common/hash.h>
+
+// INTERNAL HEADER

 #include <dali-toolkit/internal/controls/renderers/color/color-renderer.h>
 
 namespace Dali
 #include <dali-toolkit/internal/controls/renderers/color/color-renderer.h>
 
 namespace Dali


@@ -35,24 +38,8 @@ RendererFactoryCache::RendererFactoryCache()
 
 RendererFactoryCache::~RendererFactoryCache()
 {
 
 RendererFactoryCache::~RendererFactoryCache()
 {

-  for( int i=0; i<= SHADER_TYPE_MAX; i++)
-  {
-    if(mShader[i])
-    {
-      mShader[i].Reset();
-    }
-  }
-
-  for( int i=0; i<= GEOMETRY_TYPE_MAX; i++)
-  {
-    if(mGeometry[i])
-    {
-      mGeometry[i].Reset();
-    }
-  }

 }
 
 }
 

-

 Geometry RendererFactoryCache::GetGeometry( GeometryType type )
 {
   return mGeometry[type];
 Geometry RendererFactoryCache::GetGeometry( GeometryType type )
 {
   return mGeometry[type];


@@ -73,6 +60,80 @@ void RendererFactoryCache::SaveShader( ShaderType type, Shader shader )
   mShader[type] = shader;
 }
 
   mShader[type] = shader;
 }
 

+int RendererFactoryCache::FindRenderer( const std::string& key ) const
+{
+  int hash = Dali::CalculateHash( key );
+
+  HashVector::Iterator startIt = mRendererHashes.Begin();
+  HashVector::Iterator it;
+
+  for(;;)
+  {
+    it = std::find( startIt, mRendererHashes.End(), hash );
+    if( it != mRendererHashes.End() )
+    {
+      int index = it - mRendererHashes.Begin();
+      const CachedRendererPtr& cachedRenderer = mRenderers[ index ];
+
+      if( cachedRenderer && cachedRenderer->mKey == key )
+      {
+        return index;
+      }
+    }
+    else
+    {
+      break;
+    }
+    startIt = it + 1;
+  }
+
+  return -1;
+}
+
+RendererFactoryCache::CachedRendererPtr RendererFactoryCache::GetRenderer( const std::string& key ) const
+{
+  int index = FindRenderer( key );
+  if( index != -1 )
+  {
+    return mRenderers[ index ];
+  }
+  else
+  {
+    return CachedRendererPtr();
+  }
+}
+
+RendererFactoryCache::CachedRendererPtr RendererFactoryCache::SaveRenderer( const std::string& key, Renderer& renderer )
+{
+  int hash = Dali::CalculateHash( key );
+  CachedRendererPtr newCachedRenderer = new CachedRenderer( key, renderer );
+
+  CachedRenderers::iterator it = std::find(mRenderers.begin(), mRenderers.end(), CachedRendererPtr() );
+  if( it != mRenderers.end() )
+  {
+    *it = newCachedRenderer;
+    int index = it - mRenderers.begin();
+    mRendererHashes[ index ] = hash;
+  }
+  else
+  {
+    mRendererHashes.PushBack( hash );
+    mRenderers.push_back( newCachedRenderer );
+  }
+
+  return newCachedRenderer;
+}
+
+void RendererFactoryCache::RemoveRenderer( const std::string& key )
+{
+  int index = FindRenderer( key );
+  if( index != -1 )
+  {
+    mRendererHashes[ index ] = Dali::CalculateHash( "" );
+    mRenderers[ index ].Reset();
+  }
+}
+

 Geometry RendererFactoryCache::CreateQuadGeometry()
 {
   const float halfWidth = 0.5f;
 Geometry RendererFactoryCache::CreateQuadGeometry()
 {
   const float halfWidth = 0.5f;

diff --git a/dali-toolkit/internal/controls/renderers/renderer-factory-cache.h b/dali-toolkit/internal/controls/renderers/renderer-factory-cache.h
index c905b01..f546c85 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/renderer-factory-cache.h
+++ b/dali-toolkit/internal/controls/renderers/renderer-factory-cache.h
@@ -17,10 +17,13 @@
  * limitations under the License.
  */
 
  * limitations under the License.
  */
 

+#include <map>
+

 // EXTERNAL INCLUDES
 #include <dali/public-api/object/ref-object.h>
 #include <dali/devel-api/rendering/geometry.h>
 #include <dali/devel-api/rendering/shader.h>
 // EXTERNAL INCLUDES
 #include <dali/public-api/object/ref-object.h>
 #include <dali/devel-api/rendering/geometry.h>
 #include <dali/devel-api/rendering/shader.h>

+#include <dali/devel-api/rendering/renderer.h>

 
 namespace Dali
 {
 
 namespace Dali
 {


@@ -106,6 +109,47 @@ public:
    */
   static Geometry CreateQuadGeometry();
 
    */
   static Geometry CreateQuadGeometry();
 

+public:
+  struct CachedRenderer : RefObject
+  {
+    std::string mKey;
+    Renderer mRenderer;
+
+    CachedRenderer( const std::string& key, const Renderer& renderer )
+    : mKey( key ),
+      mRenderer( renderer )
+    {}
+  };
+
+  typedef IntrusivePtr< CachedRenderer > CachedRendererPtr;
+
+  /**
+   * @brief Request renderer from the url
+   *
+   * @return The cached renderer if exist in the cache. Otherwise null is returned.
+   */
+  CachedRendererPtr GetRenderer( const std::string& key ) const;
+
+  /**
+   * @brief Cache the renderer based on the given key.
+   *
+   * If the key already exists in the cache, then the cache will save an additional renderer to the cache.
+   * RemoveRenderer will then need to be called twice to remove both items from the cache.
+   *
+   * @param[in] key The key to use for caching
+   * @param[in] renderer The Renderer to be cached
+   *
+   * @return The cached renderer stored in the cache
+   */
+  CachedRendererPtr SaveRenderer( const std::string& key, Renderer& renderer );
+
+  /**
+   * @brief Removes the renderer from the cache based on the given key
+   *
+   * @param[in] key The key used for caching
+   */
+  void RemoveRenderer( const std::string& key );
+

 protected:
 
   /**
 protected:
 
   /**


@@ -124,12 +168,25 @@ protected:
   RendererFactoryCache& operator=(const RendererFactoryCache& rhs);
 
 private:
   RendererFactoryCache& operator=(const RendererFactoryCache& rhs);
 
 private:

+  typedef Dali::Vector< std::size_t > HashVector;
+  typedef std::vector< CachedRendererPtr > CachedRenderers;

 
 

+  /**
+   * @brief Finds the first index into the cached renderers from the url
+   *
+   * @return Returns the first index into the cached renderer from the url if it exists in the cache, otherwise returns -1
+   */
+  int FindRenderer( const std::string& key ) const;
+
+private:

   // ToDo: test whether using the WeakHandle could improve the performance
   //       With WeakHandle, the resource would be released automatically when no control is using it
 
   Geometry mGeometry[GEOMETRY_TYPE_MAX+1];
   Shader mShader[SHADER_TYPE_MAX+1];
   // ToDo: test whether using the WeakHandle could improve the performance
   //       With WeakHandle, the resource would be released automatically when no control is using it
 
   Geometry mGeometry[GEOMETRY_TYPE_MAX+1];
   Shader mShader[SHADER_TYPE_MAX+1];

+
+  HashVector mRendererHashes;
+  CachedRenderers mRenderers;

 };
 
 } // namespace Internal
 };
 
 } // namespace Internal

diff --git a/dali-toolkit/internal/controls/renderers/renderer-factory-impl.cpp b/dali-toolkit/internal/controls/renderers/renderer-factory-impl.cpp
index afcc452..b9d1d40 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/renderer-factory-impl.cpp
+++ b/dali-toolkit/internal/controls/renderers/renderer-factory-impl.cpp
@@ -83,35 +83,36 @@ Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Property::Ma
   std::string typeValue ;
   if( type && type->Get( typeValue ))
   {
   std::string typeValue ;
   if( type && type->Get( typeValue ))
   {

+    if( !mFactoryCache )
+    {
+      mFactoryCache = new RendererFactoryCache();
+    }
+

     if( typeValue ==  COLOR_RENDERER )
     {
     if( typeValue ==  COLOR_RENDERER )
     {

-      rendererPtr = new ColorRenderer();
+      rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );

     }
     else if( typeValue ==  GRADIENT_RENDERER )
     {
     }
     else if( typeValue ==  GRADIENT_RENDERER )
     {

-      rendererPtr = new GradientRenderer();
+      rendererPtr = new GradientRenderer( *( mFactoryCache.Get() ) );

     }
     else if( typeValue ==  IMAGE_RENDERER )
     {
     }
     else if( typeValue ==  IMAGE_RENDERER )
     {

-      rendererPtr = new ImageRenderer();
+      rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ) );

     }
     else if( typeValue ==  N_PATCH_RENDERER )
     {
     }
     else if( typeValue ==  N_PATCH_RENDERER )
     {

-      rendererPtr = new NPatchRenderer();
+      rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );

     }
     else if( typeValue == BORDER_RENDERER )
     {
     }
     else if( typeValue == BORDER_RENDERER )
     {

-      rendererPtr = new BorderRenderer();
+      rendererPtr = new BorderRenderer( *( mFactoryCache.Get() ) );

     }
   }
 
   if( rendererPtr )
   {
     }
   }
 
   if( rendererPtr )
   {

-    if( !mFactoryCache )
-    {
-      mFactoryCache = new RendererFactoryCache();
-    }
-    rendererPtr->Initialize( *( mFactoryCache.Get() ), propertyMap );
+    rendererPtr->Initialize( propertyMap );

   }
   else
   {
   }
   else
   {


@@ -123,14 +124,12 @@ Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Property::Ma
 
 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Vector4& color )
 {
 
 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Vector4& color )
 {

-  ColorRenderer* rendererPtr = new ColorRenderer();
-

   if( !mFactoryCache )
   {
     mFactoryCache = new RendererFactoryCache();
   }
   if( !mFactoryCache )
   {
     mFactoryCache = new RendererFactoryCache();
   }

-  rendererPtr->Initialize( *( mFactoryCache.Get() ) );

 
 

+  ColorRenderer* rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );

   rendererPtr->SetColor( color );
 
   return Toolkit::ControlRenderer( rendererPtr );
   rendererPtr->SetColor( color );
 
   return Toolkit::ControlRenderer( rendererPtr );


@@ -153,13 +152,16 @@ bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const V
 
 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( float borderSize, const Vector4& borderColor )
 {
 
 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( float borderSize, const Vector4& borderColor )
 {

-  BorderRenderer* rendererPtr = new BorderRenderer();
+  if( !mFactoryCache )
+  {
+    mFactoryCache = new RendererFactoryCache();
+  }
+  BorderRenderer* rendererPtr = new BorderRenderer( *mFactoryCache.Get() );

 
   if( !mFactoryCache )
   {
     mFactoryCache = new RendererFactoryCache();
   }
 
   if( !mFactoryCache )
   {
     mFactoryCache = new RendererFactoryCache();
   }

-  rendererPtr->Initialize( *( mFactoryCache.Get() ) );

 
   rendererPtr->SetBorderSize( borderSize );
   rendererPtr->SetBorderColor( borderColor );
 
   rendererPtr->SetBorderSize( borderSize );
   rendererPtr->SetBorderColor( borderColor );


@@ -177,16 +179,14 @@ Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Image& image
   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
   if( npatchImage )
   {
   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
   if( npatchImage )
   {

-    NPatchRenderer* rendererPtr = new NPatchRenderer();
-    rendererPtr->Initialize( *( mFactoryCache.Get() ) );
+    NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );

     rendererPtr->SetImage( npatchImage );
 
     return Toolkit::ControlRenderer( rendererPtr );
   }
   else
   {
     rendererPtr->SetImage( npatchImage );
 
     return Toolkit::ControlRenderer( rendererPtr );
   }
   else
   {

-    ImageRenderer* rendererPtr = new ImageRenderer();
-    rendererPtr->Initialize( *( mFactoryCache.Get() ) );
+    ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ) );

     rendererPtr->SetImage( image );
 
     return Toolkit::ControlRenderer( rendererPtr );
     rendererPtr->SetImage( image );
 
     return Toolkit::ControlRenderer( rendererPtr );


@@ -221,26 +221,21 @@ bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const I
 
 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const std::string& url )
 {
 
 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const std::string& url )
 {

+  if( !mFactoryCache )
+  {
+    mFactoryCache = new RendererFactoryCache();
+  }
+

   if( NinePatchImage::IsNinePatchUrl( url ) )
   {
   if( NinePatchImage::IsNinePatchUrl( url ) )
   {

-    NPatchRenderer* rendererPtr = new NPatchRenderer();
-    if( !mFactoryCache )
-    {
-      mFactoryCache = new RendererFactoryCache();
-    }
-    rendererPtr->Initialize( *( mFactoryCache.Get() ) );
+    NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );

     rendererPtr->SetImage( url );
 
     return Toolkit::ControlRenderer( rendererPtr );
   }
   else
   {
     rendererPtr->SetImage( url );
 
     return Toolkit::ControlRenderer( rendererPtr );
   }
   else
   {

-    ImageRenderer* rendererPtr = new ImageRenderer();
-    if( !mFactoryCache )
-    {
-      mFactoryCache = new RendererFactoryCache();
-    }
-    rendererPtr->Initialize( *( mFactoryCache.Get() ) );
+    ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ) );

     rendererPtr->SetImage( url );
 
     return Toolkit::ControlRenderer( rendererPtr );
     rendererPtr->SetImage( url );
 
     return Toolkit::ControlRenderer( rendererPtr );


@@ -308,11 +303,7 @@ bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const P
     }
   }
 
     }
   }
 

-  if( !mFactoryCache )
-  {
-    mFactoryCache = new RendererFactoryCache();
-  }
-  GetImplementation( renderer ).Initialize( *( mFactoryCache.Get() ), propertyMap );
+  GetImplementation( renderer ).Initialize( propertyMap );

   return false;
 }
 
   return false;
 }