[dali_1.2.13] Merge branch 'devel/master'
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / image / image-visual.h
1 #ifndef DALI_TOOLKIT_INTERNAL_IMAGE_VISUAL_H
2 #define DALI_TOOLKIT_INTERNAL_IMAGE_VISUAL_H
3
4 /*
5  * Copyright (c) 2016 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
21 // EXTERNAL INCLUDES
22 #include <dali/public-api/common/intrusive-ptr.h>
23 #include <dali/public-api/images/image.h>
24 #include <dali/public-api/images/image-operations.h>
25 #include <dali/public-api/images/resource-image.h>
26 #include <dali/devel-api/object/weak-handle.h>
27
28 // INTERNAL INCLUDES
29 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
30 #include <dali-toolkit/devel-api/image-loader/atlas-upload-observer.h>
31
32 namespace Dali
33 {
34
35 class NativeImage;
36
37 namespace Toolkit
38 {
39
40 namespace Internal
41 {
42
43 class ImageVisual;
44 typedef IntrusivePtr< ImageVisual > ImageVisualPtr;
45
46 /**
47  * The visual which renders an image to the control's quad
48  *
49  * The following properties are optional
50  *
51  * | %Property Name     | Type             |
52  * |--------------------|------------------|
53  * | url                | STRING           |
54  * | fittingMode        | STRING           |
55  * | samplingMode       | STRING           |
56  * | desiredWidth       | INT              |
57  * | desiredHeight      | INT              |
58  * | synchronousLoading | BOOLEAN          |
59  *
60  * where imageFittingMode should be one of the following fitting modes:
61  *   "SHRINK_TO_FIT"
62  *   "SCALE_TO_FIT"
63  *   "FIT_WIDTH"
64  *   "FIT_HEIGHT"
65  *   "DEFAULT"
66  *
67  * where imageSamplingMode should be one of the following sampling modes:
68  *   "BOX"
69  *   "NEAREST"
70  *   "LINEAR"
71  *   "BOX_THEN_NEAREST"
72  *   "BOX_THEN_LINEAR"
73  *   "NO_FILTER"
74  *   "DONT_CARE"
75  *   "DEFAULT"
76  *
77  */
78 class ImageVisual: public Visual::Base, public ConnectionTracker, public AtlasUploadObserver
79 {
80 public:
81
82   /**
83    * @brief Create a new image visual with a URL.
84    *
85    * The visual will load the Image asynchronously when the associated actor is put on stage, and destroy the image when it is off stage
86    *
87    * @param[in] factoryCache The VisualFactoryCache object
88    * @param[in] imageUrl The URL of the image resource to use
89    * @param[in] size The width and height to fit the loaded image to.
90    * @param[in] fittingMode The FittingMode of the resource to load
91    * @param[in] samplingMode The SamplingMode of the resource to load
92    */
93   static ImageVisualPtr New( VisualFactoryCache& factoryCache,
94                              const std::string& imageUrl,
95                              ImageDimensions size = ImageDimensions(),
96                              FittingMode::Type fittingMode = FittingMode::DEFAULT,
97                              Dali::SamplingMode::Type samplingMode = SamplingMode::BOX_THEN_LINEAR );
98
99   /**
100    * @brief Create a new image visual with an Image type.
101    *
102    * @param[in] factoryCache The VisualFactoryCache object
103    * @param[in] image The image to use
104    */
105   static ImageVisualPtr New( VisualFactoryCache& factoryCache, const Image& image );
106
107 public:  // from Visual
108
109   /**
110    * @copydoc Visual::Base::GetNaturalSize
111    */
112   virtual void GetNaturalSize( Vector2& naturalSize ) const;
113
114   /**
115    * @copydoc Visual::Base::CreatePropertyMap
116    */
117   virtual void DoCreatePropertyMap( Property::Map& map ) const;
118
119   /**
120    * @copydoc Visual::Base::DoSetProperty
121    */
122   virtual void DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue );
123
124   /**
125    * @copydoc Visual::Base::DoGetProperty
126    */
127   virtual Dali::Property::Value DoGetProperty( Dali::Property::Index index );
128
129 protected:
130
131   /**
132    * @brief Constructor with a URL.
133    *
134    * The visual will load the Image asynchronously when the associated actor is put on stage, and destroy the image when it is off stage
135    *
136    * @param[in] factoryCache The VisualFactoryCache object
137    * @param[in] imageUrl The URL of the image resource to use
138    * @param[in] size The width and height to fit the loaded image to.
139    * @param[in] fittingMode The FittingMode of the resource to load
140    * @param[in] samplingMode The SamplingMode of the resource to load
141    */
142   ImageVisual( VisualFactoryCache& factoryCache,
143                const std::string& imageUrl,
144                ImageDimensions size,
145                FittingMode::Type fittingMode,
146                Dali::SamplingMode::Type samplingMode );
147
148   /**
149    * @brief Constructor with an Image type.
150    *
151    * @param[in] factoryCache The VisualFactoryCache object
152    * @param[in] image The image to use
153    */
154   ImageVisual( VisualFactoryCache& factoryCache, const Image& image );
155
156   /**
157    * @brief A reference counted object may only be deleted by calling Unreference().
158    */
159   virtual ~ImageVisual();
160
161   /**
162    * @copydoc Visual::Base::DoSetProperties
163    */
164   virtual void DoSetProperties( const Property::Map& propertyMap );
165
166   /**
167    * @copydoc Visual::Base::DoSetOnStage
168    */
169   virtual void DoSetOnStage( Actor& actor );
170
171   /**
172    * @copydoc Visual::Base::DoSetOffStage
173    */
174   virtual void DoSetOffStage( Actor& actor );
175
176   /**
177    * @copydoc Visual::Base::OnSetTransform
178    */
179   virtual void OnSetTransform();
180
181 public:
182
183   /**
184    * Get the standard image rendering shader.
185    * @param[in] factoryCache A pointer pointing to the VisualFactoryCache object
186    * @param[in] atlasing Whether texture atlasing is applied.
187    * @param[in] defaultTextureWrapping Whether the default texture wrap mode is applied.
188    */
189   static Shader GetImageShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping );
190
191   /**
192    * @copydoc AtlasUploadObserver::UploadCompleted
193    *
194    * To avoid rendering garbage pixels, renderer should be added to actor after the resources are ready.
195    * This callback is the place to add the renderer as it would be called once the loading is finished.
196    */
197   virtual void UploadCompleted();
198
199 private:
200
201   /**
202    * @brief Applies the image to the texture set used for this renderer
203    *
204    * @param[in] image The Image to apply to the texture set used for this renderer
205    */
206   void ApplyImageToSampler( const Image& image );
207
208   /**
209    * @brief Initializes the Dali::Renderer from an image url string
210    *
211    * @param[in] imageUrl The image url string to intialize this ImageVisual from
212    */
213   void InitializeRenderer( const std::string& imageUrl );
214
215   /**
216    * @brief Initializes the Dali::Renderer from an image handle
217    *
218    * @param[in] image The image handle to intialize this ImageVisual from
219    */
220   void InitializeRenderer( const Image& image );
221
222   /**
223    * @brief Creates the Dali::Renderer (potentially from the renderer cache), initializing it
224    * @param[in] textures to use
225    */
226   void CreateRenderer( TextureSet& textures );
227
228   /**
229    * @brief Creates the Dali::Renderer for NativeImage with custom sampler type and prefix, initializing it
230    * @param NativeImageRenderer
231    */
232   void CreateNativeImageRenderer( NativeImage& nativeImage );
233
234   /**
235    * @brief Query whether resources requires to be loaded synchronously.
236    * @return Returns true if synchronous resource loading is required, false otherwise.
237    */
238   bool IsSynchronousResourceLoading() const;
239
240   /**
241    * @brief Load the resource synchronously
242    */
243   void LoadResourceSynchronously();
244
245   /**
246    * Creates the texture set and adds the texture to it
247    * @param[out] textureRect The texture area of the texture in the atlas.
248    * @param[in] url The URL of the image resource to use.
249    * @param[in] synchronousLoading If true, the resource is loaded synchronously, otherwise asynchronously.
250    * @param[in] attemptAtlasing If true will attempt atlasing, otherwise create unique texture
251    * @return the texture set to use
252    */
253   TextureSet CreateTextureSet( Vector4& textureRect, const std::string& url, bool synchronousLoading, bool attemptAtlasing );
254
255   /**
256    * Callback function of image resource loading succeed
257    * @param[in] image The Image content that we attempted to load from mImageUrl
258    */
259   void OnImageLoaded( ResourceImage image );
260
261   /**
262    * Set the value to the uTextureRect uniform
263    * @param[in] textureRect The texture rectangular area.
264    */
265   void SetTextureRectUniform( const Vector4& textureRect  );
266
267   /**
268    * Clean the renderer from cache, and remove the image from atlas if it is not used anymore
269    */
270   void CleanCache(const std::string& url);
271
272 private:
273
274   Image mImage;
275   PixelData mPixels;
276   Vector4 mPixelArea;
277   WeakHandle<Actor> mPlacementActor;
278   std::string mImageUrl;
279
280   Dali::ImageDimensions mDesiredSize;
281   Dali::FittingMode::Type mFittingMode:3;
282   Dali::SamplingMode::Type mSamplingMode:4;
283   Dali::WrapMode::Type mWrapModeU:3;
284   Dali::WrapMode::Type mWrapModeV:3;
285
286 };
287
288 } // namespace Internal
289
290 } // namespace Toolkit
291
292 } // namespace Dali
293
294 #endif /* DALI_TOOLKIT_INTERNAL_IMAGE_VISUAL_H */