[dali_2.3.41] Merge branch 'devel/master'
[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) 2024 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/public-api/math/uint-16-pair.h>
22 #include <dali/public-api/object/ref-object.h>
23 #include <dali/public-api/rendering/geometry.h>
24 #include <dali/public-api/rendering/shader.h>
25
26 // INTERNAL INCLUDES
27 #include <dali-toolkit/internal/texture-manager/texture-manager-impl.h>
28 #include <dali-toolkit/internal/visuals/npatch/npatch-loader.h>
29 #include <dali-toolkit/internal/visuals/svg/svg-loader.h>
30 #include <dali/devel-api/rendering/renderer-devel.h>
31
32 namespace Dali
33 {
34 class Texture;
35
36 namespace Toolkit
37 {
38 namespace Internal
39 {
40 class ImageAtlasManager;
41 class NPatchLoader;
42 class SvgLoader;
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     COLOR_SHADER_CUTOUT,
66     COLOR_SHADER_CUTOUT_ROUNDED_CORNER,
67     COLOR_SHADER_CUTOUT_BORDERLINE,
68     COLOR_SHADER_CUTOUT_ROUNDED_BORDERLINE,
69     COLOR_SHADER_CUTOUT_BLUR_EDGE,
70     COLOR_SHADER_CUTOUT_ROUNDED_CORNER_BLUR_EDGE,
71     BORDER_SHADER,
72     BORDER_SHADER_ANTI_ALIASING,
73     GRADIENT_SHADER_LINEAR_BOUNDING_BOX,
74     GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_CORNER,
75     GRADIENT_SHADER_LINEAR_BOUNDING_BOX_BORDERLINE,
76     GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_BORDERLINE,
77     GRADIENT_SHADER_LINEAR_USER_SPACE,
78     GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_CORNER,
79     GRADIENT_SHADER_LINEAR_USER_SPACE_BORDERLINE,
80     GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_BORDERLINE,
81     GRADIENT_SHADER_RADIAL_BOUNDING_BOX,
82     GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_CORNER,
83     GRADIENT_SHADER_RADIAL_BOUNDING_BOX_BORDERLINE,
84     GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_BORDERLINE,
85     GRADIENT_SHADER_RADIAL_USER_SPACE,
86     GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_CORNER,
87     GRADIENT_SHADER_RADIAL_USER_SPACE_BORDERLINE,
88     GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_BORDERLINE,
89     IMAGE_SHADER,
90     IMAGE_SHADER_ROUNDED_CORNER,
91     IMAGE_SHADER_BORDERLINE,
92     IMAGE_SHADER_ROUNDED_BORDERLINE,
93     IMAGE_SHADER_MASKING,
94     IMAGE_SHADER_ROUNDED_CORNER_MASKING,
95     IMAGE_SHADER_BORDERLINE_MASKING,
96     IMAGE_SHADER_ROUNDED_BORDERLINE_MASKING,
97     IMAGE_SHADER_ATLAS_DEFAULT_WRAP,
98     IMAGE_SHADER_ATLAS_CUSTOM_WRAP,
99     IMAGE_SHADER_YUV_TO_RGB,
100     IMAGE_SHADER_ROUNDED_CORNER_YUV_TO_RGB,
101     IMAGE_SHADER_BORDERLINE_YUV_TO_RGB,
102     IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_TO_RGB,
103     IMAGE_SHADER_YUV_AND_RGB,
104     IMAGE_SHADER_ROUNDED_CORNER_YUV_AND_RGB,
105     IMAGE_SHADER_BORDERLINE_YUV_AND_RGB,
106     IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_AND_RGB,
107     NATIVE_IMAGE_SHADER,
108     NATIVE_IMAGE_SHADER_ROUNDED_CORNER,
109     NATIVE_IMAGE_SHADER_BORDERLINE,
110     NATIVE_IMAGE_SHADER_ROUNDED_BORDERLINE,
111     NATIVE_IMAGE_SHADER_MASKING,
112     NATIVE_IMAGE_SHADER_ROUNDED_CORNER_MASKING,
113     NATIVE_IMAGE_SHADER_BORDERLINE_MASKING,
114     NATIVE_IMAGE_SHADER_ROUNDED_BORDERLINE_MASKING,
115     NATIVE_IMAGE_SHADER_ATLAS_DEFAULT_WRAP,
116     NATIVE_IMAGE_SHADER_ATLAS_CUSTOM_WRAP,
117     NINE_PATCH_SHADER,
118     NINE_PATCH_MASK_SHADER,
119     TEXT_SHADER_SINGLE_COLOR_TEXT,
120     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE,
121     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_OVERLAY,
122     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_OVERLAY,
123     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI,
124     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI,
125     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_OVERLAY_AND_EMOJI,
126     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_OVERLAY_AND_EMOJI,
127     TEXT_SHADER_MULTI_COLOR_TEXT,
128     TEXT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE,
129     TEXT_SHADER_MULTI_COLOR_TEXT_WITH_OVERLAY,
130     TEXT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE_AND_OVERLAY,
131     ANIMATED_GRADIENT_SHADER_LINEAR_BOUNDING_REFLECT,
132     ANIMATED_GRADIENT_SHADER_LINEAR_BOUNDING_REPEAT,
133     ANIMATED_GRADIENT_SHADER_LINEAR_BOUNDING_CLAMP,
134     ANIMATED_GRADIENT_SHADER_LINEAR_USER_REFLECT,
135     ANIMATED_GRADIENT_SHADER_LINEAR_USER_REPEAT,
136     ANIMATED_GRADIENT_SHADER_LINEAR_USER_CLAMP,
137     ANIMATED_GRADIENT_SHADER_RADIAL_BOUNDING_REFLECT,
138     ANIMATED_GRADIENT_SHADER_RADIAL_BOUNDING_REPEAT,
139     ANIMATED_GRADIENT_SHADER_RADIAL_BOUNDING_CLAMP,
140     ANIMATED_GRADIENT_SHADER_RADIAL_USER_REFLECT,
141     ANIMATED_GRADIENT_SHADER_RADIAL_USER_REPEAT,
142     ANIMATED_GRADIENT_SHADER_RADIAL_USER_CLAMP,
143     WIREFRAME_SHADER,
144     ARC_BUTT_CAP_SHADER,
145     ARC_ROUND_CAP_SHADER,
146     SHADER_TYPE_MAX = ARC_ROUND_CAP_SHADER
147   };
148
149   /**
150    * Type of geometry for caching.
151    */
152   enum GeometryType
153   {
154     QUAD_GEOMETRY,
155     BORDER_GEOMETRY,
156     NINE_PATCH_GEOMETRY,
157     NINE_PATCH_BORDER_GEOMETRY,
158     WIREFRAME_GEOMETRY,
159     GEOMETRY_TYPE_MAX = WIREFRAME_GEOMETRY
160   };
161
162 public:
163   /**
164    * @brief Constructor
165    *
166    * @param[in] preMultiplyOnLoad True if image visuals should pre-multiply alpha on image load.
167    */
168   VisualFactoryCache(bool preMultiplyOnLoad);
169
170   /**
171    * @brief Destructor
172    */
173   ~VisualFactoryCache();
174
175   /**
176    * Request geometry of the given type.
177    * @return The geometry of the required type if it exist in the cache. Otherwise, an empty handle is returned.
178    */
179   Geometry GetGeometry(GeometryType type);
180
181   /**
182    * Cache the geometry of the give type.
183    * @param[in] type The geometry type.
184    * @param[in] geometry The geometry for caching.
185    */
186   void SaveGeometry(GeometryType type, Geometry geometry);
187
188   /**
189    * Request shader of the given type.
190    * @return The shader of the required type if it exist in the cache. Otherwise, an empty handle is returned.
191    */
192   Shader GetShader(ShaderType type);
193
194   /**
195    * Generate and cache the shader of the give type. The name of shader will be installed to shader.
196    * @param[in] type The shder type.
197    * @param[in] vertexShader The vertex shader code.
198    * @param[in] fragmentShader The fragment shader code.
199    * @return The shader created by given vertex and fragment shader code.
200    */
201   Shader GenerateAndSaveShader(ShaderType type, std::string_view vertexShader, std::string_view fragmentShader);
202
203   /*
204    * Greate the quad geometry.
205    * Quad geometry is shared by multiple kind of Renderer, so implement it in the factory-cache.
206    */
207   static Geometry CreateQuadGeometry();
208
209   /**
210    * Create the grid geometry.
211    * @param[in] gridSize The size of the grid.
212    * @return The created grid geometry.
213    */
214   static Geometry CreateGridGeometry(Uint16Pair gridSize);
215
216   /**
217    * @copydoc Toolkit::VisualFactory::SetPreMultiplyOnLoad()
218    */
219   void SetPreMultiplyOnLoad(bool preMultiply);
220
221   /**
222    * @copydoc Toolkit::VisualFactory::GetPreMultiplyOnLoad()
223    */
224   bool GetPreMultiplyOnLoad() const;
225
226   /**
227    * @brief Set an image to be used when a visual has failed to correctly render
228    * @param[in] brokenImageUrlList The broken image url list
229    */
230   void SetBrokenImageUrl(std::string& defaultBrokenUrl, const std::vector<std::string>& brokenImageUrlList);
231
232   /**
233    * @brief Update the broken image Renderer object
234    * @param[in,out] renderer renderer for broken image
235    * @param[in] size the size of actor
236    * @param[in] rendererIsImage True if input renderer use image shader already.
237    *                            If true, we don't need to create new renderer when broken image is single image.
238    *                            Most of user experience use normal images. So It can reduce runtime.
239    */
240   void UpdateBrokenImageRenderer(Renderer& renderer, const Vector2& size, const bool rendererIsImage = true);
241
242   /**
243    * @brief Get whether we support YUV Planes load or not.
244    *
245    * @return True if we support to load YUV Planes. False otherwise.
246    */
247   bool GetLoadYuvPlanes() const;
248
249 public:
250   /**
251    * Get the image atlas manager.
252    * @return A pointer to the atlas manager
253    */
254   ImageAtlasManagerPtr GetAtlasManager();
255
256   /**
257    * Get the texture manager
258    * @return A reference to the texture manager
259    */
260   TextureManager& GetTextureManager();
261
262   /**
263    * Get the N-Patch texture cache.
264    * @return A reference to the N patch loader
265    */
266   NPatchLoader& GetNPatchLoader();
267
268   /**
269    * Get the Svg texture cache.
270    * @return A reference to the Svg loader
271    */
272   SvgLoader& GetSvgLoader();
273
274   /**
275    * Get the vector animation manager.
276    * @return A reference to the vector animation manager.
277    */
278   VectorAnimationManager& GetVectorAnimationManager();
279
280   /**
281    * @brief Finalize vector animation manager.
282    * It will be called when application is terminated.
283    */
284   void FinalizeVectorAnimationManager();
285
286 protected:
287   /**
288    * Undefined copy constructor.
289    */
290   VisualFactoryCache(const VisualFactoryCache&);
291
292   /**
293    * Undefined assignment operator.
294    */
295   VisualFactoryCache& operator=(const VisualFactoryCache& rhs);
296
297 private:
298   /**
299    * @brief Returns a cached Texture to use when a visual has failed to correctly render
300    * @param[in] brokenIndex The index of broken image
301    *
302    * @return The broken image texture.
303    */
304   Texture GetBrokenVisualImage(uint32_t brokenIndex);
305
306   /**
307    * @brief Gets the Proper broken image index
308    * @param[in] size The size of actor
309    *
310    * @return The index of broken image
311    */
312   int32_t GetProperBrokenImageIndex(const Vector2& size);
313
314   /**
315    * @brief Apply a texture and uniforms
316    *
317    * @param[in,out] renderer The renderer for broken image
318    * @param[in] index The index of broken image
319    */
320   void ApplyTextureAndUniforms(Renderer& renderer, int index);
321
322   /**
323    * @brief Gets a geometry for npatch image
324    *
325    * @param[in] index the index of broken image
326    * @return The Geometry for NPatch
327    */
328   Geometry GetNPatchGeometry(int index);
329
330   /**
331    * @brief Gets the Npatch Shader object
332    *
333    * @param[in] index The index of broken image
334    * @return The Shader for NPatch
335    */
336   Shader GetNPatchShader(int index);
337
338   /**
339    * @brief Returns a broken image type
340    * @param[in] index BrokenImage index
341    * @return The broken image type.
342    */
343   VisualUrl::Type GetBrokenImageVisualType(int index);
344
345 private:
346   struct BrokenImageInfo
347   {
348     BrokenImageInfo()
349     : visualType(),
350       url(""),
351       npatchId(NPatchData::INVALID_NPATCH_DATA_ID),
352       texture(),
353       width(0),
354       height(0)
355     {
356     }
357
358     ~BrokenImageInfo()
359     {
360     }
361
362     // Data
363     VisualUrl::Type          visualType;
364     std::string              url;
365     NPatchData::NPatchDataId npatchId;
366     Texture                  texture;
367     uint32_t                 width;
368     uint32_t                 height;
369   };
370
371   Geometry mGeometry[GEOMETRY_TYPE_MAX + 1];
372   Shader   mShader[SHADER_TYPE_MAX + 1];
373
374   bool mLoadYuvPlanes; ///< A global flag to specify if the image should be loaded as yuv planes
375
376   ImageAtlasManagerPtr mAtlasManager;
377   TextureManager       mTextureManager;
378   NPatchLoader         mNPatchLoader;
379   SvgLoader            mSvgLoader;
380
381   std::unique_ptr<VectorAnimationManager> mVectorAnimationManager;
382   bool                                    mPreMultiplyOnLoad;
383   std::vector<BrokenImageInfo>            mBrokenImageInfoContainer;
384   std::string                             mDefaultBrokenImageUrl;
385   bool                                    mUseDefaultBrokenImageOnly;
386 };
387
388 } // namespace Internal
389
390 } // namespace Toolkit
391
392 } // namespace Dali
393
394 #endif // DALI_TOOLKIT_VISUAL_FACTORY_CACHE_H