deae0b0d840ac2b2bdba2d6d49d382629fe37b0d
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / visual-factory-cache.h
1 #ifndef DALI_TOOLKIT_VISUAL_FACTORY_CACHE_H
2 #define DALI_TOOLKIT_VISUAL_FACTORY_CACHE_H
3
4 /*
5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  */
19
20 // EXTERNAL INCLUDES
21 #include <dali/devel-api/common/owner-container.h>
22 #include <dali/public-api/math/uint-16-pair.h>
23 #include <dali/public-api/object/ref-object.h>
24 #include <dali/public-api/rendering/geometry.h>
25 #include <dali/public-api/rendering/shader.h>
26
27 // INTERNAL INCLUDES
28 #include <dali-toolkit/internal/visuals/npatch-loader.h>
29 #include <dali-toolkit/internal/visuals/svg/svg-rasterize-thread.h>
30 #include <dali-toolkit/internal/visuals/texture-manager-impl.h>
31 #include <dali/devel-api/rendering/renderer-devel.h>
32
33 namespace Dali
34 {
35 class Texture;
36
37 namespace Toolkit
38 {
39 namespace Internal
40 {
41 class ImageAtlasManager;
42 class NPatchLoader;
43 class TextureManager;
44 class VectorAnimationManager;
45
46 typedef IntrusivePtr<ImageAtlasManager> ImageAtlasManagerPtr;
47
48 /**
49  * Caches shaders and geometries. Owned by VisualFactory.
50  */
51 class VisualFactoryCache
52 {
53 public:
54   /**
55    * Type of shader for caching.
56    */
57   enum ShaderType
58   {
59     COLOR_SHADER,
60     COLOR_SHADER_ROUNDED_CORNER,
61     COLOR_SHADER_BORDERLINE,
62     COLOR_SHADER_ROUNDED_BORDERLINE,
63     COLOR_SHADER_BLUR_EDGE,
64     COLOR_SHADER_ROUNDED_CORNER_BLUR_EDGE,
65     BORDER_SHADER,
66     BORDER_SHADER_ANTI_ALIASING,
67     GRADIENT_SHADER_LINEAR_BOUNDING_BOX,
68     GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_CORNER,
69     GRADIENT_SHADER_LINEAR_BOUNDING_BOX_BORDERLINE,
70     GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_BORDERLINE,
71     GRADIENT_SHADER_LINEAR_USER_SPACE,
72     GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_CORNER,
73     GRADIENT_SHADER_LINEAR_USER_SPACE_BORDERLINE,
74     GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_BORDERLINE,
75     GRADIENT_SHADER_RADIAL_BOUNDING_BOX,
76     GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_CORNER,
77     GRADIENT_SHADER_RADIAL_BOUNDING_BOX_BORDERLINE,
78     GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_BORDERLINE,
79     GRADIENT_SHADER_RADIAL_USER_SPACE,
80     GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_CORNER,
81     GRADIENT_SHADER_RADIAL_USER_SPACE_BORDERLINE,
82     GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_BORDERLINE,
83     IMAGE_SHADER,
84     IMAGE_SHADER_ROUNDED_CORNER,
85     IMAGE_SHADER_BORDERLINE,
86     IMAGE_SHADER_ROUNDED_BORDERLINE,
87     IMAGE_SHADER_ATLAS_DEFAULT_WRAP,
88     IMAGE_SHADER_ATLAS_CUSTOM_WRAP,
89     NATIVE_IMAGE_SHADER,
90     NATIVE_IMAGE_SHADER_ROUNDED_CORNER,
91     NATIVE_IMAGE_SHADER_BORDERLINE,
92     NATIVE_IMAGE_SHADER_ROUNDED_BORDERLINE,
93     NINE_PATCH_SHADER,
94     NINE_PATCH_MASK_SHADER,
95     TEXT_SHADER_MULTI_COLOR_TEXT,
96     TEXT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE,
97     TEXT_SHADER_SINGLE_COLOR_TEXT,
98     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE,
99     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI,
100     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI,
101     ANIMATED_GRADIENT_SHADER_LINEAR_BOUNDING_REFLECT,
102     ANIMATED_GRADIENT_SHADER_LINEAR_BOUNDING_REPEAT,
103     ANIMATED_GRADIENT_SHADER_LINEAR_BOUNDING_CLAMP,
104     ANIMATED_GRADIENT_SHADER_LINEAR_USER_REFLECT,
105     ANIMATED_GRADIENT_SHADER_LINEAR_USER_REPEAT,
106     ANIMATED_GRADIENT_SHADER_LINEAR_USER_CLAMP,
107     ANIMATED_GRADIENT_SHADER_RADIAL_BOUNDING_REFLECT,
108     ANIMATED_GRADIENT_SHADER_RADIAL_BOUNDING_REPEAT,
109     ANIMATED_GRADIENT_SHADER_RADIAL_BOUNDING_CLAMP,
110     ANIMATED_GRADIENT_SHADER_RADIAL_USER_REFLECT,
111     ANIMATED_GRADIENT_SHADER_RADIAL_USER_REPEAT,
112     ANIMATED_GRADIENT_SHADER_RADIAL_USER_CLAMP,
113     WIREFRAME_SHADER,
114     ARC_BUTT_CAP_SHADER,
115     ARC_ROUND_CAP_SHADER,
116     SHADER_TYPE_MAX = ARC_ROUND_CAP_SHADER
117   };
118
119   /**
120    * Type of geometry for caching.
121    */
122   enum GeometryType
123   {
124     QUAD_GEOMETRY,
125     BORDER_GEOMETRY,
126     NINE_PATCH_GEOMETRY,
127     NINE_PATCH_BORDER_GEOMETRY,
128     WIREFRAME_GEOMETRY,
129     GEOMETRY_TYPE_MAX = WIREFRAME_GEOMETRY
130   };
131
132 public:
133   /**
134    * @brief Constructor
135    *
136    * @param[in] preMultiplyOnLoad True if image visuals should pre-multiply alpha on image load.
137    */
138   VisualFactoryCache(bool preMultiplyOnLoad);
139
140   /**
141    * @brief Destructor
142    */
143   ~VisualFactoryCache();
144
145   /**
146    * Request geometry of the given type.
147    * @return The geometry of the required type if it exist in the cache. Otherwise, an empty handle is returned.
148    */
149   Geometry GetGeometry(GeometryType type);
150
151   /**
152    * Cache the geometry of the give type.
153    * @param[in] type The geometry type.
154    * @param[in] geometry The geometry for caching.
155    */
156   void SaveGeometry(GeometryType type, Geometry geometry);
157
158   /**
159    * Request shader of the given type.
160    * @return The shader of the required type if it exist in the cache. Otherwise, an empty handle is returned.
161    */
162   Shader GetShader(ShaderType type);
163
164   /**
165    * Cache the geometry of the give type.
166    * @param[in] type The geometry type.
167    * @param[in] geometry The geometry for caching.
168    */
169   void SaveShader(ShaderType type, Shader shader);
170
171   /*
172    * Greate the quad geometry.
173    * Quad geometry is shared by multiple kind of Renderer, so implement it in the factory-cache.
174    */
175   static Geometry CreateQuadGeometry();
176
177   /**
178    * Create the grid geometry.
179    * @param[in] gridSize The size of the grid.
180    * @return The created grid geometry.
181    */
182   static Geometry CreateGridGeometry(Uint16Pair gridSize);
183
184   /**
185    * @copydoc Toolkit::VisualFactory::SetPreMultiplyOnLoad()
186    */
187   void SetPreMultiplyOnLoad(bool preMultiply);
188
189   /**
190    * @copydoc Toolkit::VisualFactory::GetPreMultiplyOnLoad()
191    */
192   bool GetPreMultiplyOnLoad();
193
194   /**
195    * @brief Set an image to be used when a visual has failed to correctly render
196    * @param[in] brokenImageUrlList The broken image url list
197    */
198   void SetBrokenImageUrl(const std::vector<std::string>& brokenImageUrlList);
199
200   /**
201    * @brief Update the broken image Renderer object
202    * @param[in,out] renderer renderer for broken image
203    * @param[in] size the size of actor
204    */
205   void UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size);
206
207 public:
208   /**
209    * Get the image atlas manager.
210    * @return A pointer to the atlas manager
211    */
212   ImageAtlasManagerPtr GetAtlasManager();
213
214   /**
215    * Get the texture manager
216    * @return A reference to the texture manager
217    */
218   TextureManager& GetTextureManager();
219
220   /**
221    * Get the N-Patch texture cache.
222    * @return A reference to the N patch loader
223    */
224   NPatchLoader& GetNPatchLoader();
225
226   /**
227    * Get the SVG rasterization thread.
228    * @return A raw pointer pointing to the SVG rasterization thread.
229    */
230   SvgRasterizeThread* GetSVGRasterizationThread();
231
232   /**
233    * Get the vector animation manager.
234    * @return A reference to the vector animation manager.
235    */
236   VectorAnimationManager& GetVectorAnimationManager();
237
238 protected:
239   /**
240    * Undefined copy constructor.
241    */
242   VisualFactoryCache(const VisualFactoryCache&);
243
244   /**
245    * Undefined assignment operator.
246    */
247   VisualFactoryCache& operator=(const VisualFactoryCache& rhs);
248
249 private:
250   /**
251    * @brief Returns a cached Texture to use when a visual has failed to correctly render
252    * @param[in] brokenIndex The index of broken image
253    *
254    * @return The broken image texture.
255    */
256   Texture GetBrokenVisualImage(uint32_t brokenIndex);
257
258   /**
259    * @brief Gets the Proper broken image index
260    * @param[in] size The size of actor
261    *
262    * @return The index of broken image
263    */
264   int32_t GetProperBrokenImageIndex(const Vector2& size);
265
266   /**
267    * @brief Apply a texture and uniforms
268    *
269    * @param[in,out] renderer The renderer for broken image
270    * @param[in] index The index of broken image
271    */
272   void ApplyTextureAndUniforms(Renderer& renderer, int index);
273
274   /**
275    * @brief Creates a Npatch Geometry object
276    *
277    * @param[in] gridSize The gridSize for creating a geometry
278    * @return The Geometry for NPatch
279    */
280   Geometry CreateNPatchGeometry(Uint16Pair gridSize);
281
282   /**
283    * @brief Gets a geometry for npatch image
284    *
285    * @param[in] index the index of broken image
286    * @return The Geometry for NPatch
287    */
288   Geometry GetNPatchGeometry(int index);
289
290   /**
291    * @brief Gets the Npatch Shader object
292    *
293    * @param[in] index The index of broken image
294    * @return The Shader for NPatch
295    */
296   Shader GetNPatchShader(int index);
297
298   /**
299    * @brief Registers a properties for Stretch Ranges
300    *
301    * @param[in,out] renderer The renderer for broken image
302    * @param[in] uniformName The name of the uniform
303    * @param[in] stretchPixels The stretchable pixels in the cropped image space
304    * @param[in] imageExtent The imageExtent
305    */
306   void RegisterStretchProperties(Renderer& renderer, const char* uniformName, const NPatchUtility::StretchRanges& stretchPixels, uint16_t imageExtent);
307
308   /**
309    * @brief Returns a broken image type
310    * @param[in] index BrokenImage index
311    * @return The broken image type.
312    */
313   VisualUrl::Type GetBrokenImageVisualType(int index);
314
315 private:
316   struct BrokenImageInfo
317   {
318     BrokenImageInfo()
319     :visualType(),
320      url(""),
321      npatchId(NPatchData::INVALID_NPATCH_DATA_ID),
322      texture(),
323      width(0),
324      height(0)
325     {
326     }
327
328     ~BrokenImageInfo()
329     {
330     }
331
332     // Data
333     VisualUrl::Type                         visualType;
334     std::string                             url;
335     NPatchData::NPatchDataId                npatchId;
336     Texture                                 texture;
337     uint32_t                                width;
338     uint32_t                                height;
339   };
340
341   Geometry mGeometry[GEOMETRY_TYPE_MAX + 1];
342   Shader   mShader[SHADER_TYPE_MAX + 1];
343
344   ImageAtlasManagerPtr                    mAtlasManager;
345   TextureManager                          mTextureManager;
346   NPatchLoader                            mNPatchLoader;
347
348   SvgRasterizeThread*                     mSvgRasterizeThread;
349   std::unique_ptr<VectorAnimationManager> mVectorAnimationManager;
350   bool                                    mPreMultiplyOnLoad;
351   std::vector<BrokenImageInfo>            mBrokenImageInfoContainer;
352 };
353
354 } // namespace Internal
355
356 } // namespace Toolkit
357
358 } // namespace Dali
359
360 #endif // DALI_TOOLKIT_VISUAL_FACTORY_CACHE_H