X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Ftexture-manager-impl.h;h=651bc44aa9cb6fac2f479963902ce4a4e1431972;hp=117bd1f2c98d2343b731fcd7940a9d6d0293d245;hb=787daa34be8ea18f1066045cf922254fe32777c8;hpb=44bb6ae11e1c189104d9a8c9881bd5e524b398c0 diff --git a/dali-toolkit/internal/visuals/texture-manager-impl.h b/dali-toolkit/internal/visuals/texture-manager-impl.h old mode 100644 new mode 100755 index 117bd1f..651bc44 --- a/dali-toolkit/internal/visuals/texture-manager-impl.h +++ b/dali-toolkit/internal/visuals/texture-manager-impl.h @@ -2,7 +2,7 @@ #define DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H /* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * Copyright (c) 2019 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -45,6 +46,8 @@ namespace Toolkit namespace Internal { +class ImageAtlasManager; +typedef IntrusivePtr ImageAtlasManagerPtr; /** * The TextureManager provides a common Image loading API for Visuals. @@ -96,13 +99,57 @@ public: LOADING, ///< Loading has been started, but not finished. LOAD_FINISHED, ///< Loading has finished. (for CPU storage only) WAITING_FOR_MASK,///< Loading has finished, but waiting for mask image + MASK_APPLYING, ///< Loading has finished, Mask is applying + MASK_APPLIED, ///< Loading has finished, Mask is applyied by GPU UPLOADED, ///< Uploaded and ready. (For GPU upload only) CANCELLED, ///< Removed before loading completed LOAD_FAILED ///< Async loading failed, e.g. connection problem }; + /** + * @brief Types of reloading policies + */ + enum class ReloadPolicy + { + CACHED = 0, ///< Loads cached texture if it exists. + FORCED ///< Forces reloading of texture. + }; + + /** + * @brief Whether to multiply alpha into color channels on load + */ + enum class MultiplyOnLoad + { + LOAD_WITHOUT_MULTIPLY = 0, ///< Don't modify the image + MULTIPLY_ON_LOAD ///< Multiply alpha into color channels on load + }; + public: + struct MaskingData + { + MaskingData(); + ~MaskingData() = default; + + VisualUrl mAlphaMaskUrl; + TextureManager::TextureId mAlphaMaskId; + float mContentScaleFactor; + bool mCropToMask; + }; + using MaskingDataPointer = std::unique_ptr; + + + /** + * Class to provide lifecycle event on destruction of texture manager. + */ + struct LifecycleObserver + { + /** + * Called shortly before the texture manager is destroyed. + */ + virtual void TextureManagerDestroyed() = 0; + }; + /** * Constructor. */ @@ -113,7 +160,6 @@ public: */ ~TextureManager(); - // TextureManager Main API: /** @@ -124,22 +170,86 @@ public: * * When the client has finished with the Texture, Remove() should be called. * - * @param[in] url The URL of the image to load - * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic - * @param[in] fittingMode The FittingMode to use - * @param[in] samplingMode The SamplingMode to use - * @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be loaded, and marked successful, - * but "useAtlasing" will be set to false in the "UploadCompleted" callback from the TextureManagerUploadObserver. - * @param[in] observer The client object should inherit from this and provide the "UploadCompleted" virtual. - * This is called when an image load completes (or fails). - * @return A TextureId to use as a handle to reference this Texture - */ - TextureId RequestLoad( const VisualUrl& url, - const ImageDimensions desiredSize, - FittingMode::Type fittingMode, - Dali::SamplingMode::Type samplingMode, - const UseAtlas useAtlasing, - TextureUploadObserver* observer ); + * @param[in] url The URL of the image to load + * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic + * @param[in] fittingMode The FittingMode to use + * @param[in] samplingMode The SamplingMode to use + * @param[in, out] maskInfo Mask info structure + * @param[in] synchronousLoading true if the URL should be loaded synchronously + * @param[out] textureId, The textureId of the URL + * @param[out] textureRect The rectangle within the texture atlas that this URL occupies, + * this is the rectangle in normalized coordinates. + * @param[out] textureRectSize The rectangle within the texture atlas that this URL occupies, + * this is the same rectangle in pixels. + * @param[in,out] atlasingStatus Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still + * be loaded, and marked successful, but this will be set to false. + * If atlasing succeeds, this will be set to true. + * @param[out] loadingStatus The loading status of the texture + * @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). + * @param[in] atlasObserver This is used if the texture is atlased, and will be called instead of + * textureObserver.UploadCompleted + * @param[in] imageAtlasManager The atlas manager to use for atlasing textures + * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data + * @param[in] reloadPolicy Forces a reload of the texture even if already cached + * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the + * image has no alpha channel + * + * @return The texture set containing the image, or empty if still loading. + */ + + TextureSet LoadTexture( const VisualUrl& url, + Dali::ImageDimensions desiredSize, + Dali::FittingMode::Type fittingMode, + Dali::SamplingMode::Type samplingMode, + MaskingDataPointer& maskInfo, + bool synchronousLoading, + TextureManager::TextureId& textureId, + Vector4& textureRect, + Dali::ImageDimensions& textureRectSize, + bool& atlasingStatus, + bool& loadingStatus, + Dali::WrapMode::Type wrapModeU, + Dali::WrapMode::Type wrapModeV, + TextureUploadObserver* textureObserver, + AtlasUploadObserver* atlasObserver, + ImageAtlasManagerPtr imageAtlasManager, + bool orientationCorrection, + TextureManager::ReloadPolicy reloadPolicy, + MultiplyOnLoad& preMultiplyOnLoad ); + + /** + * @brief Requests an image load of the given URL. + * + * The parameters are used to specify how the image is loaded. + * The observer has the UploadComplete method called when the load is ready. + * + * When the client has finished with the Texture, Remove() should be called. + * + * @param[in] url The URL of the image to load + * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic + * @param[in] fittingMode The FittingMode to use + * @param[in] samplingMode The SamplingMode to use + * @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be loaded, and marked successful, + * but "useAtlasing" will be set to false in the "UploadCompleted" callback from the TextureManagerUploadObserver. + * @param[in] observer The client object should inherit from this and provide the "UploadCompleted" virtual. + * This is called when an image load completes (or fails). + * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data + * @param[in] reloadPolicy Forces a reload of the texture even if already cached + * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the image has no alpha channel + * @return A TextureId to use as a handle to reference this Texture + */ + TextureId RequestLoad( const VisualUrl& url, + const ImageDimensions desiredSize, + FittingMode::Type fittingMode, + Dali::SamplingMode::Type samplingMode, + const UseAtlas useAtlasing, + TextureUploadObserver* observer, + bool orientationCorrection, + TextureManager::ReloadPolicy reloadPolicy, + MultiplyOnLoad& preMultiplyOnLoad ); /** * @brief Requests an image load of the given URL, when the texture has @@ -151,28 +261,40 @@ public: * * When the client has finished with the Texture, Remove() should be called. * - * @param[in] url The URL of the image to load - * @param[in] maskTextureId The texture id of an image to mask this with (can be INVALID if no masking required) - * @param[in] contentScale The scale factor to apply to the image before masking - * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic - * @param[in] fittingMode The FittingMode to use - * @param[in] samplingMode The SamplingMode to use - * @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be loaded, and marked successful, - * but "useAtlasing" will be set to false in the "UploadCompleted" callback from the TextureManagerUploadObserver. - * @param[in] cropToMask Only used with masking, this will crop the scaled image to the mask size. If false, then the mask will be scaled to fit the image before being applied. - * @param[in] observer The client object should inherit from this and provide the "UploadCompleted" virtual. - * This is called when an image load completes (or fails). - * @return A TextureId to use as a handle to reference this Texture - */ - TextureId RequestLoad( const VisualUrl& url, - TextureId maskTextureId, - float contentScale, - const ImageDimensions desiredSize, - FittingMode::Type fittingMode, - Dali::SamplingMode::Type samplingMode, - const UseAtlas useAtlasing, - bool cropToMask, - TextureUploadObserver* observer ); + * @param[in] url The URL of the image to load + * @param[in] maskTextureId The texture id of an image to mask this with + * (can be INVALID if no masking required) + * @param[in] contentScale The scale factor to apply to the image before masking + * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic + * @param[in] fittingMode The FittingMode to use + * @param[in] samplingMode The SamplingMode to use + * @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still + * be loaded, and marked successful, + * but "useAtlasing" will be set to false in the "UploadCompleted" callback from + * the TextureManagerUploadObserver. + * @param[in] cropToMask Only used with masking, this will crop the scaled image to the mask size. + * If false, then the mask will be scaled to fit the image before being applied. + * @param[in] observer The client object should inherit from this and provide the "UploadCompleted" + * virtual. + * This is called when an image load completes (or fails). + * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data + * @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 the + * image has no alpha channel + * @return A TextureId to use as a handle to reference this Texture + */ + TextureId RequestLoad( const VisualUrl& url, + TextureId maskTextureId, + float contentScale, + const ImageDimensions desiredSize, + FittingMode::Type fittingMode, + Dali::SamplingMode::Type samplingMode, + const UseAtlas useAtlasing, + bool cropToMask, + TextureUploadObserver* observer, + bool orientationCorrection, + TextureManager::ReloadPolicy reloadPolicy, + MultiplyOnLoad& preMultiplyOnLoad ); /** * Requests a masking image to be loaded. This mask is not uploaded to GL, @@ -191,9 +313,11 @@ public: void Remove( const TextureManager::TextureId textureId ); /** - * Get the visualUrl associated with the texture id + * @brief Get the visualUrl associated with the texture id. + * @param[in] textureId The texture Id to get + * @return The visual Url associated with the texture id. */ - const VisualUrl& GetVisualUrl( TextureId textureId ); + VisualUrl GetVisualUrl( TextureId textureId ); /** * @brief Get the current state of a texture @@ -224,6 +348,25 @@ public: */ TextureSet RemoveExternalTexture( const std::string& url ); + /** + * Add an observer to the object. + * @param[in] observer The observer to add. + */ + void AddObserver( TextureManager::LifecycleObserver& observer ); + + /** + * Remove an observer from the object + * @pre The observer has already been added. + * @param[in] observer The observer to remove. + */ + void RemoveObserver( TextureManager::LifecycleObserver& observer ); + + /** + * @brief Set an image to be used when a visual has failed to correctly render + * @param[in] brokenImageUrl The broken image url. + */ + void SetBrokenImageUrl(const std::string& brokenImageUrl); + private: /** @@ -236,35 +379,55 @@ private: * * When the client has finished with the Texture, Remove() should be called. * - * @param[in] url The URL of the image to load - * @param[in] maskTextureId The texture id of an image to use as a mask. If no mask is required, then set to INVALID_TEXTURE_ID - * @param[in] contentScale The scaling factor to apply to the content when masking - * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic - * @param[in] fittingMode The FittingMode to use - * @param[in] samplingMode The SamplingMode to use - * @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be loaded, and marked successful, - * but "useAtlasing" will be set to false in the "UploadCompleted" callback from the TextureManagerUploadObserver. - * @param[in] cropToMask Whether to crop the target after masking, or scale the mask to the image before masking. - * @param[in] storageType, Whether the pixel data is stored in the cache or uploaded to the GPU - * @param[in] observer The client object should inherit from this and provide the "UploadCompleted" virtual. - * This is called when an image load completes (or fails). - * @return A TextureId to use as a handle to reference this Texture + * @param[in] url The URL of the image to load + * @param[in] maskTextureId The texture id of an image to use as a mask. If no mask is required, then set + * to INVALID_TEXTURE_ID + * @param[in] contentScale The scaling factor to apply to the content when masking + * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic + * @param[in] fittingMode The FittingMode to use + * @param[in] samplingMode The SamplingMode to use + * @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be + * loaded, and marked successful, but "useAtlasing" will be set to false in the + * "UploadCompleted" callback from the TextureManagerUploadObserver. + * @param[in] cropToMask Whether to crop the target after masking, or scale the mask to the image before + * masking. + * @param[in] storageType, Whether the pixel data is stored in the cache or uploaded to the GPU + * @param[in] observer The client object should inherit from this and provide the "UploadCompleted" + * virtual. + * This is called when an image load completes (or fails). + * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data + * @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 + * @return A TextureId to use as a handle to reference this Texture */ TextureId RequestLoadInternal( - const VisualUrl& url, - TextureId maskTextureId, - float contentScale, - const ImageDimensions desiredSize, - FittingMode::Type fittingMode, - Dali::SamplingMode::Type samplingMode, - UseAtlas useAtlas, - bool cropToMask, - StorageType storageType, - TextureUploadObserver* observer ); + const VisualUrl& url, + TextureId maskTextureId, + float contentScale, + const ImageDimensions desiredSize, + FittingMode::Type fittingMode, + Dali::SamplingMode::Type samplingMode, + UseAtlas useAtlas, + bool cropToMask, + StorageType storageType, + TextureUploadObserver* observer, + bool orientationCorrection, + TextureManager::ReloadPolicy reloadPolicy, + MultiplyOnLoad& preMultiplyOnLoad ); + /** + * @brief Get the current state of a texture + * @param[in] textureId The texture id to query + * @return The loading state if the texture is valid, or NOT_STARTED if the textureId + * is not valid. + */ + LoadState GetTextureStateInternal( TextureId textureId ); typedef size_t TextureHash; ///< The type used to store the hash used for Texture caching. + // Structs: + /** * @brief This struct is used to manage the life-cycle of Texture loading and caching. */ @@ -280,7 +443,9 @@ private: bool loadSynchronously, bool cropToMask, UseAtlas useAtlas, - TextureManager::TextureHash hash ) + TextureManager::TextureHash hash, + bool orientationCorrection, + bool preMultiplyOnLoad ) : url( url ), desiredSize( desiredSize ), useSize( desiredSize ), @@ -296,7 +461,10 @@ private: storageType( UPLOAD_TO_TEXTURE ), loadSynchronously( loadSynchronously ), useAtlas( useAtlas ), - cropToMask( cropToMask ) + cropToMask( cropToMask ), + orientationCorrection( true ), + preMultiplyOnLoad( preMultiplyOnLoad ), + preMultiplied( false ) { } @@ -318,65 +486,85 @@ 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 - LoadState loadState:3; ///< The load state showing the load progress of the Texture + LoadState loadState:4; ///< The load state showing the load progress of the Texture FittingMode::Type fittingMode:2; ///< The requested FittingMode Dali::SamplingMode::Type samplingMode:3; ///< The requested SamplingMode - StorageType storageType:1; ///< CPU storage / GPU upload; + StorageType storageType:2; ///< CPU storage / GPU upload; bool loadSynchronously:1; ///< True if synchronous loading was requested - UseAtlas useAtlas:1; ///< USE_ATLAS if an atlas was requested. This is updated to false if atlas is not used + UseAtlas useAtlas:2; ///< USE_ATLAS if an atlas was requested. + ///< This is updated to false if atlas is not used bool cropToMask:1; ///< true if the image should be cropped to the mask size. + 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 }; - // Structs: - /** - * Struct to hold information about a requested Async load. - * This is used to look up a TextureManager::TextureId from the returned AsyncLoad Id. + * Structure to hold info about a texture load queued during NotifyObservers */ - struct AsyncLoadingInfo + struct LoadQueueElement { - AsyncLoadingInfo( TextureId textureId ) - : textureId( textureId ), - loadId( 0 ) + LoadQueueElement( TextureId textureId, TextureUploadObserver* observer ) + : mTextureId( textureId ), + mObserver( observer ) { } - TextureId textureId; ///< The external Texture Id assigned to this load - unsigned short loadId; ///< The load Id used by the async loader to reference this load + TextureId mTextureId; ///< The texture id of the requested load. + TextureUploadObserver* mObserver; ///< Observer of texture load. }; /** - * @brief This struct is used within a container to manage atlas creation and destruction. + * Struct to hold information about a requested Async load. + * This is used to look up a TextureManager::TextureId from the returned AsyncLoad Id. */ - struct AtlasInfo + struct AsyncLoadingInfo { - AtlasInfo( Toolkit::ImageAtlas atlas, TextureSet textureSet ) - : atlas( atlas ), - textureSet( textureSet ) + AsyncLoadingInfo( TextureId textureId ) + : textureId( textureId ), + loadId( 0 ) { } - Toolkit::ImageAtlas atlas; ///< The ImageAtlas object - TextureSet textureSet; ///< The TextureSet is kept in the struct to allow fast lookup of TextureSet to Atlas + TextureId textureId; ///< The external Texture Id assigned to this load + uint32_t loadId; ///< The load Id used by the async loader to reference this load }; // Private typedefs: typedef std::deque AsyncLoadingInfoContainerType; ///< The container type used to manage Asynchronous loads in progress - typedef std::vector AtlasInfoContainerType; ///< The container type used to manage Atlas creation and destruction typedef std::vector TextureInfoContainerType; ///< The container type used to manage the life-cycle and caching of Textures /** + * @brief Initiate a load or queue load if NotifyObservers is invoking callbacks + * @param[in] textureInfo The TextureInfo struct associated with the Texture + * @param[in] observer The observer wishing to observe the texture upload + */ + void LoadOrQueueTexture( TextureInfo& textureInfo, TextureUploadObserver* observer ); + + /** + * @brief Queue a texture load to be subsequently handled by ProcessQueuedTextures. + * @param[in] textureInfo The TextureInfo struct associated with the Texture + * @param[in] observer The observer wishing to observe the texture upload + */ + void QueueLoadTexture( TextureInfo& textureInfo, TextureUploadObserver* observer ); + + /** * @brief Used internally to initiate a load. * @param[in] textureInfo The TextureInfo struct associated with the Texture - * @return True if the load was initiated + * @param[in] observer The observer wishing to observe the texture upload + */ + void LoadTexture( TextureInfo& textureInfo, TextureUploadObserver* observer ); + + /** + * @brief Initiate load of textures queued whilst NotifyObservers invoking callbacks. */ - bool LoadTexture( TextureInfo& textureInfo ); + void ProcessQueuedTextures(); /** * Add the observer to the observer list * @param[in] textureInfo The TextureInfo struct associated with the texture - * observer The observer wishing to observe the texture upload + * @param[in] observer The observer wishing to observe the texture upload */ void ObserveTexture( TextureInfo & textureInfo, TextureUploadObserver* observer ); @@ -419,13 +607,10 @@ private: /** * Apply the mask to the pixelBuffer. - * @param[in] pixelBuffer The pixelBuffer to apply the mask to + * @param[in] textureInfo The information of texture to apply the mask to * @param[in] maskTextureId The texture id of the mask. - * @param[in] contentScale The factor to scale the content - * @param[in] cropToMask Whether to crop the content to the mask size */ - void ApplyMask( Devel::PixelBuffer& pixelBuffer, TextureId maskTextureId, - float contentScale, bool cropToMask ); + void ApplyMask( TextureInfo& textureInfo, TextureId maskTextureId ); /** * Upload the texture specified in pixelBuffer to the appropriate location @@ -480,6 +665,7 @@ private: const FittingMode::Type fittingMode, const Dali::SamplingMode::Type samplingMode, const UseAtlas useAtlas, TextureId maskTextureId ); + /** * @brief Looks up a cached texture by its hash. * If found, the given parameters are used to check there is no hash-collision. @@ -499,7 +685,8 @@ private: const FittingMode::Type fittingMode, const Dali::SamplingMode::Type samplingMode, const bool useAtlas, - TextureId maskTextureId ); + TextureId maskTextureId, + MultiplyOnLoad preMultiplyOnLoad); private: @@ -519,17 +706,37 @@ private: * @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 - * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic + * @param[in] desiredSize The size the image is likely to appear at. + * This can be set to 0,0 for automatic * @param[in] fittingMode The FittingMode to use * @param[in] samplingMode The SamplingMode to use - * @param[in] orientationCorrection Whether to use image metadata to rotate or flip the image, e.g., from portrait to landscape + * @param[in] orientationCorrection Whether to use image metadata to rotate or flip the image, + * e.g., from portrait to landscape + * @param[in] preMultiplyOnLoad if the image's color should be multiplied by it's alpha. Set to OFF if there is no alpha or if the image need to be applied alpha mask. */ void Load(TextureId textureId, const VisualUrl& url, ImageDimensions desiredSize, FittingMode::Type fittingMode, SamplingMode::Type samplingMode, - bool orientationCorrection); + bool orientationCorrection, + DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad); + + /** + * @brief Apply mask + * @param [in] id of the texture + * @param [in] pixelBuffer of the to be masked image + * @param [in] maskPixelBuffer of the mask image + * @param [in] contentScale The factor to scale the content + * @param [in] cropToMask Whether to crop the content to the mask size + * @param [in] preMultiplyOnLoad if the image's color should be multiplied by it's alpha. Set to OFF if there is no alpha. + */ + void ApplyMask( TextureId textureId, + Devel::PixelBuffer pixelBuffer, + Devel::PixelBuffer maskPixelBuffer, + float contentScale, + bool cropToMask, + DevelAsyncImageLoader::PreMultiplyOnLoad preMultiplyOnLoad ); public: AsyncLoadingHelper(const AsyncLoadingHelper&) = delete; @@ -542,16 +749,16 @@ private: /** * @brief Main constructor that used by all other constructors */ - AsyncLoadingHelper(Toolkit::AsyncImageLoader loader, - TextureManager& textureManager, - AsyncLoadingInfoContainerType&& loadingInfoContainer); + AsyncLoadingHelper( Toolkit::AsyncImageLoader loader, + TextureManager& textureManager, + AsyncLoadingInfoContainerType&& loadingInfoContainer ); /** * @brief Callback to be called when texture loading is complete, it passes the pixel buffer on to texture manager. * @param[in] id Loader id * @param[in] pixelBuffer Image data */ - void AsyncLoadComplete(uint32_t id, Devel::PixelBuffer pixelBuffer); + void AsyncLoadComplete( uint32_t id, Devel::PixelBuffer pixelBuffer ); private: Toolkit::AsyncImageLoader mLoader; @@ -586,13 +793,15 @@ private: private: // Member Variables: - AtlasInfoContainerType mAtlasContainer; ///< Used to manage Atlas creation and destruction TextureInfoContainerType mTextureInfoContainer; ///< Used to manage the life-cycle and caching of Textures RoundRobinContainerView< AsyncLoadingHelper > mAsyncLocalLoaders; ///< The Asynchronous image loaders used to provide all local async loads RoundRobinContainerView< AsyncLoadingHelper > mAsyncRemoteLoaders; ///< The Asynchronous image loaders used to provide all remote async loads std::vector< ExternalTextureInfo > mExternalTextures; ///< Externally provided textures + Dali::Vector mLifecycleObservers; ///< Lifecycle observers of texture manager + Dali::Vector mLoadQueue; ///< Queue of textures to load after NotifyObservers + std::string mBrokenImageUrl; ///< Broken image url TextureId mCurrentTextureId; ///< The current value used for the unique Texture Id generation - + bool mQueueLoadFlag; ///< Flag that causes Load Textures to be queued. };