1 #ifndef DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H
2 #define DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H
5 * Copyright (c) 2022 Samsung Electronics Co., Ltd.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
21 #include <dali/devel-api/adaptor-framework/animated-image-loading.h>
22 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
23 #include <dali/public-api/adaptor-framework/encoded-image-buffer.h>
24 #include <dali/public-api/common/dali-vector.h>
25 #include <dali/public-api/rendering/geometry.h>
28 #include <dali-toolkit/devel-api/image-loader/image-atlas.h>
29 #include <dali-toolkit/internal/helpers/round-robin-container-view.h>
30 #include <dali-toolkit/internal/texture-manager/texture-cache-manager.h>
31 #include <dali-toolkit/internal/texture-manager/texture-manager-type.h>
32 #include <dali-toolkit/internal/texture-manager/texture-upload-observer.h>
33 #include <dali-toolkit/internal/visuals/visual-url.h>
41 class ImageAtlasManager;
42 typedef IntrusivePtr<ImageAtlasManager> ImageAtlasManagerPtr;
43 class TextureAsyncLoadingHelper;
46 * The TextureManager provides a common Image loading API for Visuals.
48 * The TextureManager is responsible for providing sync, async, atlased and non-atlased
49 * CPU time alpha masking, animated image loads.
51 * Texture caching is provided and performed by TextureCacheManager.
52 * TextureUploadObserver.LoadComplete called when async load completed.
54 class TextureManager : public ConnectionTracker
57 // Copy enum and types and const values that TextureManager will use.
58 using TextureId = TextureManagerType::TextureId;
59 using TextureCacheIndex = TextureManagerType::TextureCacheIndex;
60 using TextureHash = TextureManagerType::TextureHash;
62 static constexpr TextureId INVALID_TEXTURE_ID = TextureManagerType::INVALID_TEXTURE_ID;
63 static constexpr TextureCacheIndex INVALID_CACHE_INDEX = TextureManagerType::INVALID_CACHE_INDEX;
65 using UseAtlas = TextureManagerType::UseAtlas;
66 using StorageType = TextureManagerType::StorageType;
67 using LoadType = TextureManagerType::LoadType;
68 using LoadState = TextureManagerType::LoadState;
69 using ReloadPolicy = TextureManagerType::ReloadPolicy;
70 using MultiplyOnLoad = TextureManagerType::MultiplyOnLoad;
71 using TextureInfo = TextureManagerType::TextureInfo;
77 ~MaskingData() = default;
79 VisualUrl mAlphaMaskUrl;
80 TextureManager::TextureId mAlphaMaskId;
81 float mContentScaleFactor;
84 using MaskingDataPointer = std::unique_ptr<MaskingData>;
87 * Class to provide lifecycle event on destruction of texture manager.
89 struct LifecycleObserver
92 * Called shortly before the texture manager is destroyed.
94 virtual void TextureManagerDestroyed() = 0;
105 ~TextureManager() override;
107 // TextureManager Main API:
110 * @brief Requests an frame of animated image load.
112 * The parameters are used to specify how the animated image is loaded.
113 * The observer has the LoadComplete method called when the load is ready.
115 * @param[in] animatedImageLoading The AnimatedImageLoading that contain the animated image information
116 * @param[in] frameIndex The frame index to load.
117 * @param[out] textureId The textureId of the frame
118 * @param[in, out] maskInfo Mask info structure
119 * @param[in] samplingMode The SamplingMode to use
120 * @param[in] wrapModeU Horizontal Wrap mode
121 * @param[in] wrapModeV Vertical Wrap mode
122 * @param[in] synchronousLoading true if the frame should be loaded synchronously
123 * @param[in] useCache true if this frame loading uses cache.
124 * @param[in] textureObserver The client object should inherit from this and provide the "LoadCompleted" virtual.
125 * This is called when an image load completes (or fails).
127 * @return The texture set containing the frame of animated image, or empty if still loading.
129 TextureSet LoadAnimatedImageTexture(Dali::AnimatedImageLoading animatedImageLoading,
130 const uint32_t& frameIndex,
131 TextureManager::TextureId& textureId,
132 MaskingDataPointer& maskInfo,
133 const Dali::SamplingMode::Type& samplingMode,
134 const Dali::WrapMode::Type& wrapModeU,
135 const Dali::WrapMode::Type& wrapModeV,
136 const bool& synchronousLoading,
137 const bool& useCache,
138 TextureUploadObserver* textureObserver);
141 * @brief Requests an image load of the given URL to get PixelBuffer.
143 * The parameters are used to specify how the image is loaded.
144 * The observer has the LoadComplete method called when the load is ready.
146 * @param[in] url The URL of the image to load
147 * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic
148 * @param[in] fittingMode The FittingMode to use
149 * @param[in] samplingMode The SamplingMode to use
150 * @param[in] synchronousLoading true if the URL should be loaded synchronously
151 * @param[in] textureObserver The client object should inherit from this and provide the "LoadCompleted" virtual.
152 * This is called when an image load completes (or fails).
153 * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
154 * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
155 * image has no alpha channel
157 * @return The pixel buffer containing the image, or empty if still loading.
159 Devel::PixelBuffer LoadPixelBuffer(
160 const VisualUrl& url,
161 const Dali::ImageDimensions& desiredSize,
162 const Dali::FittingMode::Type& fittingMode,
163 const Dali::SamplingMode::Type& samplingMode,
164 const bool& synchronousLoading,
165 TextureUploadObserver* textureObserver,
166 const bool& orientationCorrection,
167 TextureManager::MultiplyOnLoad& preMultiplyOnLoad);
170 * @brief Requests an image load of the given URL.
172 * The parameters are used to specify how the image is loaded.
173 * The observer has the LoadComplete method called when the load is ready.
175 * When the client has finished with the Texture, Remove() should be called.
177 * @param[in] url The URL of the image to load
178 * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic
179 * @param[in] fittingMode The FittingMode to use
180 * @param[in] samplingMode The SamplingMode to use
181 * @param[in, out] maskInfo Mask info structure
182 * @param[in] synchronousLoading true if the URL should be loaded synchronously
183 * @param[out] textureId, The textureId of the URL
184 * @param[out] textureRect The rectangle within the texture atlas that this URL occupies,
185 * this is the rectangle in normalized coordinates.
186 * @param[out] textureRectSize The rectangle within the texture atlas that this URL occupies,
187 * this is the same rectangle in pixels.
188 * @param[in,out] atlasingStatus Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still
189 * be loaded, and marked successful, but this will be set to false.
190 * If atlasing succeeds, this will be set to true.
191 * @param[out] loadingStatus The loading status of the texture
192 * @param[in] wrapModeU Horizontal Wrap mode
193 * @param[in] wrapModeV Vertical Wrap mode
194 * @param[in] textureObserver The client object should inherit from this and provide the "LoadCompleted" virtual.
195 * This is called when an image load completes (or fails).
196 * @param[in] atlasObserver This is used if the texture is atlased, and will be called instead of
197 * textureObserver.LoadCompleted
198 * @param[in] imageAtlasManager The atlas manager to use for atlasing textures
199 * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
200 * @param[in] reloadPolicy Forces a reload of the texture even if already cached
201 * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
202 * image has no alpha channel
204 * @return The texture set containing the image, or empty if still loading.
206 TextureSet LoadTexture(
207 const VisualUrl& url,
208 const Dali::ImageDimensions& desiredSize,
209 const Dali::FittingMode::Type& fittingMode,
210 const Dali::SamplingMode::Type& samplingMode,
211 MaskingDataPointer& maskInfo,
212 const bool& synchronousLoading,
213 TextureManager::TextureId& textureId,
214 Dali::Vector4& textureRect,
215 Dali::ImageDimensions& textureRectSize,
216 bool& atlasingStatus,
218 const Dali::WrapMode::Type& wrapModeU,
219 const Dali::WrapMode::Type& wrapModeV,
220 TextureUploadObserver* textureObserver,
221 AtlasUploadObserver* atlasObserver,
222 ImageAtlasManagerPtr imageAtlasManager,
223 const bool& orientationCorrection,
224 const TextureManager::ReloadPolicy& reloadPolicy,
225 TextureManager::MultiplyOnLoad& preMultiplyOnLoad);
228 * @brief Remove a Texture from the TextureManager.
230 * Textures are cached and therefore only the removal of the last
231 * occurrence of a Texture will cause its removal internally.
233 * @param[in] textureId The ID of the Texture to remove.
234 * @param[in] textureObserver The texture observer.
236 void Remove(const TextureManager::TextureId& textureId, TextureUploadObserver* textureObserver);
239 * Add an observer to the object.
240 * @param[in] observer The observer to add.
242 void AddObserver(TextureManager::LifecycleObserver& observer);
245 * Remove an observer from the object
246 * @pre The observer has already been added.
247 * @param[in] observer The observer to remove.
249 void RemoveObserver(TextureManager::LifecycleObserver& observer);
252 * @brief Returns the geometry associated with texture.
253 * @param[in] textureId Id of the texture
254 * @param[out] frontElements number of front elements
255 * @param[out] backElements number of back elements
256 * @return Returns valid geometry object
258 Geometry GetRenderGeometry(const TextureManager::TextureId& textureId, std::uint32_t& frontElements, std::uint32_t& backElements);
261 // API list that need to access TextureCacheManager.
264 * @copydoc TextureCacheManager::GetVisualUrl
266 inline VisualUrl GetVisualUrl(const TextureManager::TextureId& textureId)
268 return mTextureCacheManager.GetVisualUrl(textureId);
272 * @copydoc TextureCacheManager::GetTextureSet
274 inline TextureSet GetTextureSet(const TextureManager::TextureId& textureId)
276 return mTextureCacheManager.GetTextureSet(textureId);
280 * @copydoc TextureCacheManager::RemoveExternalTexture
282 inline TextureSet RemoveExternalTexture(const std::string& url)
284 return mTextureCacheManager.RemoveExternalTexture(url);
288 * @copydoc TextureCacheManager::RemoveEncodedImageBuffer
290 inline EncodedImageBuffer RemoveEncodedImageBuffer(const std::string& url)
292 return mTextureCacheManager.RemoveEncodedImageBuffer(url);
296 * @copydoc TextureCacheManager::UseExternalResource
298 inline void UseExternalResource(const VisualUrl& url)
300 mTextureCacheManager.UseExternalResource(url);
304 * @copydoc TextureCacheManager::GetEncodedImageBuffer
306 inline EncodedImageBuffer GetEncodedImageBuffer(const std::string& url)
308 return mTextureCacheManager.GetEncodedImageBuffer(url);
312 * @copydoc TextureCacheManager::AddExternalTexture
314 inline std::string AddExternalTexture(const TextureSet& texture)
316 return mTextureCacheManager.AddExternalTexture(texture);
320 * @copydoc TextureCacheManager::AddEncodedImageBuffer
322 inline std::string AddEncodedImageBuffer(const EncodedImageBuffer& encodedImageBuffer)
324 return mTextureCacheManager.AddEncodedImageBuffer(encodedImageBuffer);
327 public: // Load Request API
329 * @brief Requests an image load of the given URL.
331 * The parameters are used to specify how the image is loaded.
332 * The observer has the LoadComplete method called when the load is ready.
334 * When the client has finished with the Texture, Remove() should be called.
336 * @param[in] url The URL of the image to load
337 * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic
338 * @param[in] fittingMode The FittingMode to use
339 * @param[in] samplingMode The SamplingMode to use
340 * @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be loaded, and marked successful,
341 * but "useAtlasing" will be set to false in the "LoadCompleted" callback from the TextureManagerUploadObserver.
342 * @param[in] observer The client object should inherit from this and provide the "LoadCompleted" virtual.
343 * This is called when an image load completes (or fails).
344 * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
345 * @param[in] reloadPolicy Forces a reload of the texture even if already cached
346 * @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
347 * @param[in] synchronousLoading True if the frame should be loaded synchronously. If you skip this parameter,
349 * @return A TextureId to use as a handle to reference this Texture
351 TextureId RequestLoad(
352 const VisualUrl& url,
353 const ImageDimensions& desiredSize,
354 const Dali::FittingMode::Type& fittingMode,
355 const Dali::SamplingMode::Type& samplingMode,
356 const TextureManager::UseAtlas& useAtlasing,
357 TextureUploadObserver* observer,
358 const bool& orientationCorrection,
359 const TextureManager::ReloadPolicy& reloadPolicy,
360 TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
361 const bool& synchronousLoading = false);
364 * @brief Requests an image load of the given URL, when the texture has
365 * have loaded, it will perform a blend with the image mask, and upload
366 * the blended texture.
368 * The parameters are used to specify how the image is loaded.
369 * The observer has the LoadComplete method called when the load is ready.
371 * When the client has finished with the Texture, Remove() should be called.
373 * @param[in] url The URL of the image to load
374 * @param[in] maskTextureId The texture id of an image to mask this with
375 * (can be INVALID if no masking required)
376 * @param[in] contentScale The scale factor to apply to the image before masking
377 * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic
378 * @param[in] fittingMode The FittingMode to use
379 * @param[in] samplingMode The SamplingMode to use
380 * @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still
381 * be loaded, and marked successful,
382 * but "useAtlasing" will be set to false in the "LoadCompleted" callback from
383 * the TextureManagerUploadObserver.
384 * @param[in] cropToMask Only used with masking, this will crop the scaled image to the mask size.
385 * If false, then the mask will be scaled to fit the image before being applied.
386 * @param[in] observer The client object should inherit from this and provide the "LoadCompleted"
388 * This is called when an image load completes (or fails).
389 * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
390 * @param[in] reloadPolicy Forces a reload of the texture even if already cached
391 * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if the
392 * image has no alpha channel
393 * @param[in] synchronousLoading True if the frame should be loaded synchronously. If you skip this parameter,
395 * @return A TextureId to use as a handle to reference this Texture
397 TextureId RequestLoad(
398 const VisualUrl& url,
399 const TextureManager::TextureId& maskTextureId,
400 const float& contentScale,
401 const ImageDimensions& desiredSize,
402 const Dali::FittingMode::Type& fittingMode,
403 const Dali::SamplingMode::Type& samplingMode,
404 const TextureManager::UseAtlas& useAtlasing,
405 const bool& cropToMask,
406 TextureUploadObserver* observer,
407 const bool& orientationCorrection,
408 const TextureManager::ReloadPolicy& reloadPolicy,
409 TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
410 const bool& synchronousLoading = false);
413 * @brief Requests a masking image to be loaded. This mask is not uploaded to GL,
414 * instead, it is stored in CPU memory, and can be used for CPU blending.
415 * @param[in] maskUrl The URL of the mask image to load
416 * @param[in] synchronousLoading True if the frame should be loaded synchronously. If you skip this parameter,
418 * @return A TextureId to use as a handle to reference this mask Texture
420 TextureId RequestMaskLoad(
421 const VisualUrl& maskUrl,
422 const bool& synchronousLoading = false);
426 * @brief Requests an image load of the given URL, when the texture has
427 * have loaded, if there is a valid maskTextureId, it will perform a
428 * CPU blend with the mask, and upload the blend texture.
430 * The parameters are used to specify how the image is loaded.
431 * The observer has the LoadComplete method called when the load is ready.
433 * When the client has finished with the Texture, Remove() should be called.
435 * @param[in] url The URL of the image to load
436 * @param[in] maskTextureId The texture id of an image to use as a mask. If no mask is required, then set
437 * to INVALID_TEXTURE_ID
438 * @param[in] contentScale The scaling factor to apply to the content when masking
439 * @param[in] desiredSize The size the image is likely to appear at. This can be set to 0,0 for automatic
440 * @param[in] fittingMode The FittingMode to use
441 * @param[in] samplingMode The SamplingMode to use
442 * @param[in] useAtlasing Set to USE_ATLAS to attempt atlasing. If atlasing fails, the image will still be
443 * loaded, and marked successful, but "useAtlasing" will be set to false in the
444 * "LoadCompleted" callback from the TextureManagerUploadObserver.
445 * @param[in] cropToMask Whether to crop the target after masking, or scale the mask to the image before
447 * @param[in] storageType, Whether the pixel data is stored in the cache or uploaded to the GPU
448 * @param[in] observer The client object should inherit from this and provide the "LoadCompleted"
450 * This is called when an image load completes (or fails).
451 * @param[in] orientationCorrection Whether to rotate image to match embedded orientation data
452 * @param[in] reloadPolicy Forces a reload of the texture even if already cached
453 * @param[in,out] preMultiplyOnLoad True if the image color should be multiplied by it's alpha. Set to false if
455 * @param[in] animatedImageLoading The AnimatedImageLoading to load animated image
456 * @param[in] frameIndex The frame index of a frame to be loaded frame
457 * @param[in] synchronousLoading True if the frame should be loaded synchronously. If you skip this parameter,
459 * @param[in] useCache True if the texture will be cached.
460 * @return A TextureId to use as a handle to reference this Texture
462 TextureId RequestLoadInternal(
463 const VisualUrl& url,
464 const TextureManager::TextureId& maskTextureId,
465 const float& contentScale,
466 const Dali::ImageDimensions& desiredSize,
467 const Dali::FittingMode::Type& fittingMode,
468 const Dali::SamplingMode::Type& samplingMode,
469 const TextureManager::UseAtlas& useAtlas,
470 const bool& cropToMask,
471 const TextureManager::StorageType& storageType,
472 TextureUploadObserver* observer,
473 const bool& orientationCorrection,
474 const TextureManager::ReloadPolicy& reloadPolicy,
475 TextureManager::MultiplyOnLoad& preMultiplyOnLoad,
476 Dali::AnimatedImageLoading animatedImageLoading,
477 const std::uint32_t& frameIndex,
478 const bool& synchronousLoading,
479 const bool& useCache);
482 * @brief Load a new image synchronously.
483 * @param[in] url The URL of the image to load
484 * @param[in] desiredSize The size the image is likely to appear at.
485 * This can be set to 0,0 for automatic
486 * @param[in] fittingMode The FittingMode to use
487 * @param[in] samplingMode The SamplingMode to use
488 * @param[in] orientationCorrection Whether to use image metadata to rotate or flip the image,
489 * e.g., from portrait to landscape
490 * @return PixelBuffer of loaded image.
492 Devel::PixelBuffer LoadImageSynchronously(
493 const VisualUrl& url,
494 const Dali::ImageDimensions& desiredSize,
495 const Dali::FittingMode::Type& fittingMode,
496 const Dali::SamplingMode::Type& samplingMode,
497 const bool& orientationCorrection);
503 * Structure to hold info about a texture load queued during NotifyObservers
505 struct LoadQueueElement
507 LoadQueueElement(TextureManager::TextureId textureId, TextureUploadObserver* observer)
508 : mTextureId(textureId),
513 TextureManager::TextureId mTextureId; ///< The texture id of the requested load.
514 TextureUploadObserver* mObserver; ///< Observer of texture load.
518 * @brief Initiate a load or queue load if NotifyObservers is invoking callbacks
519 * @param[in] textureInfo The TextureInfo struct associated with the Texture
520 * @param[in] observer The observer wishing to observe the texture upload
522 void LoadOrQueueTexture(TextureManager::TextureInfo& textureInfo, TextureUploadObserver* observer);
525 * @brief Queue a texture load to be subsequently handled by ProcessQueuedTextures.
526 * @param[in] textureInfo The TextureInfo struct associated with the Texture
527 * @param[in] observer The observer wishing to observe the texture upload
529 void QueueLoadTexture(const TextureManager::TextureInfo& textureInfo, TextureUploadObserver* observer);
532 * @brief Used internally to initiate a load.
533 * @param[in] textureInfo The TextureInfo struct associated with the Texture
534 * @param[in] observer The observer wishing to observe the texture upload
536 void LoadTexture(TextureManager::TextureInfo& textureInfo, TextureUploadObserver* observer);
539 * @brief Initiate load of textures queued whilst NotifyObservers invoking callbacks.
541 void ProcessLoadQueue();
544 * @brief Initiate remove of texture queued whilst NotifyObservers invoking callbacks.
546 void ProcessRemoveQueue();
549 * Add the observer to the observer list
550 * @param[in] textureInfo The TextureInfo struct associated with the texture
551 * @param[in] observer The observer wishing to observe the texture upload
553 void ObserveTexture(TextureManager::TextureInfo& textureInfo, TextureUploadObserver* observer);
556 * @brief Performs Post-Load steps including atlasing.
557 * @param[in] textureInfo The struct associated with this Texture
558 * @param[in] pixelBuffer The image pixelBuffer
559 * @return True if successful
561 void PostLoad(TextureManager::TextureInfo& textureInfo, Devel::PixelBuffer& pixelBuffer);
564 * Check if there is a texture waiting to be masked. If there
565 * is then apply this mask and upload it.
566 * @param[in] maskTextureInfo The texture info of the mask that has just loaded.
568 void CheckForWaitingTexture(TextureManager::TextureInfo& maskTextureInfo);
571 * Apply the mask to the pixelBuffer.
572 * @param[in] textureInfo The information of texture to apply the mask to
573 * @param[in] maskTextureId The texture id of the mask.
575 void ApplyMask(TextureManager::TextureInfo& textureInfo, const TextureManager::TextureId& maskTextureId);
578 * Upload the texture specified in pixelBuffer to the appropriate location
579 * @param[in] pixelBuffer The image data to upload
580 * @param[in] textureInfo The texture info containing the location to
583 void UploadTexture(Devel::PixelBuffer& pixelBuffer, TextureManager::TextureInfo& textureInfo);
586 * Notify the current observers that the texture upload is complete,
587 * then remove the observers from the list.
588 * @param[in] textureInfo The struct associated with this Texture
589 * @param[in] success If the pixel data was retrieved successfully and uploaded to GPU
591 void NotifyObservers(TextureManager::TextureInfo& textureInfo, const bool& success);
594 * Call LoadComplete to the observer.
595 * @param[in] observer The client object should inherit from this and provide the "LoadCompleted"
596 * @param[in] textureInfo The struct associated with this Texture
597 * @param[in] success If the pixel data was retrieved successfully and uploaded to GPU
599 void EmitLoadComplete(TextureUploadObserver* observer, TextureManager::TextureInfo& textureInfo, const bool& success);
603 * @brief Common method to handle loading completion.
604 * TextureAsyncLoadingHelper will call this API After async loading finished.
605 * @param[in] textureId The ID of the texture load complete.
606 * @param[in] pixelBuffer The loaded image data
608 void AsyncLoadComplete(const TextureManager::TextureId& textureId, Devel::PixelBuffer pixelBuffer);
612 * Deleted copy constructor.
614 TextureManager(const TextureManager&) = delete;
617 * Deleted assignment operator.
619 TextureManager& operator=(const TextureManager& rhs) = delete;
622 * This is called by the TextureManagerUploadObserver when an observer is destroyed.
623 * We use the callback to know when to remove an observer from our notify list.
624 * @param[in] observer The observer that generated the callback
626 void ObserverDestroyed(TextureUploadObserver* observer);
628 private: // Member Variables:
629 TextureCacheManager mTextureCacheManager; ///< Manager the life-cycle and caching of Textures
631 RoundRobinContainerView<TextureAsyncLoadingHelper> mAsyncLocalLoaders; ///< The Asynchronous image loaders used to provide all local async loads
632 RoundRobinContainerView<TextureAsyncLoadingHelper> mAsyncRemoteLoaders; ///< The Asynchronous image loaders used to provide all remote async loads
634 Dali::Vector<LifecycleObserver*> mLifecycleObservers; ///< Lifecycle observers of texture manager
635 Dali::Vector<LoadQueueElement> mLoadQueue; ///< Queue of textures to load after NotifyObservers
636 Dali::Vector<TextureManager::TextureId> mRemoveQueue; ///< Queue of textures to remove after NotifyObservers
637 bool mQueueLoadFlag; ///< Flag that causes Load Textures to be queued.
640 } // namespace Internal
642 } // namespace Toolkit
646 #endif // DALI_TOOLKIT_TEXTURE_MANAGER_IMPL_H