#define DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H
/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 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.
/**
* The TextureManager provides a common Image loading API for Visuals.
*
- * The TextureManager is responsible for providing sync, async, atlased and non-atlased
+ * The TextureManager is responsible for providing sync, async,
* CPU time alpha masking, animated image loads.
*
* Texture caching is provided and performed by TextureCacheManager.
static constexpr TextureId INVALID_TEXTURE_ID = TextureManagerType::INVALID_TEXTURE_ID;
static constexpr TextureCacheIndex INVALID_CACHE_INDEX = TextureManagerType::INVALID_CACHE_INDEX;
- using UseAtlas = TextureManagerType::UseAtlas;
using StorageType = TextureManagerType::StorageType;
- using LoadType = TextureManagerType::LoadType;
using LoadState = TextureManagerType::LoadState;
using ReloadPolicy = TextureManagerType::ReloadPolicy;
using MultiplyOnLoad = TextureManagerType::MultiplyOnLoad;
using MaskingDataPointer = std::unique_ptr<MaskingData>;
/**
- * 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.
+ *
+ * @param[in] loadYuvPlanes Whether we allow to load YuvPlanes or not. Default is false.
*/
- TextureManager();
+ TextureManager(bool loadYuvPlanes = false);
/**
* Destructor.
*/
TextureSet LoadAnimatedImageTexture(const VisualUrl& url,
Dali::AnimatedImageLoading animatedImageLoading,
- const uint32_t& frameIndex,
+ const uint32_t frameIndex,
TextureManager::TextureId& textureId,
MaskingDataPointer& maskInfo,
const Dali::ImageDimensions& desiredSize,
- const Dali::FittingMode::Type& fittingMode,
- const Dali::SamplingMode::Type& samplingMode,
- const bool& synchronousLoading,
+ const Dali::FittingMode::Type fittingMode,
+ const Dali::SamplingMode::Type samplingMode,
+ const bool synchronousLoading,
TextureUploadObserver* textureObserver,
TextureManager::MultiplyOnLoad& preMultiplyOnLoad);
Devel::PixelBuffer LoadPixelBuffer(
const VisualUrl& url,
const Dali::ImageDimensions& desiredSize,
- const Dali::FittingMode::Type& fittingMode,
- const Dali::SamplingMode::Type& samplingMode,
- const bool& synchronousLoading,
+ const Dali::FittingMode::Type fittingMode,
+ const Dali::SamplingMode::Type samplingMode,
+ const bool synchronousLoading,
TextureUploadObserver* textureObserver,
- const bool& orientationCorrection,
+ const bool orientationCorrection,
TextureManager::MultiplyOnLoad& preMultiplyOnLoad);
/**
* @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[in, out] textureId The textureId of the URL. It is also be used to check the previous textureId
+ * what requestor had. It will be used only ReloadPolicy::FORCED for now.
* @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
+ * @param[in,out] atlasingStatus Set to true 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
* @return The texture set containing the image, or empty if still loading.
*/
TextureSet LoadTexture(
- const VisualUrl& url,
- const Dali::ImageDimensions& desiredSize,
- const Dali::FittingMode::Type& fittingMode,
- const Dali::SamplingMode::Type& samplingMode,
- MaskingDataPointer& maskInfo,
- const bool& synchronousLoading,
- TextureManager::TextureId& textureId,
- Dali::Vector4& textureRect,
- Dali::ImageDimensions& textureRectSize,
- bool& atlasingStatus,
- bool& loadingStatus,
- TextureUploadObserver* textureObserver,
- AtlasUploadObserver* atlasObserver,
- ImageAtlasManagerPtr imageAtlasManager,
- const bool& orientationCorrection,
- const TextureManager::ReloadPolicy& reloadPolicy,
- TextureManager::MultiplyOnLoad& preMultiplyOnLoad);
-
- /**
- * 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);
+ const VisualUrl& url,
+ const Dali::ImageDimensions& desiredSize,
+ const Dali::FittingMode::Type fittingMode,
+ const Dali::SamplingMode::Type samplingMode,
+ MaskingDataPointer& maskInfo,
+ const bool synchronousLoading,
+ TextureManager::TextureId& textureId,
+ Dali::Vector4& textureRect,
+ Dali::ImageDimensions& textureRectSize,
+ bool& atlasingStatus,
+ bool& loadingStatus,
+ TextureUploadObserver* textureObserver,
+ AtlasUploadObserver* atlasObserver,
+ ImageAtlasManagerPtr imageAtlasManager,
+ const bool orientationCorrection,
+ const TextureManager::ReloadPolicy reloadPolicy,
+ TextureManager::MultiplyOnLoad& preMultiplyOnLoad);
/**
* @brief Returns the geometry associated with texture.
* @param[out] backElements number of back elements
* @return Returns valid geometry object
*/
- Geometry GetRenderGeometry(const TextureManager::TextureId& textureId, std::uint32_t& frontElements, std::uint32_t& backElements);
+ Geometry GetRenderGeometry(const TextureManager::TextureId textureId, uint32_t& frontElements, uint32_t& backElements);
/**
* @brief Returns the textureSet in texture manager.
* @param[in] textureId Id of the texture
* @return The textureSet in texture manager. These textures include YUV textures or images and masks.
*/
- TextureSet GetTextureSet(const TextureManager::TextureId& textureId);
+ TextureSet GetTextureSet(const TextureManager::TextureId textureId);
/**
* @brief Returns the textureSet in texture manager.
/**
* @copydoc TextureCacheManager::GetVisualUrl
*/
- inline VisualUrl GetVisualUrl(const TextureManager::TextureId& textureId)
+ inline VisualUrl GetVisualUrl(const TextureManager::TextureId textureId)
{
return mTextureCacheManager.GetVisualUrl(textureId);
}
/**
* @copydoc TextureCacheManager::GetTexture
*/
- inline Texture GetTexture(const TextureManager::TextureId& textureId)
+ inline Texture GetTexture(const TextureManager::TextureId textureId)
{
return mTextureCacheManager.GetTexture(textureId);
}
/**
* @copydoc TextureCacheManager::AddExternalTexture
*/
- inline std::string AddExternalTexture(const TextureSet& texture, bool preMultiplied = false)
+ inline std::string AddExternalTexture(const TextureSet& texture, const bool preMultiplied = false)
{
return mTextureCacheManager.AddExternalTexture(texture, preMultiplied);
}
* @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 "LoadCompleted" callback from the TextureManagerUploadObserver.
* @param[in] observer The client object should inherit from this and provide the "LoadCompleted" virtual.
* This is called when an image load completes (or fails).
* @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
* @return A TextureId to use as a handle to reference this Texture
*/
TextureId RequestLoad(
- const VisualUrl& url,
- const ImageDimensions& desiredSize,
- const Dali::FittingMode::Type& fittingMode,
- const Dali::SamplingMode::Type& samplingMode,
- const TextureManager::UseAtlas& useAtlasing,
- TextureUploadObserver* observer,
- const bool& orientationCorrection,
- const TextureManager::ReloadPolicy& reloadPolicy,
- TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
- const bool& synchronousLoading = false);
-
+ const VisualUrl& url,
+ const ImageDimensions& desiredSize,
+ const Dali::FittingMode::Type fittingMode,
+ const Dali::SamplingMode::Type samplingMode,
+ TextureUploadObserver* observer,
+ const bool orientationCorrection,
+ const TextureManager::ReloadPolicy reloadPolicy,
+ TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
+ const bool synchronousLoading = false);
+
+private: // Internal Load Request API
/**
* @brief Requests an image load of the given URL, when the texture has
* have loaded, it will perform a blend with the image mask, and upload
* @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] previousTextureId The texture id of an image which the requestor already has before
* @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 "LoadCompleted" 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 "LoadCompleted"
* @return A TextureId to use as a handle to reference this Texture
*/
TextureId RequestLoad(
- const VisualUrl& url,
- const TextureManager::TextureId& maskTextureId,
- const float& contentScale,
- const ImageDimensions& desiredSize,
- const Dali::FittingMode::Type& fittingMode,
- const Dali::SamplingMode::Type& samplingMode,
- const TextureManager::UseAtlas& useAtlasing,
- const bool& cropToMask,
- TextureUploadObserver* observer,
- const bool& orientationCorrection,
- const TextureManager::ReloadPolicy& reloadPolicy,
- TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
- const bool& synchronousLoading = false);
+ const VisualUrl& url,
+ const TextureManager::TextureId maskTextureId,
+ const TextureManager::TextureId previousTextureId,
+ const float contentScale,
+ const ImageDimensions& desiredSize,
+ const Dali::FittingMode::Type fittingMode,
+ const Dali::SamplingMode::Type samplingMode,
+ const bool cropToMask,
+ TextureUploadObserver* observer,
+ const bool orientationCorrection,
+ const TextureManager::ReloadPolicy reloadPolicy,
+ TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
+ const bool synchronousLoading = false);
/**
* @brief Requests a masking image to be loaded. This mask is not uploaded to GL,
* instead, it is stored in CPU memory, and can be used for CPU blending.
* @param[in] maskUrl The URL of the mask image to load
- * @param[in] storageType, Whether the pixel data is stored in the cache or uploaded to the GPU
+ * @param[in] storageType Whether the pixel data is stored in the cache or uploaded to the GPU
* @param[in] synchronousLoading True if the frame should be loaded synchronously. If you skip this parameter,
* default is false.
* @return A TextureId to use as a handle to reference this mask Texture
*/
TextureId RequestMaskLoad(
- const VisualUrl& maskUrl,
- StorageType storageType,
- const bool& synchronousLoading = false);
+ const VisualUrl& maskUrl,
+ const TextureManager::StorageType storageType,
+ const bool synchronousLoading = false);
-private:
/**
* @brief Requests an image load of the given URL, when the texture has
* have loaded, if there is a valid maskTextureId, it will perform a
* @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] previousTextureId The texture id of an image which the requestor already has before. It will be used
+ * when reloadPolicy is FORCED.
* @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
- * "LoadCompleted" 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] 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 "LoadCompleted"
* virtual.
* This is called when an image load completes (or fails).
* @return A TextureId to use as a handle to reference this Texture
*/
TextureId RequestLoadInternal(
- const VisualUrl& url,
- const TextureManager::TextureId& maskTextureId,
- const float& contentScale,
- const Dali::ImageDimensions& desiredSize,
- const Dali::FittingMode::Type& fittingMode,
- const Dali::SamplingMode::Type& samplingMode,
- const TextureManager::UseAtlas& useAtlas,
- const bool& cropToMask,
- const TextureManager::StorageType& storageType,
- TextureUploadObserver* observer,
- const bool& orientationCorrection,
- const TextureManager::ReloadPolicy& reloadPolicy,
- TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
- Dali::AnimatedImageLoading animatedImageLoading,
- const std::uint32_t& frameIndex,
- const bool& synchronousLoading);
+ const VisualUrl& url,
+ const TextureManager::TextureId maskTextureId,
+ const TextureManager::TextureId previousTextureId,
+ const float contentScale,
+ const Dali::ImageDimensions& desiredSize,
+ const Dali::FittingMode::Type fittingMode,
+ const Dali::SamplingMode::Type samplingMode,
+ const bool cropToMask,
+ const TextureManager::StorageType storageType,
+ TextureUploadObserver* observer,
+ const bool orientationCorrection,
+ const TextureManager::ReloadPolicy reloadPolicy,
+ TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
+ Dali::AnimatedImageLoading animatedImageLoading,
+ const uint32_t frameIndex,
+ const bool synchronousLoading);
/**
* @brief Load a new image synchronously.
void LoadImageSynchronously(
const VisualUrl& url,
const Dali::ImageDimensions& desiredSize,
- const Dali::FittingMode::Type& fittingMode,
- const Dali::SamplingMode::Type& samplingMode,
- const bool& orientationCorrection,
- const bool& loadYuvPlanes,
+ const Dali::FittingMode::Type fittingMode,
+ const Dali::SamplingMode::Type samplingMode,
+ const bool orientationCorrection,
+ const bool loadYuvPlanes,
std::vector<Devel::PixelBuffer>& pixelBuffers);
public: // Remove Request API
* @param[in] textureId The ID of the Texture to remove.
* @param[in] textureObserver The texture observer.
*/
- void RequestRemove(const TextureManager::TextureId& textureId, TextureUploadObserver* textureObserver);
+ void RequestRemove(const TextureManager::TextureId textureId, TextureUploadObserver* textureObserver);
private:
/**
*
* @param[in] textureId The ID of the Texture to remove.
*/
- void Remove(const TextureManager::TextureId& textureId);
+ void Remove(const TextureManager::TextureId textureId);
/**
* @brief Initiate remove of texture queued.
*/
struct QueueElement
{
- QueueElement(TextureManager::TextureId textureId, TextureUploadObserver* observer)
+ QueueElement(const TextureManager::TextureId textureId, TextureUploadObserver* observer)
: mTextureId(textureId),
mObserver(observer)
{
void ObserveTexture(TextureManager::TextureInfo& textureInfo, TextureUploadObserver* observer);
/**
- * @brief Performs Post-Load steps including atlasing.
+ * @brief Performs Post-Load steps.
* @param[in] textureInfo The struct associated with this Texture
* @param[in] pixelBuffers The image pixelBuffer
* @return True if successful
* @param[in] textureInfo The information of texture to apply the mask to
* @param[in] maskTextureId The texture id of the mask.
*/
- void ApplyMask(TextureManager::TextureInfo& textureInfo, const TextureManager::TextureId& maskTextureId);
+ void ApplyMask(TextureManager::TextureInfo& textureInfo, const TextureManager::TextureId maskTextureId);
/**
* Upload the texture specified in pixelBuffer to the appropriate location
* @param[in] textureInfo The struct associated with this Texture
* @param[in] success If the pixel data was retrieved successfully and uploaded to GPU
*/
- void NotifyObservers(TextureManager::TextureInfo& textureInfo, const bool& success);
+ void NotifyObservers(TextureManager::TextureInfo& textureInfo, const bool success);
/**
* Call LoadComplete to the observer.
* @param[in] textureInfo The struct associated with this Texture
* @param[in] success If the pixel data was retrieved successfully and uploaded to GPU
*/
- void EmitLoadComplete(TextureUploadObserver* observer, TextureManager::TextureInfo& textureInfo, const bool& success);
+ void EmitLoadComplete(TextureUploadObserver* observer, TextureManager::TextureInfo& textureInfo, const bool success);
/**
* @brief Remove observer in textureInfo
* @param[in] textureId The ID of the texture load complete.
* @param[in] pixelBuffers The loaded image data
*/
- void AsyncLoadComplete(const TextureManager::TextureId& textureId, std::vector<Devel::PixelBuffer>& pixelBuffers);
+ void AsyncLoadComplete(const TextureManager::TextureId textureId, std::vector<Devel::PixelBuffer>& pixelBuffers);
protected: // Implementation of Processor
/**
*/
void Process(bool postProcessor) override;
+ /**
+ * @copydoc Dali::Integration::Processor::GetProcessorName()
+ */
+ std::string_view GetProcessorName() const override
+ {
+ return "TextureManager";
+ }
+
private:
/**
* Deleted copy constructor.
private: // Member Variables:
TextureCacheManager mTextureCacheManager; ///< Manager the life-cycle and caching of Textures
- std::unique_ptr<TextureAsyncLoadingHelper> mAsyncLoader; ///< The Asynchronous image loader used to provide all local async loads
- Dali::Vector<LifecycleObserver*> mLifecycleObservers; ///< Lifecycle observers of texture manager
+ std::unique_ptr<TextureAsyncLoadingHelper> mAsyncLoader; ///< The Asynchronous image loader used to provide all local async loads
Dali::Vector<QueueElement> mLoadQueue; ///< Queue of textures to load after NotifyObservers
TextureManager::TextureId mLoadingQueueTextureId; ///< TextureId when it is loading. it causes Load Textures to be queued.
Dali::Vector<TextureManager::TextureId> mRemoveQueue; ///< Queue of textures to remove at PostProcess. It will be cleared after PostProcess.
- bool mLoadYuvPlanes; ///< A global flag to specify if the image should be loaded as yuv planes
- bool mRemoveProcessorRegistered; ///< Flag if remove processor registered or not.
+ const bool mLoadYuvPlanes; ///< A global flag to specify if the image should be loaded as yuv planes
+ bool mRemoveProcessorRegistered; ///< Flag if remove processor registered or not.
};
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff