Make NPatchData receive LoadComplete call from TextureManager.

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / texture-manager-impl.h

diff --git a/dali-toolkit/internal/visuals/texture-manager-impl.h b/dali-toolkit/internal/visuals/texture-manager-impl.h
old mode 100755 (executable)
new mode 100644 (file)
index 5146991..89a8ed0
--- a/dali-toolkit/internal/visuals/texture-manager-impl.h
+++ b/dali-toolkit/internal/visuals/texture-manager-impl.h
@@ -27,6 +27,7 @@
 #include <dali/public-api/rendering/texture-set.h>
 #include <dali/devel-api/common/owner-container.h>
 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 #include <dali/public-api/rendering/texture-set.h>
 #include <dali/devel-api/common/owner-container.h>
 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>

+#include <dali/public-api/rendering/geometry.h>

 
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/image-loader/async-image-loader-devel.h>
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/devel-api/image-loader/async-image-loader-devel.h>


@@ -73,18 +74,19 @@ public:
   };
 
   /**
   };
 
   /**

-   * Whether the pixel data should be kept in TextureManager, or uploaded for rendering
+   * Whether the pixel data should be kept in TextureManager, returned with pixelBuffer or uploaded for rendering

    */
    */

-  enum StorageType
+  enum class StorageType: uint8_t

   {
     KEEP_PIXEL_BUFFER,
   {
     KEEP_PIXEL_BUFFER,

+    RETURN_PIXEL_BUFFER,

     UPLOAD_TO_TEXTURE
   };
 
   /**
    * Whether the texture should be loaded synchronously or asynchronously.
    */
     UPLOAD_TO_TEXTURE
   };
 
   /**
    * Whether the texture should be loaded synchronously or asynchronously.
    */

-  enum LoadType
+  enum class LoadType: uint8_t

   {
     LOAD_ASYNCHRONOUSLY,
     LOAD_SYNCHRONOUSLY
   {
     LOAD_ASYNCHRONOUSLY,
     LOAD_SYNCHRONOUSLY


@@ -93,7 +95,7 @@ public:
   /**
    * @brief The LoadState Enumeration represents the current state of a particular Texture's life-cycle.
    */
   /**
    * @brief The LoadState Enumeration represents the current state of a particular Texture's life-cycle.
    */

-  enum LoadState
+  enum class LoadState: uint8_t

   {
     NOT_STARTED,     ///< Default
     LOADING,         ///< Loading has been started, but not finished.
   {
     NOT_STARTED,     ///< Default
     LOADING,         ///< Loading has been started, but not finished.


@@ -158,11 +160,38 @@ public:
   /**
    * Destructor.
    */
   /**
    * Destructor.
    */

-  ~TextureManager();
+  ~TextureManager() override;

 
   // TextureManager Main API:
 
   /**
 
   // TextureManager Main API:
 
   /**

+   * @brief Requests an frame of animated image load.
+   *
+   * The parameters are used to specify how the animated image is loaded.
+   * The observer has the LoadComplete method called when the load is ready.
+   *
+   * @param[in] animatedImageLoading  The AnimatedImageLoading that contain the animated image information
+   * @param[in] frameIndex            The frame index to load.
+   * @param[in] samplingMode          The SamplingMode to use
+   * @param[in] synchronousLoading    true if the frame should be loaded synchronously
+   * @param[out] textureId            The textureId of the frame
+   * @param[in] wrapModeU             Horizontal Wrap mode
+   * @param[in] wrapModeV             Vertical Wrap mode
+   * @param[in] textureObserver       The client object should inherit from this and provide the "UploadCompleted" virtual.
+   *                                  This is called when an image load completes (or fails).
+   *
+   * @return                          The texture set containing the frame of animated image, or empty if still loading.
+   */
+
+  TextureSet LoadAnimatedImageTexture( Dali::AnimatedImageLoading animatedImageLoading,
+                                       uint32_t frameIndex,
+                                       Dali::SamplingMode::Type samplingMode,
+                                       bool synchronousLoading,
+                                       TextureManager::TextureId& textureId,
+                                       Dali::WrapMode::Type wrapModeU, Dali::WrapMode::Type wrapModeV,
+                                       TextureUploadObserver* textureObserver );
+
+  /**

    * @brief Requests an image load of the given URL to get PixelBuffer.
    *
    * The parameters are used to specify how the image is loaded.
    * @brief Requests an image load of the given URL to get PixelBuffer.
    *
    * The parameters are used to specify how the image is loaded.


@@ -398,6 +427,15 @@ public:
    */
   void SetBrokenImageUrl(const std::string& brokenImageUrl);
 
    */
   void SetBrokenImageUrl(const std::string& brokenImageUrl);
 

+  /**
+   * @brief Returns the geometry associated with texture.
+   * @param[in] textureId Id of the texture
+   * @param[out] frontElements number of front elements
+   * @param[out] backElements number of back elements
+   * @return Returns valid geometry object
+   */
+  Geometry GetRenderGeometry(TextureId textureId, uint32_t& frontElements, uint32_t& backElements );
+

 private:
 
   /**
 private:
 
   /**


@@ -430,6 +468,8 @@ private:
    * @param[in] reloadPolicy          Forces a reload of the texture even if already cached
    * @param[in] preMultiplyOnLoad     True if the image color should be multiplied by it's alpha. Set to false if
    *                                  there is no alpha
    * @param[in] reloadPolicy          Forces a reload of the texture even if already cached
    * @param[in] preMultiplyOnLoad     True if the image color should be multiplied by it's alpha. Set to false if
    *                                  there is no alpha

+   * @param[in] animatedImageLoading  The AnimatedImageLoading to load animated image
+   * @param[in] frameIndex            The frame index of a frame to be loaded frame

    * @return                          A TextureId to use as a handle to reference this Texture
    */
   TextureId RequestLoadInternal(
    * @return                          A TextureId to use as a handle to reference this Texture
    */
   TextureId RequestLoadInternal(


@@ -446,7 +486,8 @@ private:
     bool                                orientationCorrection,
     TextureManager::ReloadPolicy        reloadPolicy,
     MultiplyOnLoad&                     preMultiplyOnLoad,
     bool                                orientationCorrection,
     TextureManager::ReloadPolicy        reloadPolicy,
     MultiplyOnLoad&                     preMultiplyOnLoad,

-    bool                                loadPixelBuffer );
+    Dali::AnimatedImageLoading          animatedImageLoading,
+    uint32_t                            frameIndex );

 
   /**
    * @brief Get the current state of a texture
 
   /**
    * @brief Get the current state of a texture


@@ -478,7 +519,8 @@ private:
                  TextureManager::TextureHash hash,
                  bool orientationCorrection,
                  bool preMultiplyOnLoad,
                  TextureManager::TextureHash hash,
                  bool orientationCorrection,
                  bool preMultiplyOnLoad,

-                 bool loadPixelBuffer )
+                 Dali::AnimatedImageLoading animatedImageLoading,
+                 uint32_t frameIndex )

     : url( url ),
       desiredSize( desiredSize ),
       useSize( desiredSize ),
     : url( url ),
       desiredSize( desiredSize ),
       useSize( desiredSize ),


@@ -488,17 +530,18 @@ private:
       hash( hash ),
       scaleFactor( scaleFactor ),
       referenceCount( 1u ),
       hash( hash ),
       scaleFactor( scaleFactor ),
       referenceCount( 1u ),

-      loadState( NOT_STARTED ),
+      loadState( LoadState::NOT_STARTED ),

       fittingMode( fittingMode ),
       samplingMode( samplingMode ),
       fittingMode( fittingMode ),
       samplingMode( samplingMode ),

-      storageType( UPLOAD_TO_TEXTURE ),
+      storageType( StorageType::UPLOAD_TO_TEXTURE ),
+      animatedImageLoading( animatedImageLoading ),
+      frameIndex( frameIndex ),

       loadSynchronously( loadSynchronously ),
       useAtlas( useAtlas ),
       cropToMask( cropToMask ),
       orientationCorrection( true ),
       preMultiplyOnLoad( preMultiplyOnLoad ),
       loadSynchronously( loadSynchronously ),
       useAtlas( useAtlas ),
       cropToMask( cropToMask ),
       orientationCorrection( true ),
       preMultiplyOnLoad( preMultiplyOnLoad ),

-      preMultiplied( false ),
-      loadPixelBuffer( loadPixelBuffer )
+      preMultiplied( false )

     {
     }
 
     {
     }
 


@@ -520,10 +563,12 @@ private:
     TextureManager::TextureHash hash; ///< The hash used to cache this Texture
     float scaleFactor;             ///< The scale factor to apply to the Texture when masking
     int16_t referenceCount;        ///< The reference count of clients using this Texture
     TextureManager::TextureHash hash; ///< The hash used to cache this Texture
     float scaleFactor;             ///< The scale factor to apply to the Texture when masking
     int16_t referenceCount;        ///< The reference count of clients using this Texture

-    LoadState loadState:4;         ///< The load state showing the load progress of the Texture
-    FittingMode::Type fittingMode:2; ///< The requested FittingMode
+    LoadState loadState;           ///< The load state showing the load progress of the Texture
+    FittingMode::Type fittingMode:3; ///< The requested FittingMode

     Dali::SamplingMode::Type samplingMode:3; ///< The requested SamplingMode
     Dali::SamplingMode::Type samplingMode:3; ///< The requested SamplingMode

-    StorageType storageType:2;     ///< CPU storage / GPU upload;
+    StorageType storageType;       ///< CPU storage / GPU upload;
+    Dali::AnimatedImageLoading animatedImageLoading; ///< AnimatedImageLoading that contains animated image information.
+    uint32_t frameIndex;           ///< frame index that be loaded, in case of animated image

     bool loadSynchronously:1;      ///< True if synchronous loading was requested
     UseAtlas useAtlas:2;           ///< USE_ATLAS if an atlas was requested.
                                    ///< This is updated to false if atlas is not used
     bool loadSynchronously:1;      ///< True if synchronous loading was requested
     UseAtlas useAtlas:2;           ///< USE_ATLAS if an atlas was requested.
                                    ///< This is updated to false if atlas is not used


@@ -531,7 +576,6 @@ private:
     bool orientationCorrection:1;  ///< true if the image should be rotated to match exif orientation data
     bool preMultiplyOnLoad:1;      ///< true if the image's color should be multiplied by it's alpha
     bool preMultiplied:1;          ///< true if the image's color was multiplied by it's alpha
     bool orientationCorrection:1;  ///< true if the image should be rotated to match exif orientation data
     bool preMultiplyOnLoad:1;      ///< true if the image's color should be multiplied by it's alpha
     bool preMultiplied:1;          ///< true if the image's color was multiplied by it's alpha

-    bool loadPixelBuffer:1;        ///< true if the image is needed to be returned as PixelBuffer

   };
 
   /**
   };
 
   /**


@@ -656,6 +700,14 @@ private:
   void UploadTexture( Devel::PixelBuffer& pixelBuffer, TextureInfo& textureInfo );
 
   /**
   void UploadTexture( Devel::PixelBuffer& pixelBuffer, TextureInfo& textureInfo );
 
   /**

+   * Creates tiled geometry of for the texture which separates fully-opaque
+   * tiles from ones which use transparency.
+   * @param pixelBuffer
+   * @param textureInfo
+   */
+  bool CreateTiledGeometry( const Devel::PixelBuffer& pixelBuffer, TextureInfo& textureInfo );
+
+  /**

    * Mark the texture as complete, and inform observers
    * @param[in] textureInfo The struct associated with this Texture
    */
    * Mark the texture as complete, and inform observers
    * @param[in] textureInfo The struct associated with this Texture
    */


@@ -688,13 +740,13 @@ private:
    * Only applies size, fitting mode andsampling mode if the size is specified.
    * Only applies maskTextureId if it isn't INVALID_TEXTURE_ID
    * Always applies useAtlas.
    * Only applies size, fitting mode andsampling mode if the size is specified.
    * Only applies maskTextureId if it isn't INVALID_TEXTURE_ID
    * Always applies useAtlas.

-   * @param[in] url          The URL of the image to load
-   * @param[in] size         The image size
-   * @param[in] fittingMode  The FittingMode to use
-   * @param[in] samplingMode The SamplingMode to use
-   * @param[in] useAtlas     True if atlased
-   * @param[in] maskTextureId The masking texture id (or INVALID_TEXTURE_ID)
-   * @return                 A hash of the provided data for caching.
+   * @param[in] url              The URL of the image to load
+   * @param[in] size             The image size
+   * @param[in] fittingMode      The FittingMode to use
+   * @param[in] samplingMode     The SamplingMode to use
+   * @param[in] useAtlas         True if atlased
+   * @param[in] maskTextureId    The masking texture id (or INVALID_TEXTURE_ID)
+   * @return                     A hash of the provided data for caching.

    */
   TextureHash GenerateHash( const std::string& url, const ImageDimensions size,
                             const FittingMode::Type fittingMode,
    */
   TextureHash GenerateHash( const std::string& url, const ImageDimensions size,
                             const FittingMode::Type fittingMode,


@@ -704,14 +756,15 @@ private:
   /**
    * @brief Looks up a cached texture by its hash.
    * If found, the given parameters are used to check there is no hash-collision.
   /**
    * @brief Looks up a cached texture by its hash.
    * If found, the given parameters are used to check there is no hash-collision.

-   * @param[in] hash          The hash to look up
-   * @param[in] url           The URL of the image to load
-   * @param[in] size          The image size
-   * @param[in] fittingMode   The FittingMode to use
-   * @param[in] samplingMode  The SamplingMode to use
-   * @param[in] useAtlas      True if atlased
-   * @param[in] maskTextureId Optional texture ID to use to mask this image
-   * @return A TextureId of a cached Texture if found. Or INVALID_TEXTURE_ID if not found.
+   * @param[in] hash              The hash to look up
+   * @param[in] url               The URL of the image to load
+   * @param[in] size              The image size
+   * @param[in] fittingMode       The FittingMode to use
+   * @param[in] samplingMode      The SamplingMode to use
+   * @param[in] useAtlas          True if atlased
+   * @param[in] maskTextureId     Optional texture ID to use to mask this image
+   * @param[in] preMultiplyOnLoad if the image's color should be multiplied by it's alpha. Set to OFF if there is no alpha.
+   * @return                      A TextureId of a cached Texture if found. Or INVALID_TEXTURE_ID if not found.

    */
   TextureManager::TextureId FindCachedTexture(
     const TextureManager::TextureHash hash,
    */
   TextureManager::TextureId FindCachedTexture(
     const TextureManager::TextureHash hash,


@@ -738,6 +791,16 @@ private:
     AsyncLoadingHelper(TextureManager& textureManager);
 
     /**
     AsyncLoadingHelper(TextureManager& textureManager);
 
     /**

+     * @brief Load a new frame of animated image
+     * @param[in] textureId             TextureId to reference the texture that will be loaded
+     * @param[in] animatedImageLoading  The AnimatedImageLoading to load animated image
+     * @param[in] frameIndex            The frame index of a frame to be loaded frame
+     */
+    void LoadAnimatedImage( TextureId textureId,
+                            Dali::AnimatedImageLoading animatedImageLoading,
+                            uint32_t frameIndex);
+
+    /**

      * @brief Load a new texture.
      * @param[in] textureId             TextureId to reference the texture that will be loaded
      * @param[in] url                   The URL of the image to load
      * @brief Load a new texture.
      * @param[in] textureId             TextureId to reference the texture that will be loaded
      * @param[in] url                   The URL of the image to load