[dali_2.0.25] 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) 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
32 namespace Dali
33 {
34 class Texture;
35
36 namespace Toolkit
37 {
38 namespace Internal
39 {
40 class ImageAtlasManager;
41 class NPatchLoader;
42 class TextureManager;
43 class VectorAnimationManager;
44
45 typedef IntrusivePtr<ImageAtlasManager> ImageAtlasManagerPtr;
46
47 /**
48  * Caches shaders and geometries. Owned by VisualFactory.
49  */
50 class VisualFactoryCache
51 {
52 public:
53   /**
54    * Type of shader for caching.
55    */
56   enum ShaderType
57   {
58     COLOR_SHADER,
59     COLOR_SHADER_ROUNDED_CORNER,
60     COLOR_SHADER_BLUR_EDGE,
61     BORDER_SHADER,
62     BORDER_SHADER_ANTI_ALIASING,
63     GRADIENT_SHADER_LINEAR_USER_SPACE,
64     GRADIENT_SHADER_LINEAR_BOUNDING_BOX,
65     GRADIENT_SHADER_RADIAL_USER_SPACE,
66     GRADIENT_SHADER_RADIAL_BOUNDING_BOX,
67     GRADIENT_SHADER_LINEAR_USER_SPACE_ROUNDED_CORNER,
68     GRADIENT_SHADER_LINEAR_BOUNDING_BOX_ROUNDED_CORNER,
69     GRADIENT_SHADER_RADIAL_USER_SPACE_ROUNDED_CORNER,
70     GRADIENT_SHADER_RADIAL_BOUNDING_BOX_ROUNDED_CORNER,
71     IMAGE_SHADER,
72     IMAGE_SHADER_ATLAS_DEFAULT_WRAP,
73     IMAGE_SHADER_ATLAS_CUSTOM_WRAP,
74     IMAGE_SHADER_ROUNDED_CORNER,
75     NINE_PATCH_SHADER,
76     NINE_PATCH_MASK_SHADER,
77     TEXT_SHADER_MULTI_COLOR_TEXT,
78     TEXT_SHADER_MULTI_COLOR_TEXT_WITH_STYLE,
79     TEXT_SHADER_SINGLE_COLOR_TEXT,
80     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE,
81     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_EMOJI,
82     TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE_AND_EMOJI,
83     ANIMATED_GRADIENT_SHADER_LINEAR_BOUNDING_REFLECT,
84     ANIMATED_GRADIENT_SHADER_LINEAR_BOUNDING_REPEAT,
85     ANIMATED_GRADIENT_SHADER_LINEAR_BOUNDING_CLAMP,
86     ANIMATED_GRADIENT_SHADER_LINEAR_USER_REFLECT,
87     ANIMATED_GRADIENT_SHADER_LINEAR_USER_REPEAT,
88     ANIMATED_GRADIENT_SHADER_LINEAR_USER_CLAMP,
89     ANIMATED_GRADIENT_SHADER_RADIAL_BOUNDING_REFLECT,
90     ANIMATED_GRADIENT_SHADER_RADIAL_BOUNDING_REPEAT,
91     ANIMATED_GRADIENT_SHADER_RADIAL_BOUNDING_CLAMP,
92     ANIMATED_GRADIENT_SHADER_RADIAL_USER_REFLECT,
93     ANIMATED_GRADIENT_SHADER_RADIAL_USER_REPEAT,
94     ANIMATED_GRADIENT_SHADER_RADIAL_USER_CLAMP,
95     WIREFRAME_SHADER,
96     ARC_BUTT_CAP_SHADER,
97     ARC_ROUND_CAP_SHADER,
98     SHADER_TYPE_MAX = ARC_ROUND_CAP_SHADER
99   };
100
101   /**
102    * Type of geometry for caching.
103    */
104   enum GeometryType
105   {
106     QUAD_GEOMETRY,
107     BORDER_GEOMETRY,
108     NINE_PATCH_GEOMETRY,
109     NINE_PATCH_BORDER_GEOMETRY,
110     WIREFRAME_GEOMETRY,
111     GEOMETRY_TYPE_MAX = WIREFRAME_GEOMETRY
112   };
113
114 public:
115   /**
116    * @brief Constructor
117    *
118    * @param[in] preMultiplyOnLoad True if image visuals should pre-multiply alpha on image load.
119    */
120   VisualFactoryCache(bool preMultiplyOnLoad);
121
122   /**
123    * @brief Destructor
124    */
125   ~VisualFactoryCache();
126
127   /**
128    * Request geometry of the given type.
129    * @return The geometry of the required type if it exist in the cache. Otherwise, an empty handle is returned.
130    */
131   Geometry GetGeometry(GeometryType type);
132
133   /**
134    * Cache the geometry of the give type.
135    * @param[in] type The geometry type.
136    * @param[in] geometry The geometry for caching.
137    */
138   void SaveGeometry(GeometryType type, Geometry geometry);
139
140   /**
141    * Request shader of the given type.
142    * @return The shader of the required type if it exist in the cache. Otherwise, an empty handle is returned.
143    */
144   Shader GetShader(ShaderType type);
145
146   /**
147    * Cache the geometry of the give type.
148    * @param[in] type The geometry type.
149    * @param[in] geometry The geometry for caching.
150    */
151   void SaveShader(ShaderType type, Shader shader);
152
153   /*
154    * Greate the quad geometry.
155    * Quad geometry is shared by multiple kind of Renderer, so implement it in the factory-cache.
156    */
157   static Geometry CreateQuadGeometry();
158
159   /**
160    * Create the grid geometry.
161    * @param[in] gridSize The size of the grid.
162    * @return The created grid geometry.
163    */
164   static Geometry CreateGridGeometry(Uint16Pair gridSize);
165
166   /**
167    * @brief Returns a new Texture to use when a visual has failed to correctly render
168    * @return The broken image texture.
169    */
170   Texture GetBrokenVisualImage();
171
172   /**
173    * @copydoc Toolkit::VisualFactory::SetPreMultiplyOnLoad()
174    */
175   void SetPreMultiplyOnLoad(bool preMultiply);
176
177   /**
178    * @copydoc Toolkit::VisualFactory::GetPreMultiplyOnLoad()
179    */
180   bool GetPreMultiplyOnLoad();
181
182   /**
183    * @brief Set an image to be used when a visual has failed to correctly render
184    * @param[in] brokenImageUrl The broken image url.
185    */
186   void SetBrokenImageUrl(const std::string& brokenImageUrl);
187
188 public:
189   /**
190    * Get the image atlas manager.
191    * @return A pointer to the atlas manager
192    */
193   ImageAtlasManagerPtr GetAtlasManager();
194
195   /**
196    * Get the texture manager
197    * @return A reference to the texture manager
198    */
199   TextureManager& GetTextureManager();
200
201   /**
202    * Get the N-Patch texture cache.
203    * @return A reference to the N patch loader
204    */
205   NPatchLoader& GetNPatchLoader();
206
207   /**
208    * Get the SVG rasterization thread.
209    * @return A raw pointer pointing to the SVG rasterization thread.
210    */
211   SvgRasterizeThread* GetSVGRasterizationThread();
212
213   /**
214    * Get the vector animation manager.
215    * @return A reference to the vector animation manager.
216    */
217   VectorAnimationManager& GetVectorAnimationManager();
218
219 protected:
220   /**
221    * Undefined copy constructor.
222    */
223   VisualFactoryCache(const VisualFactoryCache&);
224
225   /**
226    * Undefined assignment operator.
227    */
228   VisualFactoryCache& operator=(const VisualFactoryCache& rhs);
229
230 private:
231   Geometry mGeometry[GEOMETRY_TYPE_MAX + 1];
232   Shader   mShader[SHADER_TYPE_MAX + 1];
233
234   ImageAtlasManagerPtr                    mAtlasManager;
235   TextureManager                          mTextureManager;
236   NPatchLoader                            mNPatchLoader;
237   Texture                                 mBrokenImageTexture;
238   SvgRasterizeThread*                     mSvgRasterizeThread;
239   std::unique_ptr<VectorAnimationManager> mVectorAnimationManager;
240   std::string                             mBrokenImageUrl;
241   bool                                    mPreMultiplyOnLoad;
242 };
243
244 } // namespace Internal
245
246 } // namespace Toolkit
247
248 } // namespace Dali
249
250 #endif // DALI_TOOLKIT_VISUAL_FACTORY_CACHE_H