dali/internal/update/resources/resource-manager.h

   1 #ifndef __DALI_INTERNAL_RESOURCE_MANAGER_H__
   2 #define __DALI_INTERNAL_RESOURCE_MANAGER_H__
   3
   4 /*
   5  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   6  *
   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
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <string>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/public-api/images/image.h>
  26 #include <dali/public-api/images/native-image-interface.h>
  27 #include <dali/public-api/images/buffer-image.h>
  28 #include <dali/public-api/common/ref-counted-dali-vector.h>
  29
  30 #include <dali/integration-api/bitmap.h>
  31 #include <dali/integration-api/platform-abstraction.h>
  32 #include <dali/integration-api/resource-cache.h>
  33 #include <dali/integration-api/shader-data.h>
  34
  35 #include <dali/internal/common/event-to-update.h>
  36 #include <dali/internal/common/message.h>
  37 #include <dali/internal/event/common/thread-local-storage.h>
  38 #include <dali/internal/common/bitmap-upload.h>
  39 #include <dali/internal/event/text/font-impl.h>
  40 #include <dali/internal/event/resources/resource-client-declarations.h>
  41 #include <dali/internal/event/effects/shader-factory.h>
  42 #include <dali/internal/update/modeling/internal-mesh-data.h>
  43 #include <dali/internal/update/modeling/scene-graph-mesh-declarations.h>
  44 #include <dali/internal/update/resources/resource-manager-declarations.h>
  45 #include <dali/internal/update/resources/bitmap-metadata.h>
  46
  47 namespace Dali
  48 {
  49
  50 class NativeImageInterface;
  51
  52 namespace Integration
  53 {
  54 struct ResourceType;
  55 }
  56
  57 namespace Internal
  58 {
  59
  60 // value types used by messages
  61 template <> struct ParameterType< Integration::LoadResourcePriority >
  62 : public BasicType< Integration::LoadResourcePriority > {};
  63 template <> struct ParameterType< Pixel::Format >
  64 : public BasicType< Pixel::Format > {};
  65 template <> struct ParameterType< Integration::ResourceTypeId >
  66 : public BasicType< Integration::ResourceTypeId > {};
  67
  68 namespace SceneGraph
  69 {
  70 class DiscardQueue;
  71 class RenderQueue;
  72 class TextureCacheDispatcher;
  73 class PostProcessResourceDispatcher;
  74 }
  75
  76 class NotificationManager;
  77
  78 /** Raw bytes of a resource laid out exactly as it wouldbe in a file, but in memory. */
  79 typedef Dali::RefCountedVector<uint8_t> RequestBuffer;
  80 /** Counting smart pointer for managing a buffer of raw bytes. */
  81 typedef IntrusivePtr<RequestBuffer> RequestBufferPtr;
  82
  83 /**
  84  * ResourceManager keeps track of resource loading requests, and caches resources that are loaded.
  85  * It uses ResourceTicket objects, to keep track of the lifetime of each request.
  86  * If the same resource is required by two client objects, they will share the same ResourceTicket
  87  * i.e. only one load will occur using the native filesystem.
  88  *
  89  * Multi-threading notes:
  90  * Resources are received from the PlatformAbstraction API during the Core::Render() method, which
  91  * may be called from a dedicated rendering thread.
  92  * Loading requests must be made from the application's main thread e.g. when Dali::Image is created.
  93  */
  94 class ResourceManager : public Integration::ResourceCache
  95 {
  96 public:
  97
  98   /**
  99    * Create a resource manager.
 100    * There should exactly one of these objects per Dali Core.
 101    * @param[in] platformAbstraction Used to request resources from the native filesystem.
 102    * @param[in] notificationManager Used to send NotifyTickets message.
 103    * @param[in] postProcessResourcesQueue Used for performing post processing on resources
 104    * @param[in] discardQueue Used to cleanup nodes & resources when no longer in use.
 105    * @param[in] renderQueue Used to queue resource updates until the next Render.
 106    */
 107   ResourceManager( Integration::PlatformAbstraction& platformAbstraction,
 108                    NotificationManager& notificationManager,
 109                    SceneGraph::TextureCacheDispatcher& textureCacheDispatcher,
 110                    ResourcePostProcessList& postProcessResourcesQueue,
 111                    SceneGraph::PostProcessResourceDispatcher& postProcessResourceDispatcher,
 112                    SceneGraph::DiscardQueue& discardQueue,
 113                    SceneGraph::RenderQueue& renderQueue );
 114
 115   /**
 116    * Virtual destructor.
 117    */
 118   virtual ~ResourceManager();
 119
 120 public: // Used by ResourceClient
 121
 122   /********************************************************************************
 123    ************************ ResourceClient direct interface  **********************
 124    ********************************************************************************/
 125
 126   /**
 127    * Resource client passes itself for secondary intialisation.
 128    * (The resource client requires the ResourceManager to be instantiated first).
 129    * @param[in] resourceClient The ResourceClient.
 130    */
 131   void SetClient( ResourceClient& resourceClient );
 132
 133   /********************************************************************************
 134    ************************ UpdateManager direct interface  ***********************
 135    ********************************************************************************/
 136
 137   /**
 138    * Called to update the resource cache before rendering.
 139    * New resources will be added to the cache using PlatformAbstraction::FillResourceCache().
 140    * Unwanted resources will be added to the DiscardQueue.
 141    * @param[in] updateBufferIndex The current update buffer index.
 142    * @return true, if a resource load was completed or failed
 143    */
 144   bool UpdateCache( BufferIndex updateBufferIndex );
 145
 146   /**
 147    * Iterate through the post process queue, performing requested updates.
 148    * @param[in] updateBufferIndex The current update buffer index.
 149    */
 150   void PostProcessResources( BufferIndex updateBufferIndex );
 151
 152   /********************************************************************************
 153    *************************** CoreImpl direct interface  *************************
 154    ********************************************************************************/
 155
 156   /**
 157    * Returns whether the Resource Manager is still processing any resource requests.
 158    * @return true if still processing, false otherwise.
 159    */
 160   bool ResourcesToProcess();
 161
 162   /********************************************************************************
 163    ********************************* Message handlers *****************************
 164    ********************************************************************************/
 165
 166   /**
 167    * Request a resource from the native filesystem.
 168    * @param[in] id The Id of the requested resource
 169    * @param[in] typePath The type & path of requested resource.
 170    * @param[in] priority The priority of the request. This is ignored if the resource is already being loaded.
 171    */
 172   void HandleLoadResourceRequest( ResourceId id,
 173                                   const ResourceTypePath& typePath,
 174                                   Integration::LoadResourcePriority priority );
 175
 176   /**
 177    * Decode a resource from a memory buffer with the semantics of loading.
 178    * Notifications of partial completion, success, and failure will happen via
 179    * the same loading notification path used for loading from files: Update()
 180    * will retrieve loading events in its main loop and notify listeners to its
 181    * own loading events, and forward them, still as loading events, to the event
 182    * thread via its update queue.
 183    * Resource manager and lower levels make no attempt to detect resource
 184    * aliases as is done for multiple requests to load the same resource
 185    * file, so the caller is responsible for ensuring that it only requests
 186    * the decoding of an in-memory resource once and for doing the sharing of the
 187    * resulting object itself. Ultimately this responsibility resides with the
 188    * application.
 189    * @note ! Only Bitmap resources are supported for decoding from memory !
 190    * @param[in] id The Id of the requested resource.
 191    * @param[in] typePath The type of the requested resource and a path that is ignored.
 192    * @param[in] buffer The raw encoded bytes of the resource as they would appear in a file.
 193    * @param[in] priority The priority of the request. This is ignored if the resource is already being loaded.
 194    */
 195   void HandleDecodeResourceRequest( ResourceId id,
 196                                     const ResourceTypePath& typePath,
 197                                     RequestBufferPtr buffer,
 198                                     Integration::LoadResourcePriority priority );
 199
 200   /**
 201    * Injects a bitmap resource (does not require loading).
 202    * @pre bitmap has to be initialized
 203    * @param[in] id The resource id
 204    * @param[in] bitmap an initialized bitmap
 205    */
 206   void HandleAddBitmapImageRequest(ResourceId id, Integration::BitmapPtr bitmap);
 207
 208   /**
 209    * Add an existing resource to the resource manager.
 210    * @param[in] id The resource id
 211    * @param [in] resourceData the NativeImageInterface object
 212    * @return A ref-counted request object. Keep a copy until the resource is no longer required.
 213    */
 214   void HandleAddNativeImageRequest( ResourceId id, NativeImageInterfacePtr resourceData );
 215
 216   /**
 217    * Add an existing resource to the resource manager.
 218    * @param[in] id The resource id
 219    * @param[in] width       width in pixels
 220    * @param[in] height      height in pixels
 221    * @param[in] pixelFormat Pixel format
 222    */
 223   void HandleAddFrameBufferImageRequest( ResourceId id, unsigned int width, unsigned int height, Pixel::Format pixelFormat );
 224
 225   /**
 226    * Add an existing resource to the resource manager.
 227    * @param[in] id            The resource id
 228    * @param[in] nativeImage   The NativeImage
 229    */
 230   void HandleAddFrameBufferImageRequest( ResourceId id, NativeImageInterfacePtr nativeImage );
 231
 232   /**
 233    * Allocate a new empty texture.
 234    * @param[in] id The resource id
 235    * @param[in] width       width in pixels
 236    * @param[in] height      height in pixels
 237    * @param[in] pixelFormat Pixel format
 238    */
 239   void HandleAllocateTextureRequest( ResourceId id, unsigned int width, unsigned int height, Pixel::Format pixelFormat );
 240
 241   /**
 242    * Upload an array of bitmaps to a texture.
 243    * @param[in] id The resource id
 244    * @param[in] uploadArray  bitmap upload array.
 245    */
 246   void HandleUpdateTextureRequest( ResourceId id,  const BitmapUploadArray& uploadArray );
 247
 248   /**
 249    * Requests allocation of a mesh resource
 250    * @param[in] id The resource id
 251    * @param[in] meshData The mesh data
 252    */
 253   void HandleAllocateMeshRequest (ResourceId id, MeshData* meshData);
 254
 255   /**
 256    * Requests allocation of a font resource
 257    */
 258   void HandleAllocateFontRequest(ResourceId id, const std::string& familyNameAndStyle);
 259
 260   /**
 261    * Load a shader program from a file
 262    * @param[in] id The resource id
 263    * @param[in] typePath The type & path of the resource
 264    */
 265   void HandleLoadShaderRequest(ResourceId id, const ResourceTypePath& typePath );
 266
 267   /**
 268    * Update bitmap area request
 269    * @param[in] textureId The resource ID of a bitmap-texture to remove.
 270    * @param[in] area The updated area. Zero width/height indicates the whole bitmap has been updated
 271    */
 272   void HandleUpdateBitmapAreaRequest( ResourceId textureId, const Dali::RectArea& area );
 273
 274   /**
 275    * Upload a bitmap to a position within a specified texture
 276    * @param[in] destId The destination texture ID
 277    * @param[in] bitmap The pointer pointing to the bitmap data to upload
 278    * @param [in] xOffset Specifies an offset in the x direction within the texture
 279    * @param [in] yOffset Specifies an offset in the y direction within the texture
 280    */
 281   void HandleUploadBitmapRequest( ResourceId destId, Integration::BitmapPtr bitmap, std::size_t xOffset, std::size_t yOffset );
 282
 283   /**
 284    * Upload a bitmap to a position within a specified texture
 285    * @param[in] destId The destination texture ID
 286    * @param[in] srcId The resource ID of the bitmap to upload
 287    * @param [in] xOffset Specifies an offset in the x direction within the texture
 288    * @param [in] yOffset Specifies an offset in the y direction within the texture
 289    */
 290   void HandleUploadBitmapRequest( ResourceId destId, ResourceId srcId, std::size_t xOffset, std::size_t yOffset );
 291
 292   /**
 293    * Upload mesh buffer changes.
 294    * @param[in] updateBufferIndex The current update buffer index.
 295    * @param[in] id The ID of a Mesh resource.
 296    * @param[in] meshData Newly allocated mesh data; ownership is taken.
 297    */
 298   void HandleUpdateMeshRequest( BufferIndex updateBufferIndex, ResourceId id, MeshData* meshData );
 299
 300   /**
 301    * Request reloading a resource from the native filesystem.
 302    * @param[in] id The resource id
 303    * @param[in] typePath The type & path of the resource
 304    * @param[in] priority The priority of the request. This is ignored if the resource is already being refreshed.
 305    * @param[in] resetFinishedStatus True if the finished status of the resource id should be reset
 306    */
 307   void HandleReloadResourceRequest( ResourceId id, const ResourceTypePath& typePath, Integration::LoadResourcePriority priority, bool resetFinishedStatus );
 308
 309   /**
 310    * Save a resource to the given url
 311    * @param[in] id       The resource id
 312    * @param[in] typePath The type & path of the resource
 313    */
 314   void HandleSaveResourceRequest( ResourceId id, const ResourceTypePath& typePath );
 315
 316   /**
 317    * Resource ticket has been discarded, throw away the actual resource
 318    */
 319   void HandleDiscardResourceRequest( ResourceId id, Integration::ResourceTypeId typeId );
 320
 321   /**
 322    * Update font texture atlas status
 323    * @param[in] id         The resource id
 324    * @param[in] atlasId    texture ID of the atlas
 325    * @param[in] loadStatus The status update.
 326    */
 327   void HandleAtlasUpdateRequest( ResourceId id, ResourceId atlasId, Integration::LoadStatus loadStatus );
 328
 329   /********************************************************************************
 330    ******************** Update thread object direct interface  ********************
 331    ********************************************************************************/
 332
 333   /**
 334    * Check if a resource has completed loading.
 335    * @param[in] id The ID of a bitmap/texture resource.
 336    * @return true if the bitmap or texture has finished loading
 337    */
 338   bool IsResourceLoaded(ResourceId id);
 339
 340   /**
 341    * Check if a resource has failed to load, e.g. file not found, etc.
 342    * @param[in] id The ID of a bitmap/texture resource.
 343    * @return true if the bitmap or texture has failed to load
 344    */
 345   bool IsResourceLoadFailed(ResourceId id);
 346
 347   /**
 348    * Get bitmap metadata. This stores meta data about the resource, but
 349    * doesn't keep track of the resource
 350    */
 351   BitmapMetadata GetBitmapMetadata(ResourceId id);
 352
 353   /**
 354    * Get the mesh data.
 355    * @note Used by update thread objects (SceneGraph::Mesh) only
 356    * @param[in] id - the id of a MeshData resource.
 357    * @return the mesh data or NULL if this resource isn't valid
 358    */
 359   Internal::SceneGraph::Mesh* GetMesh(ResourceId id);
 360
 361   /**
 362    * Returns the shader resource corresponding to the Id
 363    * @param[in] id - the id of a shader binary resource.
 364    * @return the shader binary resource data or NULL if it has not been loaded.
 365    */
 366   Integration::ShaderDataPtr GetShaderData(ResourceId id);
 367
 368   /**
 369    * Check if current set of glyph requests on given atlas have finished loading
 370    * @param[in] id Request Id of the text atlas texture
 371    * @return true if the current set of glyph requests have all completed, false
 372    * if there are outstanding glyph requests that haven't finished.
 373    */
 374   bool IsAtlasLoaded(ResourceId id);
 375
 376   /**
 377    * Check the load status of a given atlas.
 378    * @param[in] id Request Id of the text atlas texture
 379    * @return LoadStatus
 380    */
 381   Integration::LoadStatus GetAtlasLoadStatus( ResourceId atlasId );
 382
 383   /********************************************************************************
 384    ************************* ResourceCache Implementation  ************************
 385    ********************************************************************************/
 386 public:
 387
 388   /**
 389    * @copydoc Integration::ResourceCache::LoadResponse
 390    */
 391   virtual void LoadResponse(ResourceId id, Integration::ResourceTypeId type, Integration::ResourcePointer resource, Integration::LoadStatus loadStatus);
 392
 393   /**
 394    * @copydoc Integration::ResourceCache::SaveComplete
 395    */
 396   virtual void SaveComplete(ResourceId id, Integration::ResourceTypeId type);
 397
 398   /**
 399    * @copydoc Integration::ResourceCache::LoadFailed
 400    */
 401   virtual void LoadFailed(ResourceId id, Integration::ResourceFailure failure);
 402
 403   /**
 404    * @copydoc Integration::ResourceCache::SaveFailed
 405    */
 406   virtual void SaveFailed(ResourceId id, Integration::ResourceFailure failure);
 407
 408   /********************************************************************************
 409    ********************************* Private Methods  *****************************
 410    ********************************************************************************/
 411 private:
 412
 413   /**
 414    * @param[in] id Resource id to clear
 415    * @param[in] typePath Glyphs to be loaded, and cleared beforehand
 416    */
 417   void ClearRequestedGlyphArea( ResourceId id, const ResourceTypePath& typePath );
 418
 419   /**
 420    * Sends loaded glyphs to texture atlas for uploading
 421    * @param[in] glyphSet Loaded glyphs
 422    */
 423   void UploadGlyphsToTexture( const Integration::GlyphSet& glyphSet );
 424
 425   /**
 426    * Sends notification messages for load sucess & failure,
 427    * pushes from newComplete / newFailed into oldComplete / oldFailed respectively
 428    */
 429   void NotifyTickets();
 430
 431   /**
 432    * Triggers message to Event thread to update the ticket's image attributes
 433    * @pre An Image resource with the given id should exist in the cache.
 434    * @param id ID of the image resource
 435    * @param attributes Resource image attributes
 436    */
 437   void UpdateImageTicket( ResourceId id, ImageAttributes& attributes );
 438
 439   /**
 440    * Send message to ResourceClient in event thread
 441    * @param[in] message The message to send
 442    */
 443   void SendToClient( MessageBase* message );
 444
 445   /**
 446    * Discard all dead resources.
 447    * @param[in] updateBufferIndex The current update buffer index.
 448    */
 449   void DiscardDeadResources( BufferIndex updateBufferIndex );
 450
 451 private:
 452   struct ResourceManagerImpl;
 453   ResourceManagerImpl* mImpl;
 454 };
 455
 456 // Messages sent to resource manager from other threads:
 457 // These functions are run on other threads and insert messages to be
 458 // picked-up by the update thread in its main loop and executed on that in
 459 // submission order.
 460
 461 inline void RequestLoadResourceMessage( EventToUpdate& eventToUpdate,
 462                                         ResourceManager& manager,
 463                                         ResourceId id,
 464                                         const ResourceTypePath& typePath,
 465                                         Integration::LoadResourcePriority priority )
 466 {
 467   typedef MessageValue3< ResourceManager, ResourceId, ResourceTypePath, Integration::LoadResourcePriority > LocalType;
 468
 469   // Reserve some memory inside the message queue
 470   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ), false );
 471
 472   // Construct message in the message queue memory; note that delete should not be called on the return value
 473   new (slot) LocalType( &manager, &ResourceManager::HandleLoadResourceRequest, id, typePath, priority );
 474 }
 475
 476 inline void RequestDecodeResourceMessage( EventToUpdate& eventToUpdate,
 477                                           ResourceManager& manager,
 478                                           const ResourceId id,
 479                                           /// We use typePath instead of the raw type for ownership and to enable copying of a concrete type.
 480                                           const ResourceTypePath& typePath,
 481                                           RequestBufferPtr buffer,
 482                                           Integration::LoadResourcePriority priority )
 483 {
 484   typedef MessageValue4< ResourceManager, ResourceId, ResourceTypePath, RequestBufferPtr, Integration::LoadResourcePriority > LocalType;
 485
 486   // Reserve some memory inside the message queue
 487   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ), false );
 488
 489   // Construct message in the message queue memory; note that delete should not be called on the return value
 490   new (slot) LocalType( &manager, &ResourceManager::HandleDecodeResourceRequest, id, typePath, buffer, priority );
 491 }
 492
 493 inline void RequestAddBitmapImageMessage( EventToUpdate& eventToUpdate,
 494                                           ResourceManager& manager,
 495                                           ResourceId id,
 496                                           Integration::Bitmap* resourceData )
 497 {
 498   typedef MessageValue2< ResourceManager, ResourceId, Integration::BitmapPtr > LocalType;
 499
 500   // Reserve some memory inside the message queue
 501   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 502
 503   // Construct message in the message queue memory; note that delete should not be called on the return value
 504   new (slot) LocalType( &manager, &ResourceManager::HandleAddBitmapImageRequest, id, resourceData );
 505 }
 506
 507 inline void RequestAddNativeImageMessage( EventToUpdate& eventToUpdate,
 508                                           ResourceManager& manager,
 509                                           ResourceId id,
 510                                           NativeImageInterfacePtr resourceData )
 511 {
 512   typedef MessageValue2< ResourceManager, ResourceId, NativeImageInterfacePtr > LocalType;
 513
 514   // Reserve some memory inside the message queue
 515   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 516
 517   // Construct message in the message queue memory; note that delete should not be called on the return value
 518   new (slot) LocalType( &manager, &ResourceManager::HandleAddNativeImageRequest, id, resourceData );
 519 }
 520
 521 inline void RequestAddFrameBufferImageMessage( EventToUpdate& eventToUpdate,
 522                                                ResourceManager& manager,
 523                                                ResourceId id,
 524                                                unsigned int width,
 525                                                unsigned int height,
 526                                                Pixel::Format pixelFormat )
 527 {
 528   typedef MessageValue4< ResourceManager, ResourceId, unsigned int, unsigned int, Pixel::Format > LocalType;
 529
 530   // Reserve some memory inside the message queue
 531   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 532
 533   // Construct message in the message queue memory; note that delete should not be called on the return value
 534   new (slot) LocalType( &manager, &ResourceManager::HandleAddFrameBufferImageRequest, id, width, height, pixelFormat );
 535 }
 536
 537 inline void RequestAddFrameBufferImageMessage( EventToUpdate& eventToUpdate,
 538                                                ResourceManager& manager,
 539                                                ResourceId id,
 540                                                NativeImageInterfacePtr resourceData )
 541 {
 542   typedef MessageValue2< ResourceManager, ResourceId, NativeImageInterfacePtr > LocalType;
 543
 544   // Reserve some memory inside the message queue
 545   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 546
 547   // Construct message in the message queue memory; note that delete should not be called on the return value
 548   new (slot) LocalType( &manager, &ResourceManager::HandleAddFrameBufferImageRequest, id, resourceData );
 549 }
 550
 551 inline void RequestAllocateTextureMessage(EventToUpdate& eventToUpdate,
 552                                                ResourceManager& manager,
 553                                                ResourceId id,
 554                                                unsigned int width,
 555                                                unsigned int height,
 556                                                Pixel::Format pixelFormat)
 557 {
 558   typedef MessageValue4< ResourceManager, ResourceId, unsigned int, unsigned int, Pixel::Format > LocalType;
 559
 560   // Reserve some memory inside the message queue
 561   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 562
 563   // Construct message in the message queue memory; note that delete should not be called on the return value
 564   new (slot) LocalType( &manager, &ResourceManager::HandleAllocateTextureRequest, id, width, height, pixelFormat );
 565 }
 566
 567 inline void RequestUpdateTextureMessage(EventToUpdate& eventToUpdate,
 568                                                ResourceManager& manager,
 569                                                ResourceId id,
 570                                                BitmapUploadArray uploadArray )
 571 {
 572   typedef MessageValue2< ResourceManager, ResourceId, BitmapUploadArray > LocalType;
 573
 574   // Reserve some memory inside the message queue
 575   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 576
 577   // Construct message in the message queue memory; note that delete should not be called on the return value
 578   new (slot) LocalType( &manager, &ResourceManager::HandleUpdateTextureRequest, id, uploadArray );
 579 }
 580
 581 inline void RequestAllocateMeshMessage( EventToUpdate& eventToUpdate,
 582                                         ResourceManager& manager,
 583                                         ResourceId id,
 584                                         OwnerPointer<MeshData>& meshData )
 585 {
 586   typedef MessageValue2< ResourceManager, ResourceId, OwnerPointer<MeshData> > LocalType;
 587
 588   // Reserve some memory inside the message queue
 589   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 590
 591   // Construct message in the message queue memory; note that delete should not be called on the return value
 592   new (slot) LocalType( &manager, &ResourceManager::HandleAllocateMeshRequest, id, meshData.Release() );
 593 }
 594
 595 inline void RequestAllocateFontMessage( EventToUpdate& eventToUpdate,
 596                                         ResourceManager& manager,
 597                                         ResourceId id,
 598                                         const std::string& familyNameAndStyle)
 599 {
 600   typedef MessageValue2< ResourceManager, ResourceId, std::string > LocalType;
 601
 602   // Reserve some memory inside the message queue
 603   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 604
 605   // Construct message in the message queue memory; note that delete should not be called on the return value
 606   new (slot) LocalType( &manager, &ResourceManager::HandleAllocateFontRequest, id, familyNameAndStyle );
 607 }
 608
 609 inline void RequestLoadShaderMessage( EventToUpdate& eventToUpdate,
 610                                       ResourceManager& manager,
 611                                       ResourceId id,
 612                                       const ResourceTypePath& typePath )
 613 {
 614   typedef MessageValue2< ResourceManager, ResourceId, ResourceTypePath > LocalType;
 615
 616   // Reserve some memory inside the message queue
 617   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 618
 619   // Construct message in the message queue memory; note that delete should not be called on the return value
 620   new (slot) LocalType( &manager, &ResourceManager::HandleLoadShaderRequest, id, typePath );
 621 }
 622
 623 inline void RequestUpdateBitmapAreaMessage( EventToUpdate& eventToUpdate,
 624                                             ResourceManager& manager,
 625                                             ResourceId id,
 626                                             const Dali::RectArea& area )
 627 {
 628   typedef MessageValue2< ResourceManager, ResourceId, Dali::RectArea > LocalType;
 629
 630   // Reserve some memory inside the message queue
 631   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ), false );
 632
 633   // Construct message in the message queue memory; note that delete should not be called on the return value
 634   new (slot) LocalType( &manager, &ResourceManager::HandleUpdateBitmapAreaRequest, id, area );
 635 }
 636
 637 inline void RequestUploadBitmapMessage( EventToUpdate& eventToUpdate,
 638                                         ResourceManager& manager,
 639                                         ResourceId destId,
 640                                         Integration::BitmapPtr bitmap,
 641                                         std::size_t xOffset,
 642                                         std::size_t yOffset )
 643 {
 644   typedef MessageValue4< ResourceManager, ResourceId, Integration::BitmapPtr , std::size_t, std::size_t > LocalType;
 645
 646   // Reserve some memory inside the message queue
 647   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ), false );
 648
 649   // Construct message in the message queue memory; note that delete should not be called on the return value
 650   new (slot) LocalType( &manager, &ResourceManager::HandleUploadBitmapRequest, destId, bitmap, xOffset, yOffset );
 651 }
 652
 653 inline void RequestUploadBitmapMessage( EventToUpdate& eventToUpdate,
 654                                         ResourceManager& manager,
 655                                         ResourceId destId,
 656                                         ResourceId srcId,
 657                                         std::size_t xOffset,
 658                                         std::size_t yOffset )
 659 {
 660   typedef MessageValue4< ResourceManager, ResourceId, ResourceId, std::size_t, std::size_t > LocalType;
 661
 662   // Reserve some memory inside the message queue
 663   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ), false );
 664
 665   // Construct message in the message queue memory; note that delete should not be called on the return value
 666   new (slot) LocalType( &manager, &ResourceManager::HandleUploadBitmapRequest, destId, srcId, xOffset, yOffset );
 667 }
 668
 669 inline void RequestUpdateMeshMessage( EventToUpdate& eventToUpdate,
 670                                       ResourceManager& manager,
 671                                       ResourceId id,
 672                                       const Dali::MeshData& meshData,
 673                                       ResourcePolicy::Discardable discardable )
 674 {
 675   typedef MessageDoubleBuffered2< ResourceManager, ResourceId, OwnerPointer< MeshData > > LocalType;
 676   // Reserve some memory inside the message queue
 677   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 678
 679   MeshData* internalMeshData = new MeshData( meshData, discardable, false );
 680
 681   // Construct message in the message queue memory; note that delete should not be called on the return value
 682   new (slot) LocalType( &manager, &ResourceManager::HandleUpdateMeshRequest, id, internalMeshData );
 683 }
 684
 685 inline void RequestReloadResourceMessage( EventToUpdate& eventToUpdate,
 686                                           ResourceManager& manager,
 687                                           ResourceId id,
 688                                           const ResourceTypePath& typePath,
 689                                           Integration::LoadResourcePriority priority,
 690                                           bool resetFinishedStatus )
 691 {
 692   typedef MessageValue4< ResourceManager, ResourceId, ResourceTypePath, Integration::LoadResourcePriority, bool > LocalType;
 693
 694   // Reserve some memory inside the message queue
 695   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ), false );
 696
 697   // Construct message in the message queue memory; note that delete should not be called on the return value
 698   new (slot) LocalType( &manager, &ResourceManager::HandleReloadResourceRequest, id, typePath, priority, resetFinishedStatus );
 699 }
 700
 701 inline void RequestSaveResourceMessage( EventToUpdate& eventToUpdate,
 702                                         ResourceManager& manager,
 703                                         ResourceId id,
 704                                         const ResourceTypePath& typePath )
 705 {
 706   typedef MessageValue2< ResourceManager, ResourceId, ResourceTypePath > LocalType;
 707
 708   // Reserve some memory inside the message queue
 709   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 710
 711   // Construct message in the message queue memory; note that delete should not be called on the return value
 712   new (slot) LocalType( &manager, &ResourceManager::HandleSaveResourceRequest, id, typePath );
 713 }
 714
 715 inline void RequestDiscardResourceMessage( EventToUpdate& eventToUpdate,
 716                                            ResourceManager& manager,
 717                                            ResourceId id,
 718                                            Integration::ResourceTypeId typeId )
 719 {
 720   typedef MessageValue2< ResourceManager, ResourceId, Integration::ResourceTypeId > LocalType;
 721
 722   // Reserve some memory inside the message queue
 723   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 724
 725   // Construct message in the message queue memory; note that delete should not be called on the return value
 726   new (slot) LocalType( &manager, &ResourceManager::HandleDiscardResourceRequest, id, typeId );
 727 }
 728
 729 inline void RequestAtlasUpdateMessage( EventToUpdate& eventToUpdate,
 730                                        ResourceManager& manager,
 731                                        ResourceId id,
 732                                        ResourceId atlasId,
 733                                        Integration::LoadStatus loadStatus )
 734 {
 735   typedef MessageValue3< ResourceManager, ResourceId, ResourceId, Integration::LoadStatus > LocalType;
 736
 737   // Reserve some memory inside the message queue
 738   unsigned int* slot = eventToUpdate.ReserveMessageSlot( sizeof( LocalType ) );
 739
 740   // Construct message in the message queue memory; note that delete should not be called on the return value
 741   new (slot) LocalType( &manager, &ResourceManager::HandleAtlasUpdateRequest, id, atlasId, loadStatus );
 742 }
 743
 744 } // namespace Internal
 745
 746 } // namespace Dali
 747
 748 #endif // __DALI_INTERNAL_RESOURCE_MANAGER_H__