X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fvisual-factory-cache.cpp;h=febd2855c08da159bcf8bb77cc41aca93f1143d1;hb=ec0f0792f651f58e887bf53801da23a6d76de0e0;hp=b4fde0a814c4b71127f3ef375c3ca2b6ed4902b2;hpb=c052b6678e2c6d8a65545dbbe4531ea7057c1999;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git

diff --git a/dali-toolkit/internal/visuals/visual-factory-cache.cpp b/dali-toolkit/internal/visuals/visual-factory-cache.cpp
index b4fde0a..febd285 100644
--- a/dali-toolkit/internal/visuals/visual-factory-cache.cpp
+++ b/dali-toolkit/internal/visuals/visual-factory-cache.cpp
@@ -26,6 +26,8 @@
 #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/integration-api/debug.h>
 
 namespace Dali
 {
@@ -33,11 +35,73 @@ namespace Toolkit
 {
 namespace Internal
 {
+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;
+}
+
+/**
+ * @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)
 : mSvgRasterizeThread(NULL),
   mVectorAnimationManager(),
-  mBrokenImageUrl(""),
-  mPreMultiplyOnLoad(preMultiplyOnLoad)
+  mPreMultiplyOnLoad(preMultiplyOnLoad),
+  mBrokenImageInfoContainer()
 {
 }
 
@@ -104,7 +168,10 @@ ImageAtlasManagerPtr VisualFactoryCache::GetAtlasManager()
   if(!mAtlasManager)
   {
     mAtlasManager = new ImageAtlasManager();
-    mAtlasManager->SetBrokenImage(mBrokenImageUrl);
+    if(!mBrokenImageInfoContainer.empty())
+    {
+      mAtlasManager->SetBrokenImage(mBrokenImageInfoContainer[0].url);
+    }
   }
 
   return mAtlasManager;
@@ -207,20 +274,22 @@ Geometry VisualFactoryCache::CreateGridGeometry(Uint16Pair gridSize)
   return geometry;
 }
 
-Texture VisualFactoryCache::GetBrokenVisualImage()
+Texture VisualFactoryCache::GetBrokenVisualImage(uint32_t brokenIndex)
 {
-  if(!mBrokenImageTexture && mBrokenImageUrl.size())
+  if(!(mBrokenImageInfoContainer[brokenIndex].texture))
   {
-    PixelData          data;
-    Devel::PixelBuffer pixelBuffer = LoadImageFromFile(mBrokenImageUrl);
+    PixelData          pixelData;
+    Devel::PixelBuffer pixelBuffer = LoadImageFromFile(mBrokenImageInfoContainer[brokenIndex].url);
     if(pixelBuffer)
     {
-      data                = Devel::PixelBuffer::Convert(pixelBuffer); // takes ownership of buffer
-      mBrokenImageTexture = Texture::New(Dali::TextureType::TEXTURE_2D, data.GetPixelFormat(), data.GetWidth(), data.GetHeight());
-      mBrokenImageTexture.Upload(data);
+      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 mBrokenImageTexture;
+  return mBrokenImageInfoContainer[brokenIndex].texture;
 }
 
 void VisualFactoryCache::SetPreMultiplyOnLoad(bool preMultiply)
@@ -233,16 +302,274 @@ bool VisualFactoryCache::GetPreMultiplyOnLoad()
   return mPreMultiplyOnLoad;
 }
 
-void VisualFactoryCache::SetBrokenImageUrl(const std::string& brokenImageUrl)
+void VisualFactoryCache::SetBrokenImageUrl(const std::vector<std::string>& brokenImageUrlList)
 {
-  mBrokenImageUrl = brokenImageUrl;
+  mBrokenImageInfoContainer.clear();
+  mBrokenImageInfoContainer.assign(brokenImageUrlList.size(), BrokenImageInfo());
+  for(unsigned int i = 0; i < brokenImageUrlList.size(); i++)
+  {
+    mBrokenImageInfoContainer[i].url = brokenImageUrlList[i];
+  }
+}
 
-  if(!mAtlasManager)
+VisualUrl::Type VisualFactoryCache::GetBrokenImageVisualType(int index)
+{
+  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)
   {
-    mAtlasManager = new ImageAtlasManager();
+    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;
+  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 = CreateNPatchGeometry(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 = CreateNPatchGeometry(gridSize);
+    }
+  }
+  else
+  {
+    // no N patch data so use default geometry
+    geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
+    if(!geometry)
+    {
+      geometry = CreateNPatchGeometry(Uint16Pair(3,3));
+      SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
+    }
+  }
+  return geometry;
+}
+
+Shader VisualFactoryCache::GetNPatchShader(int index)
+{
+  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))
+  {
+    xStretchCount = data->GetStretchPixelsX().Count();
+    yStretchCount = data->GetStretchPixelsY().Count();
+  }
+
+  if(DALI_LIKELY((xStretchCount == 0 && yStretchCount == 0)))
+  {
+    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::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)
+  {
+    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());
+    }
+    renderer.SetTextures(textureSet);
+  }
+}
+
+void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size)
+{
+  // Load Information for broken image
+  for(uint32_t index = 0; index < mBrokenImageInfoContainer.size(); index++)
+  {
+    if(mBrokenImageInfoContainer[index].width == 0 && mBrokenImageInfoContainer[index].height == 0)
+    {
+      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 [path:%s] \n",mBrokenImageInfoContainer[index].url.c_str());
+          }
+        }
+        else
+        {
+          GetBrokenVisualImage(index);
+        }
+      }
+    }
+  }
+
+  // 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);
+    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);
+  }
+}
+
+int32_t VisualFactoryCache::GetProperBrokenImageIndex(const Vector2& size)
+{
+  // Sets the default broken type
+  int32_t returnIndex = 0;
+  if((size.width == 0 || size.height == 0))
+  {
+    // To do : Need to add observer about size
+    return returnIndex;
+  }
+
+  // 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)
+    {
+      continue;
+    }
+
+    if(mBrokenImageInfoContainer[index].width < size.width && mBrokenImageInfoContainer[index].height < size.height)
+    {
+      returnIndex = index;
+      break;
+    }
   }
 
-  mAtlasManager->SetBrokenImage(mBrokenImageUrl);
+  return returnIndex;
 }
 
 } // namespace Internal