Remove Geometry::QUAD() usage in Toolkit

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / renderers / renderer-factory-cache.cpp

diff --git a/dali-toolkit/internal/controls/renderers/renderer-factory-cache.cpp b/dali-toolkit/internal/controls/renderers/renderer-factory-cache.cpp
index a22f541..4fd7424 100644 (file)
--- a/dali-toolkit/internal/controls/renderers/renderer-factory-cache.cpp
+++ b/dali-toolkit/internal/controls/renderers/renderer-factory-cache.cpp
@@ -22,6 +22,7 @@
 
 // INTERNAL HEADER
 #include <dali-toolkit/internal/controls/renderers/color/color-renderer.h>
+#include <dali-toolkit/internal/controls/renderers/svg/svg-renderer.h>
 
 namespace Dali
 {
@@ -33,11 +34,13 @@ namespace Internal
 {
 
 RendererFactoryCache::RendererFactoryCache()
+: mSvgRasterizeThread( NULL )
 {
 }
 
 RendererFactoryCache::~RendererFactoryCache()
 {
+  SvgRasterizeThread::TerminateThread( mSvgRasterizeThread );
 }
 
 Geometry RendererFactoryCache::GetGeometry( GeometryType type )
@@ -73,7 +76,7 @@ int RendererFactoryCache::FindRenderer( const std::string& key ) const
     if( it != mRendererHashes.End() )
     {
       int index = it - mRendererHashes.Begin();
-      const CachedRendererPtr& cachedRenderer = mRenderers[ index ];
+      const CachedRenderer* cachedRenderer = mRenderers[ index ];
 
       if( cachedRenderer && cachedRenderer->mKey == key )
       {
@@ -90,48 +93,64 @@ int RendererFactoryCache::FindRenderer( const std::string& key ) const
   return -1;
 }
 
-RendererFactoryCache::CachedRendererPtr RendererFactoryCache::GetRenderer( const std::string& key ) const
+Renderer RendererFactoryCache::GetRenderer( const std::string& key ) const
 {
   int index = FindRenderer( key );
   if( index != -1 )
   {
-    return mRenderers[ index ];
+    return mRenderers[ index ]->mRenderer.GetHandle();
   }
   else
   {
-    return CachedRendererPtr();
+    return Renderer();
   }
 }
 
-RendererFactoryCache::CachedRendererPtr RendererFactoryCache::SaveRenderer( const std::string& key, Renderer& renderer )
+void RendererFactoryCache::SaveRenderer( const std::string& key, Renderer& renderer )
 {
   int hash = Dali::CalculateHash( key );
-  CachedRendererPtr newCachedRenderer = new CachedRenderer( key, renderer );
+  const CachedRenderer* cachedRenderer = new CachedRenderer( key, renderer );
 
-  CachedRenderers::iterator it = std::find(mRenderers.begin(), mRenderers.end(), CachedRendererPtr() );
-  if( it != mRenderers.end() )
+  CachedRenderers::Iterator it = std::find( mRenderers.Begin(), mRenderers.End(), static_cast< CachedRenderer* >( NULL ) );
+  if( it != mRenderers.End() )
   {
-    *it = newCachedRenderer;
-    int index = it - mRenderers.begin();
+    *it = cachedRenderer;
+    int index = it - mRenderers.Begin();
     mRendererHashes[ index ] = hash;
   }
   else
   {
     mRendererHashes.PushBack( hash );
-    mRenderers.push_back( newCachedRenderer );
+    mRenderers.PushBack( cachedRenderer );
   }
-
-  return newCachedRenderer;
 }
 
-void RendererFactoryCache::RemoveRenderer( const std::string& key )
+bool RendererFactoryCache::CleanRendererCache( const std::string& key )
 {
   int index = FindRenderer( key );
   if( index != -1 )
   {
-    mRendererHashes[ index ] = Dali::CalculateHash( "" );
-    mRenderers[ index ].Reset();
+    const CachedRenderer*& cachedRenderer = mRenderers[ index ];
+    if( !cachedRenderer->mRenderer.GetHandle() )
+    {
+      mRendererHashes[ index ] = Dali::INITIAL_HASH_VALUE;
+
+      delete cachedRenderer;
+      cachedRenderer = NULL;
+      return true;
+    }
   }
+  return false;
+}
+
+void RendererFactoryCache::CacheDebugRenderer( Renderer& renderer )
+{
+  mDebugRenderer = renderer;
+}
+
+Renderer RendererFactoryCache::GetDebugRenderer()
+{
+  return mDebugRenderer;
 }
 
 Geometry RendererFactoryCache::CreateQuadGeometry()
@@ -142,15 +161,15 @@ Geometry RendererFactoryCache::CreateQuadGeometry()
   QuadVertex quadVertexData[4] =
   {
       { Vector2(-halfWidth, -halfHeight) },
-      { Vector2( halfWidth, -halfHeight) },
       { Vector2(-halfWidth, halfHeight)  },
+      { Vector2( halfWidth, -halfHeight) },
       { Vector2( halfWidth, halfHeight)  }
   };
 
   Property::Map quadVertexFormat;
   quadVertexFormat["aPosition"] = Property::VECTOR2;
-  PropertyBuffer quadVertices = PropertyBuffer::New( quadVertexFormat, 4 );
-  quadVertices.SetData(quadVertexData);
+  PropertyBuffer quadVertices = PropertyBuffer::New( quadVertexFormat );
+  quadVertices.SetData( quadVertexData, 4 );
 
   // Create the geometry object
   Geometry geometry = Geometry::New();
@@ -160,6 +179,93 @@ Geometry RendererFactoryCache::CreateQuadGeometry()
   return geometry;
 }
 
+SvgRasterizeThread* RendererFactoryCache::GetSVGRasterizationThread()
+{
+  if( !mSvgRasterizeThread )
+  {
+    mSvgRasterizeThread = new SvgRasterizeThread( new EventThreadCallback( MakeCallback( this, &RendererFactoryCache::ApplyRasterizedSVGToSampler ) ) );
+    mSvgRasterizeThread->Start();
+  }
+  return mSvgRasterizeThread;
+}
+
+void RendererFactoryCache::ApplyRasterizedSVGToSampler()
+{
+  while( RasterizingTaskPtr task = mSvgRasterizeThread->NextCompletedTask() )
+  {
+    task->GetSvgRenderer()->ApplyRasterizedImage( task->GetPixelData() );
+  }
+}
+
+Geometry RendererFactoryCache::CreateGridGeometry( Uint16Pair gridSize )
+{
+  uint16_t gridWidth = gridSize.GetWidth();
+  uint16_t gridHeight = gridSize.GetHeight();
+
+  // Create vertices
+  Vector< Vector2 > vertices;
+  vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) );
+
+  for( int y = 0; y < gridHeight + 1; ++y )
+  {
+    for( int x = 0; x < gridWidth + 1; ++x )
+    {
+      vertices.PushBack( Vector2( (float)x/gridWidth - 0.5f, (float)y/gridHeight  - 0.5f) );
+    }
+  }
+
+  // Create indices
+  Vector< unsigned short > indices;
+  indices.Reserve( (gridWidth+2)*gridHeight*2 - 2);
+
+  for( unsigned int row = 0u; row < gridHeight; ++row )
+  {
+    unsigned int rowStartIndex = row*(gridWidth+1u);
+    unsigned int nextRowStartIndex = rowStartIndex + gridWidth +1u;
+
+    if( row != 0u ) // degenerate index on non-first row
+    {
+      indices.PushBack( rowStartIndex );
+    }
+
+    for( unsigned int column = 0u; column < gridWidth+1u; column++) // main strip
+    {
+      indices.PushBack( rowStartIndex + column);
+      indices.PushBack( nextRowStartIndex + column);
+    }
+
+    if( row != gridHeight-1u ) // degenerate index on non-last row
+    {
+      indices.PushBack( nextRowStartIndex + gridWidth );
+    }
+  }
+
+  Property::Map vertexFormat;
+  vertexFormat[ "aPosition" ] = Property::VECTOR2;
+  PropertyBuffer vertexPropertyBuffer = PropertyBuffer::New( vertexFormat );
+  if( vertices.Size() > 0 )
+  {
+    vertexPropertyBuffer.SetData( &vertices[ 0 ], vertices.Size() );
+  }
+
+  Property::Map indexFormat;
+  indexFormat[ "indices" ] = Property::INTEGER;
+  PropertyBuffer indexPropertyBuffer = PropertyBuffer::New( indexFormat );
+
+
+  // Create the geometry object
+  Geometry geometry = Geometry::New();
+  geometry.AddVertexBuffer( vertexPropertyBuffer );
+  if( indices.Size() > 0 )
+  {
+    geometry.SetIndexBuffer( &indices[ 0 ], indices.Size() );
+  }
+
+  geometry.SetGeometryType( Geometry::TRIANGLE_STRIP );
+
+  return geometry;
+}
+
 } // namespace Internal
 
 } // namespace Toolkit