2 * Copyright (c) 2021 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include "visual-factory-cache.h"
21 #include <dali/devel-api/adaptor-framework/image-loading.h>
22 #include <dali/devel-api/common/hash.h>
25 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-animation-manager.h>
26 #include <dali-toolkit/internal/visuals/color/color-visual.h>
27 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
28 #include <dali-toolkit/internal/visuals/svg/svg-visual.h>
29 #include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
30 #include <dali-toolkit/devel-api/utility/npatch-helper.h>
31 #include <dali/integration-api/debug.h>
40 VisualFactoryCache::VisualFactoryCache(bool preMultiplyOnLoad)
41 : mSvgRasterizeThread(NULL),
42 mVectorAnimationManager(),
43 mPreMultiplyOnLoad(preMultiplyOnLoad),
44 mBrokenImageInfoContainer(),
45 mDefaultBrokenImageUrl(""),
46 mUseDefaultBrokenImageOnly(true)
50 VisualFactoryCache::~VisualFactoryCache()
52 SvgRasterizeThread::TerminateThread(mSvgRasterizeThread);
55 Geometry VisualFactoryCache::GetGeometry(GeometryType type)
57 if(!mGeometry[type] && type == QUAD_GEOMETRY)
59 mGeometry[type] = CreateQuadGeometry();
62 return mGeometry[type];
65 void VisualFactoryCache::SaveGeometry(GeometryType type, Geometry geometry)
67 mGeometry[type] = geometry;
70 Shader VisualFactoryCache::GetShader(ShaderType type)
75 void VisualFactoryCache::SaveShader(ShaderType type, Shader shader)
77 mShader[type] = shader;
80 Geometry VisualFactoryCache::CreateQuadGeometry()
82 const float halfWidth = 0.5f;
83 const float halfHeight = 0.5f;
88 QuadVertex quadVertexData[4] =
90 {Vector2(-halfWidth, -halfHeight)},
91 {Vector2(-halfWidth, halfHeight)},
92 {Vector2(halfWidth, -halfHeight)},
93 {Vector2(halfWidth, halfHeight)}};
95 Property::Map quadVertexFormat;
96 quadVertexFormat["aPosition"] = Property::VECTOR2;
97 VertexBuffer quadVertices = VertexBuffer::New(quadVertexFormat);
98 quadVertices.SetData(quadVertexData, 4);
100 // Create the geometry object
101 Geometry geometry = Geometry::New();
102 geometry.AddVertexBuffer(quadVertices);
103 geometry.SetType(Geometry::TRIANGLE_STRIP);
108 ImageAtlasManagerPtr VisualFactoryCache::GetAtlasManager()
112 mAtlasManager = new ImageAtlasManager();
113 mAtlasManager->SetBrokenImage(mDefaultBrokenImageUrl);
116 return mAtlasManager;
119 TextureManager& VisualFactoryCache::GetTextureManager()
121 return mTextureManager;
124 NPatchLoader& VisualFactoryCache::GetNPatchLoader()
126 return mNPatchLoader;
129 SvgRasterizeThread* VisualFactoryCache::GetSVGRasterizationThread()
131 if(!mSvgRasterizeThread)
133 mSvgRasterizeThread = new SvgRasterizeThread();
134 mSvgRasterizeThread->Start();
136 return mSvgRasterizeThread;
139 VectorAnimationManager& VisualFactoryCache::GetVectorAnimationManager()
141 if(!mVectorAnimationManager)
143 mVectorAnimationManager = std::unique_ptr<VectorAnimationManager>(new VectorAnimationManager());
145 return *mVectorAnimationManager;
148 Geometry VisualFactoryCache::CreateGridGeometry(Uint16Pair gridSize)
150 uint16_t gridWidth = gridSize.GetWidth();
151 uint16_t gridHeight = gridSize.GetHeight();
154 Vector<Vector2> vertices;
155 vertices.Reserve((gridWidth + 1) * (gridHeight + 1));
157 for(int y = 0; y < gridHeight + 1; ++y)
159 for(int x = 0; x < gridWidth + 1; ++x)
161 vertices.PushBack(Vector2((float)x / gridWidth - 0.5f, (float)y / gridHeight - 0.5f));
166 Vector<unsigned short> indices;
167 indices.Reserve((gridWidth + 2) * gridHeight * 2 - 2);
169 for(unsigned int row = 0u; row < gridHeight; ++row)
171 unsigned int rowStartIndex = row * (gridWidth + 1u);
172 unsigned int nextRowStartIndex = rowStartIndex + gridWidth + 1u;
174 if(row != 0u) // degenerate index on non-first row
176 indices.PushBack(rowStartIndex);
179 for(unsigned int column = 0u; column < gridWidth + 1u; column++) // main strip
181 indices.PushBack(rowStartIndex + column);
182 indices.PushBack(nextRowStartIndex + column);
185 if(row != gridHeight - 1u) // degenerate index on non-last row
187 indices.PushBack(nextRowStartIndex + gridWidth);
191 Property::Map vertexFormat;
192 vertexFormat["aPosition"] = Property::VECTOR2;
193 VertexBuffer vertexBuffer = VertexBuffer::New(vertexFormat);
194 if(vertices.Size() > 0)
196 vertexBuffer.SetData(&vertices[0], vertices.Size());
199 Property::Map indexFormat;
200 indexFormat["indices"] = Property::INTEGER;
201 VertexBuffer indexVertexBuffer = VertexBuffer::New(indexFormat);
203 // Create the geometry object
204 Geometry geometry = Geometry::New();
205 geometry.AddVertexBuffer(vertexBuffer);
206 if(indices.Size() > 0)
208 geometry.SetIndexBuffer(&indices[0], indices.Size());
211 geometry.SetType(Geometry::TRIANGLE_STRIP);
216 Texture VisualFactoryCache::GetBrokenVisualImage(uint32_t brokenIndex)
218 if(!(mBrokenImageInfoContainer[brokenIndex].texture))
221 Devel::PixelBuffer pixelBuffer = LoadImageFromFile(mBrokenImageInfoContainer[brokenIndex].url);
224 pixelData = Devel::PixelBuffer::Convert(pixelBuffer); // takes ownership of buffer
225 mBrokenImageInfoContainer[brokenIndex].texture = Texture::New(Dali::TextureType::TEXTURE_2D, pixelData.GetPixelFormat(), pixelData.GetWidth(), pixelData.GetHeight());
226 mBrokenImageInfoContainer[brokenIndex].texture.Upload(pixelData);
227 mBrokenImageInfoContainer[brokenIndex].width = pixelData.GetWidth();
228 mBrokenImageInfoContainer[brokenIndex].height = pixelData.GetHeight();
231 return mBrokenImageInfoContainer[brokenIndex].texture;
234 void VisualFactoryCache::SetPreMultiplyOnLoad(bool preMultiply)
236 mPreMultiplyOnLoad = preMultiply;
239 bool VisualFactoryCache::GetPreMultiplyOnLoad()
241 return mPreMultiplyOnLoad;
244 void VisualFactoryCache::SetBrokenImageUrl(std::string& defaultBrokenUrl, const std::vector<std::string>& brokenImageUrlList)
246 mUseDefaultBrokenImageOnly = false;
247 mBrokenImageInfoContainer.clear();
248 mBrokenImageInfoContainer.assign(brokenImageUrlList.size(), BrokenImageInfo());
249 for(unsigned int i = 0; i < brokenImageUrlList.size(); i++)
251 mBrokenImageInfoContainer[i].url = brokenImageUrlList[i];
254 mDefaultBrokenImageUrl = defaultBrokenUrl;
257 VisualUrl::Type VisualFactoryCache::GetBrokenImageVisualType(int index)
259 return mBrokenImageInfoContainer[index].visualType;
262 Geometry VisualFactoryCache::GetNPatchGeometry(int index)
265 const NPatchData* data;
266 if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
268 if(data->GetStretchPixelsX().Size() == 1 && data->GetStretchPixelsY().Size() == 1)
270 geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
273 geometry = NPatchHelper::CreateGridGeometry(Uint16Pair(3,3));
274 SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
277 else if(data->GetStretchPixelsX().Size() > 0 || data->GetStretchPixelsY().Size() > 0)
279 Uint16Pair gridSize(2 * data->GetStretchPixelsX().Size() + 1, 2 * data->GetStretchPixelsY().Size() + 1);
280 geometry = NPatchHelper::CreateGridGeometry(gridSize);
285 // no N patch data so use default geometry
286 geometry = GetGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY);
289 geometry = NPatchHelper::CreateGridGeometry(Uint16Pair(3,3));
290 SaveGeometry(VisualFactoryCache::NINE_PATCH_GEOMETRY, geometry);
296 Shader VisualFactoryCache::GetNPatchShader(int index)
299 const NPatchData* data;
300 // 0 is either no data (load failed?) or no stretch regions on image
301 // for both cases we use the default shader
302 NPatchUtility::StretchRanges::SizeType xStretchCount = 0;
303 NPatchUtility::StretchRanges::SizeType yStretchCount = 0;
305 // ask loader for the regions
306 if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data))
308 xStretchCount = data->GetStretchPixelsX().Count();
309 yStretchCount = data->GetStretchPixelsY().Count();
312 if(DALI_LIKELY((xStretchCount == 0 && yStretchCount == 0) || (xStretchCount == 1 && yStretchCount == 1)))
314 shader = GetShader(VisualFactoryCache::NINE_PATCH_SHADER);
315 if(DALI_UNLIKELY(!shader))
317 shader = Shader::New(SHADER_NPATCH_VISUAL_3X3_SHADER_VERT, SHADER_NPATCH_VISUAL_SHADER_FRAG);
319 // Only cache vanilla 9 patch shaders
320 SaveShader(VisualFactoryCache::NINE_PATCH_SHADER, shader);
323 else if(xStretchCount > 0 || yStretchCount > 0)
325 std::stringstream vertexShader;
326 vertexShader << "#define FACTOR_SIZE_X " << xStretchCount + 2 << "\n"
327 << "#define FACTOR_SIZE_Y " << yStretchCount + 2 << "\n"
328 << SHADER_NPATCH_VISUAL_SHADER_VERT;
329 shader = Shader::New(vertexShader.str(), SHADER_NPATCH_VISUAL_SHADER_FRAG);
334 void VisualFactoryCache::ApplyTextureAndUniforms(Renderer& renderer, int index)
336 const NPatchData* data;
337 TextureSet textureSet;
338 if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
340 textureSet = data->GetTextures();
341 mBrokenImageInfoContainer[index].texture = textureSet.GetTexture(0);
342 NPatchHelper::ApplyTextureAndUniforms(renderer, data);
343 renderer.SetTextures(textureSet);
347 void VisualFactoryCache::UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size)
350 bool useDefaultBrokenImage = false;
351 if(mBrokenImageInfoContainer.size() == 0)
353 useDefaultBrokenImage = true;
356 // Load Information for broken image
357 for(uint32_t index = 0; (index < mBrokenImageInfoContainer.size()) && !useDefaultBrokenImage; index++)
359 if(mBrokenImageInfoContainer[index].width == 0 && mBrokenImageInfoContainer[index].height == 0)
361 if(!mBrokenImageInfoContainer[index].url.empty())
363 VisualUrl visualUrl(mBrokenImageInfoContainer[index].url);
364 mBrokenImageInfoContainer[index].visualType = visualUrl.GetType();
365 if(mBrokenImageInfoContainer[index].visualType == VisualUrl::Type::N_PATCH)
367 const NPatchData* data;
369 mBrokenImageInfoContainer[index].npatchId = mNPatchLoader.Load( mTextureManager, NULL, mBrokenImageInfoContainer[index].url, border, mPreMultiplyOnLoad, true);
370 if(mNPatchLoader.GetNPatchData(mBrokenImageInfoContainer[index].npatchId, data) && data->GetLoadingState() == NPatchData::LoadingState::LOAD_COMPLETE)
372 mBrokenImageInfoContainer[index].width = data->GetCroppedWidth();
373 mBrokenImageInfoContainer[index].height = data->GetCroppedHeight();
377 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());
378 useDefaultBrokenImage = true;
383 if(!GetBrokenVisualImage(index))
385 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());
386 useDefaultBrokenImage = true;
393 if(!mUseDefaultBrokenImageOnly && useDefaultBrokenImage)
396 mBrokenImageInfoContainer.clear();
398 // assign for broken image
399 const int defaultBrokenIndex = 0;
400 mBrokenImageInfoContainer.assign(1, BrokenImageInfo());
401 mBrokenImageInfoContainer[defaultBrokenIndex].url = mDefaultBrokenImageUrl;
402 VisualUrl visualUrl(mBrokenImageInfoContainer[defaultBrokenIndex].url);
403 mBrokenImageInfoContainer[defaultBrokenIndex].visualType = visualUrl.GetType();
404 mUseDefaultBrokenImageOnly = true;
407 // Set Texutre to renderer
408 int brokenIndex = GetProperBrokenImageIndex(size);
409 if(GetBrokenImageVisualType(brokenIndex) == VisualUrl::N_PATCH)
411 // Set geometry and shader for npatch
412 Geometry geometry = GetNPatchGeometry(brokenIndex);
413 Shader shader = GetNPatchShader(brokenIndex);
414 renderer.SetGeometry(geometry);
415 renderer.SetShader(shader);
416 ApplyTextureAndUniforms(renderer, brokenIndex);
420 Texture brokenImage = GetBrokenVisualImage(brokenIndex);
421 TextureSet textureSet = TextureSet::New();
422 textureSet.SetTexture(0u, brokenImage);
423 renderer.SetTextures(textureSet);
427 int32_t VisualFactoryCache::GetProperBrokenImageIndex(const Vector2& size)
429 // Sets the default broken type
430 int32_t returnIndex = 0;
431 if((size.width == 0 || size.height == 0) || mUseDefaultBrokenImageOnly )
433 // To do : Need to add observer about size
437 // Find the proper value if we know the size of the image
438 for(int32_t index = static_cast<int32_t>(mBrokenImageInfoContainer.size()) - 1; index >= 0; index--)
440 // Skip if the value is not set
441 if(mBrokenImageInfoContainer[index].width == 0 || mBrokenImageInfoContainer[index].height == 0)
446 if(mBrokenImageInfoContainer[index].width < size.width && mBrokenImageInfoContainer[index].height < size.height)
456 } // namespace Internal
458 } // namespace Toolkit