#include <dali/public-api/object/ref-object.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 <deque>
// INTERNAL INCLUDES
};
/**
- * Whether the texture should be stored in CPU memory, or uploaded to a GPU texture
+ * Whether the pixel data should be kept in TextureManager, or uploaded for rendering
*/
enum StorageType
{
- CPU,
- GPU_UPLOAD
+ KEEP_PIXEL_BUFFER,
+ UPLOAD_TO_TEXTURE
};
/**
/**
* @brief Requests an image load of the given URL, when the texture has
- * have loaded, it will perform a CPU blend with the image mask, and upload
- * the blend texture.
+ * have loaded, it will perform a blend with the image mask, and upload
+ * the blended texture.
*
* 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] 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 );
/**
void Remove( const TextureManager::TextureId textureId );
/**
+ * Get the visualUrl associated with the texture id
+ */
+ const VisualUrl& GetVisualUrl( TextureId textureId );
+
+ /**
* @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
*
* @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
*/
- TextureId RequestInternalLoad(
+ 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 );
TextureId maskTextureId,
const VisualUrl& url,
ImageDimensions desiredSize,
+ float scaleFactor,
FittingMode::Type fittingMode,
Dali::SamplingMode::Type samplingMode,
bool loadSynchronously,
+ bool cropToMask,
UseAtlas useAtlas,
TextureManager::TextureHash hash )
: url( url ),
textureId( textureId ),
maskTextureId( maskTextureId ),
hash( hash ),
+ scaleFactor( scaleFactor ),
referenceCount( 1u ),
loadState( NOT_STARTED ),
fittingMode( fittingMode ),
samplingMode( samplingMode ),
- storageType( GPU_UPLOAD ),
+ storageType( UPLOAD_TO_TEXTURE ),
loadSynchronously( loadSynchronously ),
- useAtlas( useAtlas )
+ useAtlas( useAtlas ),
+ cropToMask( cropToMask )
{
}
ObserverListType observerList; ///< Container used to store all observer clients of this Texture
Toolkit::ImageAtlas atlas; ///< The atlas this Texture lays within (if any)
- PixelData pixelData; ///< The PixelData holding the image data (this is used if atlasing is deferred or CPU storage is required)
+ Devel::PixelBuffer pixelBuffer;///< The PixelBuffer holding the image data (May be empty after upload)
TextureSet textureSet; ///< The TextureSet holding the Texture
VisualUrl url; ///< The URL of the image
ImageDimensions desiredSize; ///< The size requested
TextureId textureId; ///< The TextureId associated with this Texture
TextureId maskTextureId; ///< The mask TextureId to be applied on load
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
FittingMode::Type fittingMode:2; ///< The requested FittingMode
StorageType storageType:1; ///< 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
+ bool cropToMask:1; ///< true if the image should be cropped to the mask size.
};
// Structs:
/**
* @brief This signal handler is called when the async local loader finishes loading.
* @param[in] id This is the async image loaders Id
- * @param[in] pixelData The loaded image data
+ * @param[in] pixelBuffer The loaded image data
*/
- void AsyncLocalLoadComplete( uint32_t id, PixelData pixelData );
+ void AsyncLocalLoadComplete( uint32_t id, Devel::PixelBuffer pixelBuffer );
/**
* @brief This signal handler is called when the async local loader finishes loading.
* @param[in] id This is the async image loaders Id
- * @param[in] pixelData The loaded image data
+ * @param[in] pixelBuffer The loaded image data
*/
- void AsyncRemoteLoadComplete( uint32_t id, PixelData pixelData );
+ void AsyncRemoteLoadComplete( uint32_t id, Devel::PixelBuffer pixelBuffer );
/**
* Common method to handle loading completion
* @param[in] container The Async loading container
* @param[in] id This is the async image loaders Id
- * @param[in] pixelData The loaded image data
+ * @param[in] pixelBuffer The loaded image data
*/
- void AsyncLoadComplete( AsyncLoadingInfoContainerType& container, uint32_t id, PixelData pixelData );
+ void AsyncLoadComplete( AsyncLoadingInfoContainerType& container, uint32_t id, Devel::PixelBuffer pixelBuffer );
/**
* @brief Performs Post-Load steps including atlasing.
* @param[in] textureInfo The struct associated with this Texture
- * @param[in] pixelData The image pixelData
+ * @param[in] pixelBuffer The image pixelBuffer
* @return True if successful
*/
- void PostLoad( TextureManager::TextureInfo& textureInfo, PixelData pixelData );
+ void PostLoad( TextureManager::TextureInfo& textureInfo, Devel::PixelBuffer& pixelBuffer );
/**
* Check if there is a texture waiting to be masked. If there
void CheckForWaitingTexture( TextureInfo& maskTextureInfo );
/**
- * Apply the mask texture to the image texture.
- * @param[in] pixelData The image pixelData to apply the mask to
+ * Apply the mask to the pixelBuffer.
+ * @param[in] pixelBuffer The pixelBuffer 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( PixelData pixelData, TextureId maskTextureId );
+ void ApplyMask( Devel::PixelBuffer& pixelBuffer, TextureId maskTextureId,
+ float contentScale, bool cropToMask );
/**
- * Upload the texture specified in pixelData to the appropriate location
- * @param[in] pixelData The image data to upload
+ * Upload the texture specified in pixelBuffer to the appropriate location
+ * @param[in] pixelBuffer The image data to upload
* @param[in] textureInfo The texture info containing the location to
* store the data to.
*/
- void UploadTexture( PixelData pixelData, TextureInfo& textureInfo );
+ void UploadTexture( Devel::PixelBuffer& pixelBuffer, TextureInfo& textureInfo );
/**
* Mark the texture as complete, and inform observers
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.