Support SVG thread pool

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / visual-factory-cache.cpp

diff --git a/dali-toolkit/internal/visuals/visual-factory-cache.cpp b/dali-toolkit/internal/visuals/visual-factory-cache.cpp
index febd285..6b4bf10 100644 (file)
--- a/dali-toolkit/internal/visuals/visual-factory-cache.cpp
+++ b/dali-toolkit/internal/visuals/visual-factory-cache.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.


@@ -22,11 +22,13 @@
 #include <dali/devel-api/common/hash.h>
 
 // INTERNAL INCLUDES
 #include <dali/devel-api/common/hash.h>
 
 // INTERNAL INCLUDES

+#include <dali-toolkit/devel-api/utility/npatch-helper.h>
+#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>

 #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/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/internal/visuals/visual-string-constants.h>

 #include <dali/integration-api/debug.h>
 
 namespace Dali
 #include <dali/integration-api/debug.h>
 
 namespace Dali


@@ -37,77 +39,21 @@ namespace Internal
 {
 namespace
 {
 {
 namespace
 {

-
-/**
- * @brief Creates the geometry formed from the vertices and indices
- *
- * @param[in]  vertices             The vertices to generate the geometry from
- * @param[in]  indices              The indices to generate the geometry from
- * @return The geometry formed from the vertices and indices
- */
-Geometry GenerateGeometry(const Vector<Vector2>& vertices, const Vector<unsigned short>& indices)
-{
-  Property::Map vertexFormat;
-  vertexFormat["aPosition"] = Property::VECTOR2;
-  VertexBuffer vertexBuffer = VertexBuffer::New(vertexFormat);
-  if(vertices.Size() > 0)
-  {
-    vertexBuffer.SetData(&vertices[0], vertices.Size());
-  }
-
-  // Create the geometry object
-  Geometry geometry = Geometry::New();
-  geometry.AddVertexBuffer(vertexBuffer);
-  if(indices.Size() > 0)
-  {
-    geometry.SetIndexBuffer(&indices[0], indices.Size());
-  }
-
-  return geometry;
+const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);

 }
 
 }
 

-/**
- * @brief Adds the indices to form a quad composed off two triangles where the indices are organised in a grid
- *
- * @param[out] indices     The indices to add to
- * @param[in]  rowIdx      The row index to start the quad
- * @param[in]  nextRowIdx  The index to the next row
- */
-void AddQuadIndices(Vector<unsigned short>& indices, unsigned int rowIdx, unsigned int nextRowIdx)
-{
-  indices.PushBack(rowIdx);
-  indices.PushBack(nextRowIdx + 1);
-  indices.PushBack(rowIdx + 1);
-
-  indices.PushBack(rowIdx);
-  indices.PushBack(nextRowIdx);
-  indices.PushBack(nextRowIdx + 1);
-}
-
-/**
- * @brief Adds the vertices to create for npatch
- * @param[out] vertices The vertices to add to
- * @param[in]  x        The x value of vector
- * @param[in]  y        The y value of vector
- */
-void AddVertex(Vector<Vector2>& vertices, unsigned int x, unsigned int y)
-{
-  vertices.PushBack(Vector2(x, y));
-}
-
-} //unnamed namespace
-

 VisualFactoryCache::VisualFactoryCache(bool preMultiplyOnLoad)
 VisualFactoryCache::VisualFactoryCache(bool preMultiplyOnLoad)

-: mSvgRasterizeThread(NULL),
-  mVectorAnimationManager(),
+: mSvgRasterizeManager(nullptr),
+  mVectorAnimationManager(nullptr),

   mPreMultiplyOnLoad(preMultiplyOnLoad),
   mPreMultiplyOnLoad(preMultiplyOnLoad),

-  mBrokenImageInfoContainer()
+  mBrokenImageInfoContainer(),
+  mDefaultBrokenImageUrl(""),
+  mUseDefaultBrokenImageOnly(true)

 {
 }
 
 VisualFactoryCache::~VisualFactoryCache()
 {
 {
 }
 
 VisualFactoryCache::~VisualFactoryCache()
 {

-  SvgRasterizeThread::TerminateThread(mSvgRasterizeThread);

 }
 
 Geometry VisualFactoryCache::GetGeometry(GeometryType type)
 }
 
 Geometry VisualFactoryCache::GetGeometry(GeometryType type)


@@ -168,10 +114,7 @@ ImageAtlasManagerPtr VisualFactoryCache::GetAtlasManager()
   if(!mAtlasManager)
   {
     mAtlasManager = new ImageAtlasManager();
   if(!mAtlasManager)
   {
     mAtlasManager = new ImageAtlasManager();

-    if(!mBrokenImageInfoContainer.empty())
-    {
-      mAtlasManager->SetBrokenImage(mBrokenImageInfoContainer[0].url);
-    }
+    mAtlasManager->SetBrokenImage(mDefaultBrokenImageUrl);

   }
 
   return mAtlasManager;
   }
 
   return mAtlasManager;


@@ -187,14 +130,13 @@ NPatchLoader& VisualFactoryCache::GetNPatchLoader()
   return mNPatchLoader;
 }
 
   return mNPatchLoader;
 }
 

-SvgRasterizeThread* VisualFactoryCache::GetSVGRasterizationThread()
+SvgRasterizeManager* VisualFactoryCache::GetSVGRasterizationManager()

 {
 {

-  if(!mSvgRasterizeThread)
+  if(!mSvgRasterizeManager)

   {
   {

-    mSvgRasterizeThread = new SvgRasterizeThread();
-    mSvgRasterizeThread->Start();
+    mSvgRasterizeManager = std::unique_ptr<SvgRasterizeManager>(new SvgRasterizeManager());

   }
   }

-  return mSvgRasterizeThread;
+  return mSvgRasterizeManager.get();

 }
 
 VectorAnimationManager& VisualFactoryCache::GetVectorAnimationManager()
 }
 
 VectorAnimationManager& VisualFactoryCache::GetVectorAnimationManager()


@@ -282,10 +224,10 @@ Texture VisualFactoryCache::GetBrokenVisualImage(uint32_t brokenIndex)
     Devel::PixelBuffer pixelBuffer = LoadImageFromFile(mBrokenImageInfoContainer[brokenIndex].url);
     if(pixelBuffer)
     {
     Devel::PixelBuffer pixelBuffer = LoadImageFromFile(mBrokenImageInfoContainer[brokenIndex].url);
     if(pixelBuffer)
     {

-      pixelData                = Devel::PixelBuffer::Convert(pixelBuffer); // takes ownership of buffer
-      mBrokenImageInfoContainer[brokenIndex].texture  = Texture::New(Dali::TextureType::TEXTURE_2D, pixelData.GetPixelFormat(), pixelData.GetWidth(), pixelData.GetHeight());
+      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].texture.Upload(pixelData);

-      mBrokenImageInfoContainer[brokenIndex].width = pixelData.GetWidth();
+      mBrokenImageInfoContainer[brokenIndex].width  = pixelData.GetWidth();

       mBrokenImageInfoContainer[brokenIndex].height = pixelData.GetHeight();
     }
   }
       mBrokenImageInfoContainer[brokenIndex].height = pixelData.GetHeight();
     }
   }


@@ -302,14 +244,17 @@ bool VisualFactoryCache::GetPreMultiplyOnLoad()
   return mPreMultiplyOnLoad;
 }
 
   return mPreMultiplyOnLoad;
 }
 

-void VisualFactoryCache::SetBrokenImageUrl(const std::vector<std::string>& brokenImageUrlList)
+void VisualFactoryCache::SetBrokenImageUrl(std::string& defaultBrokenUrl, const std::vector<std::string>& brokenImageUrlList)

 {
 {

+  mUseDefaultBrokenImageOnly = false;

   mBrokenImageInfoContainer.clear();
   mBrokenImageInfoContainer.assign(brokenImageUrlList.size(), BrokenImageInfo());
   for(unsigned int i = 0; i < brokenImageUrlList.size(); i++)
   {
     mBrokenImageInfoContainer[i].url = brokenImageUrlList[i];
   }
   mBrokenImageInfoContainer.clear();
   mBrokenImageInfoContainer.assign(brokenImageUrlList.size(), BrokenImageInfo());
   for(unsigned int i = 0; i < brokenImageUrlList.size(); i++)
   {
     mBrokenImageInfoContainer[i].url = brokenImageUrlList[i];
   }

+
+  mDefaultBrokenImageUrl = defaultBrokenUrl;

 }
 
 VisualUrl::Type VisualFactoryCache::GetBrokenImageVisualType(int index)
 }
 
 VisualUrl::Type VisualFactoryCache::GetBrokenImageVisualType(int index)


@@ -317,40 +262,6 @@ VisualUrl::Type VisualFactoryCache::GetBrokenImageVisualType(int index)
   return mBrokenImageInfoContainer[index].visualType;
 }
 
   return mBrokenImageInfoContainer[index].visualType;
 }
 

-Geometry VisualFactoryCache::CreateNPatchGeometry(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)
-    {
-      AddVertex(vertices, x, y);
-    }
-  }
-
-  // Create indices
-  Vector<unsigned short> indices;
-  indices.Reserve(gridWidth * gridHeight * 6);
-
-  unsigned int rowIdx     = 0;
-  unsigned int nextRowIdx = gridWidth + 1;
-  for(int y = 0; y < gridHeight; ++y, ++nextRowIdx, ++rowIdx)
-  {
-    for(int x = 0; x < gridWidth; ++x, ++nextRowIdx, ++rowIdx)
-    {
-      AddQuadIndices(indices, rowIdx, nextRowIdx);
-    }
-  }
-
-  return GenerateGeometry(vertices, indices);
-}
-

 Geometry VisualFactoryCache::GetNPatchGeometry(int index)
 {
   Geometry          geometry;
 Geometry VisualFactoryCache::GetNPatchGeometry(int index)
 {
   Geometry          geometry;


@@ -362,14 +273,14 @@ Geometry VisualFactoryCache::GetNPatchGeometry(int index)
       geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
       if(!geometry)
       {
       geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
       if(!geometry)
       {

-        geometry = CreateNPatchGeometry(Uint16Pair(3,3));
+        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);
         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 = CreateNPatchGeometry(gridSize);
+      geometry = NPatchHelper::CreateGridGeometry(gridSize);

     }
   }
   else
     }
   }
   else


@@ -378,7 +289,7 @@ Geometry VisualFactoryCache::GetNPatchGeometry(int index)
     geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
     if(!geometry)
     {
     geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
     if(!geometry)
     {

-      geometry = CreateNPatchGeometry(Uint16Pair(3,3));
+      geometry = NPatchHelper::CreateGridGeometry(Uint16Pair(3, 3));

       SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
     }
   }
       SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
     }
   }


@@ -401,7 +312,7 @@ Shader VisualFactoryCache::GetNPatchShader(int index)
     yStretchCount = data->GetStretchPixelsY().Count();
   }
 
     yStretchCount = data->GetStretchPixelsY().Count();
   }
 

-  if(DALI_LIKELY((xStretchCount == 0 && yStretchCount == 0)))
+  if(DALI_LIKELY((xStretchCount == 0 && yStretchCount == 0) || (xStretchCount == 1 && yStretchCount == 1)))

   {
     shader = GetShader(VisualFactoryCache::NINE_PATCH_SHADER);
     if(DALI_UNLIKELY(!shader))
   {
     shader = GetShader(VisualFactoryCache::NINE_PATCH_SHADER);
     if(DALI_UNLIKELY(!shader))


@@ -423,76 +334,29 @@ Shader VisualFactoryCache::GetNPatchShader(int index)
   return shader;
 }
 
   return shader;
 }
 

-void VisualFactoryCache::RegisterStretchProperties(Renderer& renderer, const char* uniformName, const NPatchUtility::StretchRanges& stretchPixels, uint16_t imageExtent)
-{
-  uint16_t     prevEnd     = 0;
-  uint16_t     prevFix     = 0;
-  uint16_t     prevStretch = 0;
-  unsigned int i           = 1;
-  for(NPatchUtility::StretchRanges::ConstIterator it = stretchPixels.Begin(); it != stretchPixels.End(); ++it, ++i)
-  {
-    uint16_t start = it->GetX();
-    uint16_t end   = it->GetY();
-
-    uint16_t fix     = prevFix + start - prevEnd;
-    uint16_t stretch = prevStretch + end - start;
-
-    std::stringstream uniform;
-    uniform << uniformName << "[" << i << "]";
-    renderer.RegisterProperty(uniform.str(), Vector2(fix, stretch));
-
-    prevEnd     = end;
-    prevFix     = fix;
-    prevStretch = stretch;
-  }
-
-  {
-    prevFix += imageExtent - prevEnd;
-    std::stringstream uniform;
-    uniform << uniformName << "[" << i << "]";
-    renderer.RegisterProperty(uniform.str(), Vector2(prevFix, prevStretch));
-  }
-}
-

 void VisualFactoryCache::ApplyTextureAndUniforms(Renderer& renderer, int index)
 {
   const NPatchData* data;
   TextureSet        textureSet;
   if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
   {
 void VisualFactoryCache::ApplyTextureAndUniforms(Renderer& renderer, int index)
 {
   const NPatchData* data;
   TextureSet        textureSet;
   if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
   {

-    textureSet = data->GetTextures();
-    mBrokenImageInfoContainer[index].texture = data->GetTextures().GetTexture(0);
-
-    if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
-    {
-      //special case for 9 patch
-      Uint16Pair stretchX = data->GetStretchPixelsX()[0];
-      Uint16Pair stretchY = data->GetStretchPixelsY()[0];
-
-      uint16_t stretchWidth  = (stretchX.GetY() >= stretchX.GetX()) ? stretchX.GetY() - stretchX.GetX() : 0;
-      uint16_t stretchHeight = (stretchY.GetY() >= stretchY.GetX()) ? stretchY.GetY() - stretchY.GetX() : 0;
-
-      renderer.RegisterProperty("uFixed[0]", Vector2::ZERO);
-      renderer.RegisterProperty("uFixed[1]", Vector2(stretchX.GetX(), stretchY.GetX()));
-      renderer.RegisterProperty("uFixed[2]", Vector2(data->GetCroppedWidth() - stretchWidth, data->GetCroppedHeight() - stretchHeight));
-      renderer.RegisterProperty("uStretchTotal", Vector2(stretchWidth, stretchHeight));
-    }
-    else
-    {
-      renderer.RegisterProperty("uNinePatchFactorsX[0]", Vector2::ZERO);
-      renderer.RegisterProperty("uNinePatchFactorsY[0]", Vector2::ZERO);
-
-      RegisterStretchProperties(renderer, "uNinePatchFactorsX", data->GetStretchPixelsX(), data->GetCroppedWidth());
-      RegisterStretchProperties(renderer, "uNinePatchFactorsY", data->GetStretchPixelsY(), data->GetCroppedHeight());
-    }
+    textureSet                               = data->GetTextures();
+    mBrokenImageInfoContainer[index].texture = textureSet.GetTexture(0);
+    NPatchHelper::ApplyTextureAndUniforms(renderer, data);

     renderer.SetTextures(textureSet);
   }
 }
 
     renderer.SetTextures(textureSet);
   }
 }
 

-void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size)
+void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size, const bool& rendererIsImage)

 {
 {

+  bool useDefaultBrokenImage = false;
+  if(mBrokenImageInfoContainer.size() == 0)
+  {
+    useDefaultBrokenImage = true;
+  }
+

   // Load Information for broken image
   // Load Information for broken image

-  for(uint32_t index = 0; index < mBrokenImageInfoContainer.size(); index++)
+  for(uint32_t index = 0; (index < mBrokenImageInfoContainer.size()) && !useDefaultBrokenImage; index++)

   {
     if(mBrokenImageInfoContainer[index].width == 0 && mBrokenImageInfoContainer[index].height == 0)
     {
   {
     if(mBrokenImageInfoContainer[index].width == 0 && mBrokenImageInfoContainer[index].height == 0)
     {


@@ -503,41 +367,76 @@ void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vec
         if(mBrokenImageInfoContainer[index].visualType == VisualUrl::Type::N_PATCH)
         {
           const NPatchData* data;
         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);
+          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)
           {
           if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
           {

-            mBrokenImageInfoContainer[index].width = data->GetCroppedWidth();
+            mBrokenImageInfoContainer[index].width  = data->GetCroppedWidth();

             mBrokenImageInfoContainer[index].height = data->GetCroppedHeight();
           }
           else
           {
             mBrokenImageInfoContainer[index].height = data->GetCroppedHeight();
           }
           else
           {

-            DALI_LOG_ERROR("Can't update renderer for broken image. maybe image loading is failed [path:%s] \n",mBrokenImageInfoContainer[index].url.c_str());
+            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
         {
           }
         }
         else
         {

-          GetBrokenVisualImage(index);
+          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;
+          }

         }
       }
     }
   }
 
         }
       }
     }
   }
 

+  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;
+  }
+

   // Set Texutre to renderer
   int brokenIndex = GetProperBrokenImageIndex(size);
   if(GetBrokenImageVisualType(brokenIndex) == VisualUrl::N_PATCH)
   {
     // Set geometry and shader for npatch
     Geometry geometry = GetNPatchGeometry(brokenIndex);
   // Set Texutre to renderer
   int brokenIndex = GetProperBrokenImageIndex(size);
   if(GetBrokenImageVisualType(brokenIndex) == VisualUrl::N_PATCH)
   {
     // Set geometry and shader for npatch
     Geometry geometry = GetNPatchGeometry(brokenIndex);

-    Shader shader = GetNPatchShader(brokenIndex);
+    Shader   shader   = GetNPatchShader(brokenIndex);

     renderer.SetGeometry(geometry);
     renderer.SetShader(shader);
     ApplyTextureAndUniforms(renderer, brokenIndex);
   }
   else
   {
     renderer.SetGeometry(geometry);
     renderer.SetShader(shader);
     ApplyTextureAndUniforms(renderer, brokenIndex);
   }
   else
   {

-    Texture brokenImage = GetBrokenVisualImage(brokenIndex);
-    TextureSet textureSet = TextureSet::New();
+    // Create single image renderer only if rederer is not use normal ImageShader. i.e. npatch visual.
+    if(!rendererIsImage)
+    {
+      Geometry geometry = GetGeometry(QUAD_GEOMETRY);
+      Shader   shader   = GetShader(IMAGE_SHADER);
+      if(!shader)
+      {
+        std::string vertexShader   = std::string(Dali::Shader::GetVertexShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_VERT.data());
+        std::string fragmentShader = std::string(Dali::Shader::GetFragmentShaderPrefix() + SHADER_IMAGE_VISUAL_SHADER_FRAG.data());
+        shader                     = Shader::New(vertexShader, fragmentShader);
+        shader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
+        SaveShader(IMAGE_SHADER, shader);
+      }
+      renderer.SetGeometry(geometry);
+      renderer.SetShader(shader);
+    }
+    Texture    brokenImage = GetBrokenVisualImage(brokenIndex);
+    TextureSet textureSet  = TextureSet::New();

     textureSet.SetTexture(0u, brokenImage);
     renderer.SetTextures(textureSet);
   }
     textureSet.SetTexture(0u, brokenImage);
     renderer.SetTextures(textureSet);
   }


@@ -547,7 +446,7 @@ int32_t VisualFactoryCache::GetProperBrokenImageIndex(const Vector2& size)
 {
   // Sets the default broken type
   int32_t returnIndex = 0;
 {
   // Sets the default broken type
   int32_t returnIndex = 0;

-  if((size.width == 0 || size.height == 0))
+  if((size.width == 0 || size.height == 0) || mUseDefaultBrokenImageOnly)

   {
     // To do : Need to add observer about size
     return returnIndex;
   {
     // To do : Need to add observer about size
     return returnIndex;