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