TextureManager::TextureId mAlphaMaskId;
float mContentScaleFactor;
bool mCropToMask;
+ bool mPreappliedMasking;
+ bool mMaskImageLoadingFailed;
};
using MaskingDataPointer = std::unique_ptr<MaskingData>;
* 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] url The URL of the image to load
* @param[in] animatedImageLoading The AnimatedImageLoading that contain the animated image information
* @param[in] frameIndex The frame index to load.
* @param[out] textureId The textureId of the frame
+ * @param[in, out] maskInfo Mask info structure
* @param[in] samplingMode The SamplingMode to use
* @param[in] wrapModeU Horizontal Wrap mode
* @param[in] wrapModeV Vertical Wrap mode
* @param[in] synchronousLoading true if the frame should be loaded synchronously
- * @param[in] useCache true if this frame loading uses cache.
* @param[in] textureObserver The client object should inherit from this and provide the "LoadCompleted" virtual.
* This is called when an image load completes (or fails).
+ * @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 frame of animated image, or empty if still loading.
*/
- TextureSet LoadAnimatedImageTexture(Dali::AnimatedImageLoading animatedImageLoading,
+ TextureSet LoadAnimatedImageTexture(const VisualUrl& url,
+ Dali::AnimatedImageLoading animatedImageLoading,
const uint32_t& frameIndex,
TextureManager::TextureId& textureId,
+ MaskingDataPointer& maskInfo,
const Dali::SamplingMode::Type& samplingMode,
const Dali::WrapMode::Type& wrapModeU,
const Dali::WrapMode::Type& wrapModeV,
const bool& synchronousLoading,
- const bool& useCache,
- TextureUploadObserver* textureObserver);
+ TextureUploadObserver* textureObserver,
+ TextureManager::MultiplyOnLoad& preMultiplyOnLoad);
/**
* @brief Requests an image load of the given URL to get PixelBuffer.
}
/**
- * @copydoc TextureCacheManager::RemoveExternalEncodedImageBuffer
+ * @copydoc TextureCacheManager::RemoveEncodedImageBuffer
*/
- inline EncodedImageBuffer RemoveExternalEncodedImageBuffer(const std::string& url)
+ inline EncodedImageBuffer RemoveEncodedImageBuffer(const std::string& url)
{
- return mTextureCacheManager.RemoveExternalEncodedImageBuffer(url);
+ return mTextureCacheManager.RemoveEncodedImageBuffer(url);
}
/**
}
/**
- * @copydoc TextureCacheManager::AddExternalEncodedImageBuffer
+ * @copydoc TextureCacheManager::AddEncodedImageBuffer
*/
- inline std::string AddExternalEncodedImageBuffer(const EncodedImageBuffer& encodedImageBuffer)
+ inline std::string AddEncodedImageBuffer(const EncodedImageBuffer& encodedImageBuffer)
{
- return mTextureCacheManager.AddExternalEncodedImageBuffer(encodedImageBuffer);
+ return mTextureCacheManager.AddEncodedImageBuffer(encodedImageBuffer);
}
public: // Load Request API
* @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] 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);
private:
* @param[in] frameIndex The frame index of a frame to be loaded frame
* @param[in] synchronousLoading True if the frame should be loaded synchronously. If you skip this parameter,
* default is false.
- * @param[in] useCache True if the texture will be cached.
* @return A TextureId to use as a handle to reference this Texture
*/
TextureId RequestLoadInternal(
TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
Dali::AnimatedImageLoading animatedImageLoading,
const std::uint32_t& frameIndex,
- const bool& synchronousLoading,
- const bool& useCache);
+ const bool& synchronousLoading);
/**
* @brief Load a new image synchronously.
/**
* @brief Initiate load of textures queued whilst NotifyObservers invoking callbacks.
*/
- void ProcessQueuedTextures();
+ void ProcessLoadQueue();
+
+ /**
+ * @brief Initiate remove of texture queued whilst NotifyObservers invoking callbacks.
+ */
+ void ProcessRemoveQueue();
/**
* Add the observer to the observer list
RoundRobinContainerView<TextureAsyncLoadingHelper> mAsyncLocalLoaders; ///< The Asynchronous image loaders used to provide all local async loads
RoundRobinContainerView<TextureAsyncLoadingHelper> mAsyncRemoteLoaders; ///< The Asynchronous image loaders used to provide all remote async loads
- Dali::Vector<LifecycleObserver*> mLifecycleObservers; ///< Lifecycle observers of texture manager
- Dali::Vector<LoadQueueElement> mLoadQueue; ///< Queue of textures to load after NotifyObservers
- bool mQueueLoadFlag; ///< Flag that causes Load Textures to be queued.
+ Dali::Vector<LifecycleObserver*> mLifecycleObservers; ///< Lifecycle observers of texture manager
+ Dali::Vector<LoadQueueElement> mLoadQueue; ///< Queue of textures to load after NotifyObservers
+ Dali::Vector<TextureManager::TextureId> mRemoveQueue; ///< Queue of textures to remove after NotifyObservers
+ bool mQueueLoadFlag; ///< Flag that causes Load Textures to be queued.
};
} // namespace Internal