X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fvisual-factory-cache.cpp;h=a65c7795038bf7032f3e5e57467d6e9c1c9b495d;hp=72245eda8f54e0949aa5ecca19932a275faef0b4;hb=3c90f2e19f0526a936f5664dc446addbaa25ade8;hpb=1972f043026a3e1bdcaad71c17859a8f324d1e6d

diff --git a/dali-toolkit/internal/visuals/visual-factory-cache.cpp b/dali-toolkit/internal/visuals/visual-factory-cache.cpp
index 72245ed..a65c779 100644
--- a/dali-toolkit/internal/visuals/visual-factory-cache.cpp
+++ b/dali-toolkit/internal/visuals/visual-factory-cache.cpp
@@ -1,5 +1,5 @@
- /*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+/*
+ * Copyright (c) 2021 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.
@@ -17,253 +17,440 @@
 // CLASS HEADER
 #include "visual-factory-cache.h"
 
-// EXTERNAL HEADER
+// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/image-loading.h>
 #include <dali/devel-api/common/hash.h>
 
-// INTERNAL HEADER
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
 #include <dali-toolkit/internal/visuals/color/color-visual.h>
+#include <dali-toolkit/internal/visuals/image-atlas-manager.h>
 #include <dali-toolkit/internal/visuals/svg/svg-visual.h>
+#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
+#include <dali-toolkit/devel-api/utility/npatch-helper.h>
+#include <dali/integration-api/debug.h>
 
 namespace Dali
 {
-
 namespace Toolkit
 {
-
 namespace Internal
 {
 
-VisualFactoryCache::VisualFactoryCache()
-: mSvgRasterizeThread( NULL )
+VisualFactoryCache::VisualFactoryCache(bool preMultiplyOnLoad)
+: mSvgRasterizeThread(NULL),
+  mVectorAnimationManager(),
+  mPreMultiplyOnLoad(preMultiplyOnLoad),
+  mBrokenImageInfoContainer(),
+  mDefaultBrokenImageUrl(""),
+  mUseDefaultBrokenImageOnly(true)
 {
 }
 
 VisualFactoryCache::~VisualFactoryCache()
 {
-  SvgRasterizeThread::TerminateThread( mSvgRasterizeThread );
+  SvgRasterizeThread::TerminateThread(mSvgRasterizeThread);
 }
 
-Geometry VisualFactoryCache::GetGeometry( GeometryType type )
+Geometry VisualFactoryCache::GetGeometry(GeometryType type)
 {
+  if(!mGeometry[type] && type == QUAD_GEOMETRY)
+  {
+    mGeometry[type] = CreateQuadGeometry();
+  }
+
   return mGeometry[type];
 }
 
-void VisualFactoryCache::SaveGeometry( GeometryType type, Geometry geometry )
+void VisualFactoryCache::SaveGeometry(GeometryType type, Geometry geometry)
 {
   mGeometry[type] = geometry;
 }
 
-Shader VisualFactoryCache::GetShader( ShaderType type )
+Shader VisualFactoryCache::GetShader(ShaderType type)
 {
   return mShader[type];
 }
 
-void VisualFactoryCache::SaveShader( ShaderType type, Shader shader )
+void VisualFactoryCache::SaveShader(ShaderType type, Shader shader)
 {
   mShader[type] = shader;
 }
 
-int VisualFactoryCache::FindRenderer( const std::string& key ) const
+Geometry VisualFactoryCache::CreateQuadGeometry()
 {
-  int hash = Dali::CalculateHash( key );
-
-  HashVector::Iterator startIt = mRendererHashes.Begin();
-  HashVector::Iterator it;
-
-  for(;;)
+  const float halfWidth  = 0.5f;
+  const float halfHeight = 0.5f;
+  struct QuadVertex
   {
-    it = std::find( startIt, mRendererHashes.End(), hash );
-    if( it != mRendererHashes.End() )
+    Vector2 position;
+  };
+  QuadVertex quadVertexData[4] =
     {
-      int index = it - mRendererHashes.Begin();
-      const CachedRenderer* cachedRenderer = mRenderers[ index ];
+      {Vector2(-halfWidth, -halfHeight)},
+      {Vector2(-halfWidth, halfHeight)},
+      {Vector2(halfWidth, -halfHeight)},
+      {Vector2(halfWidth, halfHeight)}};
 
-      if( cachedRenderer && cachedRenderer->mKey == key )
-      {
-        return index;
-      }
-    }
-    else
-    {
-      break;
-    }
-    startIt = it + 1;
+  Property::Map quadVertexFormat;
+  quadVertexFormat["aPosition"] = Property::VECTOR2;
+  VertexBuffer quadVertices     = VertexBuffer::New(quadVertexFormat);
+  quadVertices.SetData(quadVertexData, 4);
+
+  // Create the geometry object
+  Geometry geometry = Geometry::New();
+  geometry.AddVertexBuffer(quadVertices);
+  geometry.SetType(Geometry::TRIANGLE_STRIP);
+
+  return geometry;
+}
+
+ImageAtlasManagerPtr VisualFactoryCache::GetAtlasManager()
+{
+  if(!mAtlasManager)
+  {
+    mAtlasManager = new ImageAtlasManager();
+    mAtlasManager->SetBrokenImage(mDefaultBrokenImageUrl);
   }
 
-  return -1;
+  return mAtlasManager;
 }
 
-Renderer VisualFactoryCache::GetRenderer( const std::string& key ) const
+TextureManager& VisualFactoryCache::GetTextureManager()
 {
-  int index = FindRenderer( key );
-  if( index != -1 )
+  return mTextureManager;
+}
+
+NPatchLoader& VisualFactoryCache::GetNPatchLoader()
+{
+  return mNPatchLoader;
+}
+
+SvgRasterizeThread* VisualFactoryCache::GetSVGRasterizationThread()
+{
+  if(!mSvgRasterizeThread)
   {
-    return mRenderers[ index ]->mRenderer.GetHandle();
+    mSvgRasterizeThread = new SvgRasterizeThread();
+    mSvgRasterizeThread->Start();
   }
-  else
+  return mSvgRasterizeThread;
+}
+
+VectorAnimationManager& VisualFactoryCache::GetVectorAnimationManager()
+{
+  if(!mVectorAnimationManager)
   {
-    return Renderer();
+    mVectorAnimationManager = std::unique_ptr<VectorAnimationManager>(new VectorAnimationManager());
   }
+  return *mVectorAnimationManager;
 }
 
-void VisualFactoryCache::SaveRenderer( const std::string& key, Renderer& renderer )
+Geometry VisualFactoryCache::CreateGridGeometry(Uint16Pair gridSize)
 {
-  int hash = Dali::CalculateHash( key );
-  const CachedRenderer* cachedRenderer = new CachedRenderer( key, renderer );
+  uint16_t gridWidth  = gridSize.GetWidth();
+  uint16_t gridHeight = gridSize.GetHeight();
 
-  CachedRenderers::Iterator it = std::find( mRenderers.Begin(), mRenderers.End(), static_cast< CachedRenderer* >( NULL ) );
-  if( it != mRenderers.End() )
+  // Create vertices
+  Vector<Vector2> vertices;
+  vertices.Reserve((gridWidth + 1) * (gridHeight + 1));
+
+  for(int y = 0; y < gridHeight + 1; ++y)
   {
-    *it = cachedRenderer;
-    int index = it - mRenderers.Begin();
-    mRendererHashes[ index ] = hash;
+    for(int x = 0; x < gridWidth + 1; ++x)
+    {
+      vertices.PushBack(Vector2((float)x / gridWidth - 0.5f, (float)y / gridHeight - 0.5f));
+    }
   }
-  else
+
+  // Create indices
+  Vector<unsigned short> indices;
+  indices.Reserve((gridWidth + 2) * gridHeight * 2 - 2);
+
+  for(unsigned int row = 0u; row < gridHeight; ++row)
   {
-    mRendererHashes.PushBack( hash );
-    mRenderers.PushBack( cachedRenderer );
+    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;
+  VertexBuffer vertexBuffer = VertexBuffer::New(vertexFormat);
+  if(vertices.Size() > 0)
+  {
+    vertexBuffer.SetData(&vertices[0], vertices.Size());
+  }
+
+  Property::Map indexFormat;
+  indexFormat["indices"]         = Property::INTEGER;
+  VertexBuffer indexVertexBuffer = VertexBuffer::New(indexFormat);
+
+  // Create the geometry object
+  Geometry geometry = Geometry::New();
+  geometry.AddVertexBuffer(vertexBuffer);
+  if(indices.Size() > 0)
+  {
+    geometry.SetIndexBuffer(&indices[0], indices.Size());
   }
+
+  geometry.SetType(Geometry::TRIANGLE_STRIP);
+
+  return geometry;
 }
 
-bool VisualFactoryCache::CleanRendererCache( const std::string& key )
+Texture VisualFactoryCache::GetBrokenVisualImage(uint32_t brokenIndex)
 {
-  int index = FindRenderer( key );
-  if( index != -1 )
+  if(!(mBrokenImageInfoContainer[brokenIndex].texture))
   {
-    const CachedRenderer*& cachedRenderer = mRenderers[ index ];
-    if( !cachedRenderer->mRenderer.GetHandle() )
+    PixelData          pixelData;
+    Devel::PixelBuffer pixelBuffer = LoadImageFromFile(mBrokenImageInfoContainer[brokenIndex].url);
+    if(pixelBuffer)
     {
-      mRendererHashes[ index ] = Dali::INITIAL_HASH_VALUE;
-
-      delete cachedRenderer;
-      cachedRenderer = NULL;
-      return true;
+      pixelData                = Devel::PixelBuffer::Convert(pixelBuffer); // takes ownership of buffer
+      mBrokenImageInfoContainer[brokenIndex].texture  = Texture::New(Dali::TextureType::TEXTURE_2D, pixelData.GetPixelFormat(), pixelData.GetWidth(), pixelData.GetHeight());
+      mBrokenImageInfoContainer[brokenIndex].texture.Upload(pixelData);
+      mBrokenImageInfoContainer[brokenIndex].width = pixelData.GetWidth();
+      mBrokenImageInfoContainer[brokenIndex].height = pixelData.GetHeight();
     }
   }
-  return false;
+  return mBrokenImageInfoContainer[brokenIndex].texture;
 }
 
-void VisualFactoryCache::CacheDebugVisual( Renderer& renderer )
+void VisualFactoryCache::SetPreMultiplyOnLoad(bool preMultiply)
 {
-  mDebugVisual = renderer;
+  mPreMultiplyOnLoad = preMultiply;
 }
 
-Renderer VisualFactoryCache::GetDebugVisual()
+bool VisualFactoryCache::GetPreMultiplyOnLoad()
 {
-  return mDebugVisual;
+  return mPreMultiplyOnLoad;
 }
 
-Geometry VisualFactoryCache::CreateQuadGeometry()
+void VisualFactoryCache::SetBrokenImageUrl(std::string& defaultBrokenUrl, const std::vector<std::string>& brokenImageUrlList)
 {
-  const float halfWidth = 0.5f;
-  const float halfHeight = 0.5f;
-  struct QuadVertex { Vector2 position;};
-  QuadVertex quadVertexData[4] =
+  mUseDefaultBrokenImageOnly = false;
+  mBrokenImageInfoContainer.clear();
+  mBrokenImageInfoContainer.assign(brokenImageUrlList.size(), BrokenImageInfo());
+  for(unsigned int i = 0; i < brokenImageUrlList.size(); i++)
   {
-      { Vector2(-halfWidth, -halfHeight) },
-      { Vector2(-halfWidth, halfHeight)  },
-      { Vector2( halfWidth, -halfHeight) },
-      { Vector2( halfWidth, halfHeight)  }
-  };
+    mBrokenImageInfoContainer[i].url = brokenImageUrlList[i];
+  }
 
-  Property::Map quadVertexFormat;
-  quadVertexFormat["aPosition"] = Property::VECTOR2;
-  PropertyBuffer quadVertices = PropertyBuffer::New( quadVertexFormat );
-  quadVertices.SetData( quadVertexData, 4 );
+  mDefaultBrokenImageUrl = defaultBrokenUrl;
+}
 
-  // Create the geometry object
-  Geometry geometry = Geometry::New();
-  geometry.AddVertexBuffer( quadVertices );
-  geometry.SetGeometryType( Geometry::TRIANGLE_STRIP );
+VisualUrl::Type VisualFactoryCache::GetBrokenImageVisualType(int index)
+{
+  return mBrokenImageInfoContainer[index].visualType;
+}
 
+Geometry VisualFactoryCache::GetNPatchGeometry(int index)
+{
+  Geometry          geometry;
+  const NPatchData* data;
+  if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
+  {
+    if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
+    {
+      geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
+      if(!geometry)
+      {
+        geometry = NPatchHelper::CreateGridGeometry(Uint16Pair(3,3));
+        SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
+      }
+    }
+    else if(data->GetStretchPixelsX().Size() > 0 || data->GetStretchPixelsY().Size() > 0)
+    {
+      Uint16Pair gridSize(2 * data->GetStretchPixelsX().Size() + 1, 2 * data->GetStretchPixelsY().Size() + 1);
+      geometry = NPatchHelper::CreateGridGeometry(gridSize);
+    }
+  }
+  else
+  {
+    // no N patch data so use default geometry
+    geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
+    if(!geometry)
+    {
+      geometry = NPatchHelper::CreateGridGeometry(Uint16Pair(3,3));
+      SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
+    }
+  }
   return geometry;
 }
 
-SvgRasterizeThread* VisualFactoryCache::GetSVGRasterizationThread()
+Shader VisualFactoryCache::GetNPatchShader(int index)
 {
-  if( !mSvgRasterizeThread )
+  Shader            shader;
+  const NPatchData* data;
+  // 0 is either no data (load failed?) or no stretch regions on image
+  // for both cases we use the default shader
+  NPatchUtility::StretchRanges::SizeType xStretchCount = 0;
+  NPatchUtility::StretchRanges::SizeType yStretchCount = 0;
+
+  // ask loader for the regions
+  if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data))
   {
-    mSvgRasterizeThread = new SvgRasterizeThread( new EventThreadCallback( MakeCallback( this, &VisualFactoryCache::ApplyRasterizedSVGToSampler ) ) );
-    mSvgRasterizeThread->Start();
+    xStretchCount = data->GetStretchPixelsX().Count();
+    yStretchCount = data->GetStretchPixelsY().Count();
   }
-  return mSvgRasterizeThread;
+
+  if(DALI_LIKELY((xStretchCount == 0 && yStretchCount == 0) || (xStretchCount == 1 && yStretchCount == 1)))
+  {
+    shader = GetShader(VisualFactoryCache::NINE_PATCH_SHADER);
+    if(DALI_UNLIKELY(!shader))
+    {
+      shader = Shader::New(SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, SHADER_NPATCH_VISUAL_SHADER_FRAG);
+
+      // Only cache vanilla 9 patch shaders
+      SaveShader(VisualFactoryCache::NINE_PATCH_SHADER, shader);
+    }
+  }
+  else if(xStretchCount > 0 || yStretchCount > 0)
+  {
+    std::stringstream vertexShader;
+    vertexShader << "#define FACTOR_SIZE_X " << xStretchCount + 2 << "\n"
+                 << "#define FACTOR_SIZE_Y " << yStretchCount + 2 << "\n"
+                 << SHADER_NPATCH_VISUAL_SHADER_VERT;
+    shader = Shader::New(vertexShader.str(), SHADER_NPATCH_VISUAL_SHADER_FRAG);
+  }
+  return shader;
 }
 
-void VisualFactoryCache::ApplyRasterizedSVGToSampler()
+void VisualFactoryCache::ApplyTextureAndUniforms(Renderer& renderer, int index)
 {
-  while( RasterizingTaskPtr task = mSvgRasterizeThread->NextCompletedTask() )
+  const NPatchData* data;
+  TextureSet        textureSet;
+  if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
   {
-    task->GetSvgVisual()->ApplyRasterizedImage( task->GetPixelData() );
+    textureSet = data->GetTextures();
+    mBrokenImageInfoContainer[index].texture = textureSet.GetTexture(0);
+    NPatchHelper::ApplyTextureAndUniforms(renderer, data);
+    renderer.SetTextures(textureSet);
   }
 }
 
-Geometry VisualFactoryCache::CreateGridGeometry( Uint16Pair gridSize )
+void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size)
 {
-  uint16_t gridWidth = gridSize.GetWidth();
-  uint16_t gridHeight = gridSize.GetHeight();
 
-  // Create vertices
-  Vector< Vector2 > vertices;
-  vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) );
+  bool useDefaultBrokenImage = false;
+  if(mBrokenImageInfoContainer.size() == 0)
+  {
+    useDefaultBrokenImage = true;
+  }
 
-  for( int y = 0; y < gridHeight + 1; ++y )
+  // Load Information for broken image
+  for(uint32_t index = 0; (index  < mBrokenImageInfoContainer.size()) && !useDefaultBrokenImage; index++)
   {
-    for( int x = 0; x < gridWidth + 1; ++x )
+    if(mBrokenImageInfoContainer[index].width == 0 && mBrokenImageInfoContainer[index].height == 0)
     {
-      vertices.PushBack( Vector2( (float)x/gridWidth - 0.5f, (float)y/gridHeight  - 0.5f) );
+      if(!mBrokenImageInfoContainer[index].url.empty())
+      {
+        VisualUrl visualUrl(mBrokenImageInfoContainer[index].url);
+        mBrokenImageInfoContainer[index].visualType = visualUrl.GetType();
+        if(mBrokenImageInfoContainer[index].visualType == VisualUrl::Type::N_PATCH)
+        {
+          const NPatchData* data;
+          Rect<int> border;
+          mBrokenImageInfoContainer[index].npatchId = mNPatchLoader.Load( mTextureManager, NULL, mBrokenImageInfoContainer[index].url, border, mPreMultiplyOnLoad, true);
+          if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
+          {
+            mBrokenImageInfoContainer[index].width = data->GetCroppedWidth();
+            mBrokenImageInfoContainer[index].height = data->GetCroppedHeight();
+          }
+          else
+          {
+            DALI_LOG_ERROR("Can't update renderer for broken image. maybe image loading is failed [index:%d] [path:%s] \n",index, mBrokenImageInfoContainer[index].url.c_str());
+            useDefaultBrokenImage = true;
+          }
+        }
+        else
+        {
+          if(!GetBrokenVisualImage(index))
+          {
+            DALI_LOG_ERROR("Can't update renderer for broken image. maybe image loading is failed [index:%d] [path:%s] \n",index, mBrokenImageInfoContainer[index].url.c_str());
+            useDefaultBrokenImage = true;
+          }
+        }
+      }
     }
   }
 
-  // Create indices
-  Vector< unsigned short > indices;
-  indices.Reserve( (gridWidth+2)*gridHeight*2 - 2);
+  if(!mUseDefaultBrokenImageOnly && useDefaultBrokenImage)
+  {
+    // Clear broken info
+    mBrokenImageInfoContainer.clear();
+
+    // assign for broken image
+    const int defaultBrokenIndex = 0;
+    mBrokenImageInfoContainer.assign(1, BrokenImageInfo());
+    mBrokenImageInfoContainer[defaultBrokenIndex].url = mDefaultBrokenImageUrl;
+    VisualUrl visualUrl(mBrokenImageInfoContainer[defaultBrokenIndex].url);
+    mBrokenImageInfoContainer[defaultBrokenIndex].visualType = visualUrl.GetType();
+    mUseDefaultBrokenImageOnly = true;
+  }
 
-  for( unsigned int row = 0u; row < gridHeight; ++row )
+  // Set Texutre to renderer
+  int brokenIndex = GetProperBrokenImageIndex(size);
+  if(GetBrokenImageVisualType(brokenIndex) == VisualUrl::N_PATCH)
   {
-    unsigned int rowStartIndex = row*(gridWidth+1u);
-    unsigned int nextRowStartIndex = rowStartIndex + gridWidth +1u;
+    // Set geometry and shader for npatch
+    Geometry geometry = GetNPatchGeometry(brokenIndex);
+    Shader shader = GetNPatchShader(brokenIndex);
+    renderer.SetGeometry(geometry);
+    renderer.SetShader(shader);
+    ApplyTextureAndUniforms(renderer, brokenIndex);
+  }
+  else
+  {
+    Texture brokenImage = GetBrokenVisualImage(brokenIndex);
+    TextureSet textureSet = TextureSet::New();
+    textureSet.SetTexture(0u, brokenImage);
+    renderer.SetTextures(textureSet);
+  }
+}
 
-    if( row != 0u ) // degenerate index on non-first row
-    {
-      indices.PushBack( rowStartIndex );
-    }
+int32_t VisualFactoryCache::GetProperBrokenImageIndex(const Vector2& size)
+{
+  // Sets the default broken type
+  int32_t returnIndex = 0;
+  if((size.width == 0 || size.height == 0) || mUseDefaultBrokenImageOnly )
+  {
+    // To do : Need to add observer about size
+    return returnIndex;
+  }
 
-    for( unsigned int column = 0u; column < gridWidth+1u; column++) // main strip
+  // Find the proper value if we know the size of the image
+  for(int32_t index = static_cast<int32_t>(mBrokenImageInfoContainer.size()) - 1; index >= 0; index--)
+  {
+    // Skip if the value is not set
+    if(mBrokenImageInfoContainer[index].width == 0 || mBrokenImageInfoContainer[index].height == 0)
     {
-      indices.PushBack( rowStartIndex + column);
-      indices.PushBack( nextRowStartIndex + column);
+      continue;
     }
 
-    if( row != gridHeight-1u ) // degenerate index on non-last row
+    if(mBrokenImageInfoContainer[index].width < size.width && mBrokenImageInfoContainer[index].height < size.height)
     {
-      indices.PushBack( nextRowStartIndex + gridWidth );
+      returnIndex = index;
+      break;
     }
   }
 
-  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;
+  return returnIndex;
 }
 
 } // namespace Internal
@@ -271,4 +458,3 @@ Geometry VisualFactoryCache::CreateGridGeometry( Uint16Pair gridSize )
 } // namespace Toolkit
 
 } // namespace Dali
-