Previously the queue consisted of two buffers which held update messages.
The resouce load message would come in but may not be stored in the current buffer.
Hence the message would only be processed on the next update when the buffers switched.
As the only post process is to notify an UPLOADED texture (DELETED is a no-op) the queue is now only of resource ID's indicating resource that has uploaded.
UtcDaliInternalRequestReloadBitmapRequests01, updated as now the Upload message will be sent before having to do another render-update.
Test-suite-utils updated to show location in code of Render WARNINGs
Change-Id: Ia38a2a32e3f45f6d3e07c0061db5cdfefa54ad12
{}
int LoadFailedCalled() {
- tet_printf("TicketObserver: LoadingFailed() called %d times", mLoadingFailedCalled);
+ tet_printf("TicketObserver: LoadingFailed() called %d times\n", mLoadingFailedCalled);
return mLoadingFailedCalled;
}
int LoadSucceededCalled() {
- tet_printf("TicketObserver: LoadingSucceeded() called %d times", mLoadingSucceededCalled);
+ tet_printf("TicketObserver: LoadingSucceeded() called %d times\n", mLoadingSucceededCalled);
return mLoadingSucceededCalled;
}
int UploadCalled() {
- tet_printf("TicketObserver: Uploaded() called %d times", mUploadedCount);
+ tet_printf("TicketObserver: Uploaded() called %d times\n", mUploadedCount);
return mUploadedCount;
}
void Reset() {
DALI_TEST_CHECK( req->GetId() == ticket->GetId() );
application.GetPlatform().SetResourceLoaded(id, Integration::ResourceBitmap, resourcePtr2);
- application.Render(0); // Process update messages / UpdateCache
+ application.Render(0 , TEST_LOCATION ); // Process update messages / UpdateCache
DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::GetResourcesFunc ) );
DALI_TEST_CHECK( resourceManager.IsResourceLoaded(id));
DALI_TEST_EQUALS( imageTicket->GetHeight(), 80, TEST_LOCATION );
application.SendNotification(); // Process event messages
- application.Render(0); // Process update messages / UpdateCache
+ application.Render(0, TEST_LOCATION ); // Process update messages / UpdateCache
application.SendNotification(); // Process event messages
DALI_TEST_EQUALS( testTicketObserver.LoadSucceededCalled(), 2, TEST_LOCATION );
- DALI_TEST_EQUALS( testTicketObserver.UploadCalled(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS( testTicketObserver.UploadCalled(), 1, TEST_LOCATION );
DALI_TEST_EQUALS( ticket->GetLoadingState(), ResourceLoadingSucceeded, TEST_LOCATION );
DALI_TEST_EQUALS( imageTicket->GetWidth(), 120, TEST_LOCATION );
DALI_TEST_EQUALS( imageTicket->GetHeight(), 120, TEST_LOCATION );
} // Discard ticket
application.SendNotification(); // Flush update queue (with ticket discarded message
- application.Render(1); // Process update messages
+ application.Render(1, TEST_LOCATION ); // Process update messages
application.SendNotification(); // Send event notifications
- application.Render(1); // Process update messages
// Resource should have been discarded.
DALI_TEST_CHECK( ! application.GetPlatform().WasCalled(TestPlatformAbstraction::CancelLoadFunc ) );
DALI_TEST_EQUALS( testTicketObserver.LoadSucceededCalled(), 2, TEST_LOCATION );
DALI_TEST_EQUALS( testTicketObserver.LoadFailedCalled(), 0, TEST_LOCATION );
- DALI_TEST_EQUALS( testTicketObserver.UploadCalled(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS( testTicketObserver.UploadCalled(), 1, TEST_LOCATION );
END_TEST;
}
mCore->SurfaceResized( mSurfaceWidth, mSurfaceHeight );
}
-void TestApplication::DoUpdate( unsigned int intervalMilliseconds )
+void TestApplication::DoUpdate( unsigned int intervalMilliseconds, const char* location )
{
if( GetUpdateStatus() == 0 &&
mRenderStatus.NeedsUpdate() == false &&
! GetRenderController().WasCalled(TestRenderController::RequestUpdateFunc) )
{
- fprintf(stderr, "WARNING - Update not required\n");
+ fprintf(stderr, "WARNING - Update not required :%s\n", location==NULL?"NULL":location);
}
unsigned int nextVSyncTime = mLastVSyncTime + intervalMilliseconds;
mLastVSyncTime = nextVSyncTime;
}
-bool TestApplication::Render( unsigned int intervalMilliseconds )
+bool TestApplication::Render( unsigned int intervalMilliseconds, const char* location )
{
- DoUpdate( intervalMilliseconds );
+ DoUpdate( intervalMilliseconds, location );
mCore->Render( mRenderStatus );
mFrame++;
void ProcessEvent(const Integration::Event& event);
void SendNotification();
void SetSurfaceWidth( unsigned int width, unsigned height );
- bool Render( unsigned int intervalMilliseconds = DEFAULT_RENDER_INTERVAL );
+ bool Render( unsigned int intervalMilliseconds = DEFAULT_RENDER_INTERVAL, const char* location=NULL );
unsigned int GetUpdateStatus();
bool UpdateOnly( unsigned int intervalMilliseconds = DEFAULT_RENDER_INTERVAL );
bool RenderOnly( );
bool GetRenderHasRendered();
private:
- void DoUpdate( unsigned int intervalMilliseconds );
+ void DoUpdate( unsigned int intervalMilliseconds, const char* location=NULL );
protected:
TestPlatformAbstraction mPlatformAbstraction;
mUpdateManager(NULL),
mRenderManager(NULL),
mDiscardQueue(NULL),
- mResourcePostProcessQueue(),
+ mTextureUploadedQueue(),
mNotificationManager(NULL),
mImageFactory(NULL),
mShaderFactory(NULL),
mPropertyNotificationManager = PropertyNotificationManager::New();
- std::vector< ResourcePostProcessRequest> init;
- mResourcePostProcessQueue = new ResourcePostProcessList(init);
+ mTextureUploadedQueue = new LockedResourceQueue;
- mRenderManager = RenderManager::New( glAbstraction, glSyncAbstraction, *mResourcePostProcessQueue );
+ mRenderManager = RenderManager::New( glAbstraction, glSyncAbstraction, *mTextureUploadedQueue );
RenderQueue& renderQueue = mRenderManager->GetRenderQueue();
TextureCache& textureCache = mRenderManager->GetTextureCache();
mResourceManager = new ResourceManager( mPlatform,
*mNotificationManager,
textureCache,
- *mResourcePostProcessQueue,
- *mRenderManager,
+ *mTextureUploadedQueue,
*mDiscardQueue,
renderQueue );
delete mTouchResampler;
delete mRenderManager;
delete mDiscardQueue;
- delete mResourcePostProcessQueue;
+ delete mTextureUploadedQueue;
}
Integration::ContextNotifierInterface* Core::GetContextNotifier()
SceneGraph::UpdateManager* mUpdateManager; ///< Update manager
SceneGraph::RenderManager* mRenderManager; ///< Render manager
SceneGraph::DiscardQueue* mDiscardQueue; ///< Used to cleanup nodes & resources when no longer in use.
- ResourcePostProcessList* mResourcePostProcessQueue; ///< Stores resource ids which require post processing after render
+ LockedResourceQueue* mTextureUploadedQueue; ///< Stores resource ids which require post processing after render
NotificationManager* mNotificationManager; ///< Notification manager
AnimationPlaylistOwner mAnimationPlaylist; ///< For 'Fire and forget' animation support
OwnerPointer<PropertyNotificationManager> mPropertyNotificationManager; ///< For safe signal emmision of property changed notifications
{
Impl( Integration::GlAbstraction& glAbstraction,
Integration::GlSyncAbstraction& glSyncAbstraction,
- ResourcePostProcessList& resourcePostProcessQ,
- PostProcessResourceDispatcher& postProcessDispatcher )
+ LockedResourceQueue& textureUploadedQ,
+ TextureUploadedDispatcher& postProcessDispatcher )
: context( glAbstraction ),
glSyncAbstraction( glSyncAbstraction ),
renderQueue(),
textureCache( renderQueue, postProcessDispatcher, context ),
- resourcePostProcessQueue( resourcePostProcessQ ),
+ textureUploadedQueue( textureUploadedQ ),
instructions(),
backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
frameCount( 0 ),
RenderQueue renderQueue; ///< A message queue for receiving messages from the update-thread.
TextureCache textureCache; ///< Cache for all GL textures
Render::UniformNameCache uniformNameCache; ///< Cache to provide unique indices for uniforms
- ResourcePostProcessList& resourcePostProcessQueue; ///< A queue for requesting resource post processing in update thread
+ LockedResourceQueue& textureUploadedQueue; ///< A queue for requesting resource post processing in update thread
// Render instructions describe what should be rendered during RenderManager::Render()
// Owned by RenderManager. Update manager updates instructions for the next frame while we render the current one
RenderManager* RenderManager::New( Integration::GlAbstraction& glAbstraction,
Integration::GlSyncAbstraction& glSyncAbstraction,
- ResourcePostProcessList& resourcePostProcessQ )
+ LockedResourceQueue& textureUploadedQ )
{
RenderManager* manager = new RenderManager;
- manager->mImpl = new Impl( glAbstraction, glSyncAbstraction, resourcePostProcessQ, *manager );
+ manager->mImpl = new Impl( glAbstraction, glSyncAbstraction, textureUploadedQ, *manager );
return manager;
}
}
}
-void RenderManager::DispatchPostProcessRequest(ResourcePostProcessRequest& request)
+void RenderManager::DispatchTextureUploaded(ResourceId request)
{
- mImpl->resourcePostProcessQueue[ mImpl->renderBufferIndex ].push_back( request );
+ mImpl->textureUploadedQueue.PushBack( request );
}
void RenderManager::SetShaderSaver( ShaderSaver& upstream )
}
}
- // check if anything has been posted to the update thread
- bool updateRequired = !mImpl->resourcePostProcessQueue[ mImpl->renderBufferIndex ].empty();
-
//Notify RenderGeometries that rendering has finished
for ( RenderGeometryOwnerIter iter = mImpl->renderGeometryContainer.Begin(); iter != mImpl->renderGeometryContainer.End(); ++iter )
{
DALI_PRINT_RENDER_END();
- return updateRequired;
+ // check if anything has been posted to the update thread, if IsEmpty then no update required.
+ return !mImpl->textureUploadedQueue.IsEmpty();
}
void RenderManager::DoRender( RenderInstruction& instruction, Shader& defaultShader )
// INTERNAL INCLUDES
#include <dali/public-api/math/rect.h>
#include <dali/internal/common/shader-saver.h>
-#include <dali/internal/render/common/post-process-resource-dispatcher.h>
#include <dali/internal/update/resources/resource-manager-declarations.h>
+#include <dali/internal/render/common/texture-uploaded-dispatcher.h>
#include <dali/internal/render/gl-resources/gpu-buffer.h>
#include <dali/internal/render/renderers/render-property-buffer.h>
* RenderManager is responsible for rendering the result of the previous "update", which
* is provided in a RenderCommand during UpdateManager::Update().
*/
-class RenderManager : public PostProcessResourceDispatcher
+class RenderManager : public TextureUploadedDispatcher
{
public:
*/
static RenderManager* New( Integration::GlAbstraction& glAbstraction,
Integration::GlSyncAbstraction& glSyncAbstraction,
- ResourcePostProcessList& resourcePostProcessQueue );
+ LockedResourceQueue& resourcePostProcessQueue );
/**
* Non-virtual destructor; not intended as a base class
/**
* Dispatch requests onto the postProcessResourcesQueue
- * @param[in] request The request to dispatch
+ * @param[in] resource The Id of the resource to dispatch
*/
- virtual void DispatchPostProcessRequest( ResourcePostProcessRequest& request );
+ virtual void DispatchTextureUploaded( ResourceId resource );
/**
* Set the upstream interface for compiled shader binaries to be sent back to for eventual
*
*/
+// INTERNAL INCLUDES
+#include <dali/integration-api/resource-declarations.h>
+
namespace Dali
{
namespace Internal
{
-struct ResourcePostProcessRequest;
+typedef Integration::ResourceId ResourceId;
namespace SceneGraph
{
/**
- * Interface which offers a dispatch mechanism for post process requests on resources
+ * Interface which offers a dispatch mechanism for uploaded notifications on textures
* Should be offered by a Render Thread object
*/
-class PostProcessResourceDispatcher
+class TextureUploadedDispatcher
{
public:
/**
- * Dispatch a post process resource request to the Update thread
- * @param[in] request A post process request
+ * Dispatch a post process resource uploaded request to the Update thread
+ * @param[in] resource A post process request
*/
- virtual void DispatchPostProcessRequest(ResourcePostProcessRequest& request) = 0;
+ virtual void DispatchTextureUploaded( ResourceId resource ) = 0;
protected:
/**
* Virtual destructor
*/
- virtual ~PostProcessResourceDispatcher(){}
+ virtual ~TextureUploadedDispatcher(){}
};
*
*/
-#include <dali/internal/render/gl-resources/texture-cache.h>
-
+#include <dali/integration-api/debug.h>
#include <dali/integration-api/bitmap.h>
-
-#include <dali/internal/update/resources/resource-manager-declarations.h>
-#include <dali/internal/render/common/post-process-resource-dispatcher.h>
+#include <dali/internal/render/common/texture-uploaded-dispatcher.h>
#include <dali/internal/render/queue/render-queue.h>
#include <dali/internal/render/gl-resources/context.h>
#include <dali/internal/render/gl-resources/texture-factory.h>
#include <dali/internal/render/gl-resources/texture.h>
+#include <dali/internal/render/gl-resources/texture-cache.h>
#include <dali/internal/render/gl-resources/texture-observer.h>
#include <dali/internal/render/gl-resources/bitmap-texture.h>
#include <dali/internal/render/gl-resources/native-texture.h>
#include <dali/internal/render/gl-resources/frame-buffer-texture.h>
-
-#include <dali/integration-api/debug.h>
+#include <dali/internal/update/resources/resource-manager-declarations.h>
using Dali::Internal::Texture;
using Dali::Internal::FrameBufferTexture;
}
TextureCache::TextureCache( RenderQueue& renderQueue,
- PostProcessResourceDispatcher& postProcessResourceDispatcher,
+ TextureUploadedDispatcher& postProcessResourceDispatcher,
Context& context)
: TextureCacheDispatcher(renderQueue),
- mPostProcessResourceDispatcher(postProcessResourceDispatcher),
+ mTextureUploadedDispatcher(postProcessResourceDispatcher),
mContext(context),
mDiscardBitmapsPolicy(ResourcePolicy::OWNED_DISCARD)
{
{
texturePtr->Update( bitmap.Get() );
- ResourcePostProcessRequest ppRequest( id, ResourcePostProcessRequest::UPLOADED );
- mPostProcessResourceDispatcher.DispatchPostProcessRequest(ppRequest);
+ ResourceId ppRequest( id );
+ mTextureUploadedDispatcher.DispatchTextureUploaded(ppRequest);
}
}
}
{
texturePtr->Update( bitmap.Get(), xOffset, yOffset );
- ResourcePostProcessRequest ppRequest( id, ResourcePostProcessRequest::UPLOADED );
- mPostProcessResourceDispatcher.DispatchPostProcessRequest(ppRequest);
+ ResourceId ppRequest( id );
+ mTextureUploadedDispatcher.DispatchTextureUploaded(ppRequest);
}
}
}
{
texturePtr->Update( pixelData.Get(), xOffset, yOffset );
- ResourcePostProcessRequest ppRequest( id, ResourcePostProcessRequest::UPLOADED );
- mPostProcessResourceDispatcher.DispatchPostProcessRequest(ppRequest);
+ ResourceId ppRequest( id );
+ mTextureUploadedDispatcher.DispatchTextureUploaded(ppRequest);
}
}
}
{
texturePtr->UpdateArea( area );
- ResourcePostProcessRequest ppRequest( id, ResourcePostProcessRequest::UPLOADED );
- mPostProcessResourceDispatcher.DispatchPostProcessRequest(ppRequest);
+ ResourceId ppRequest( id );
+ mTextureUploadedDispatcher.DispatchTextureUploaded(ppRequest);
}
}
}
mObservers.erase( observersIter );
}
}
-
- // Tell resource manager
- ResourcePostProcessRequest ppRequest( id, ResourcePostProcessRequest::DELETED );
- mPostProcessResourceDispatcher.DispatchPostProcessRequest(ppRequest);
}
}
bool created = texture->Bind(target, textureunit);
if( created && texture->UpdateOnCreate() ) // i.e. the pixel data was sent to GL
{
- ResourcePostProcessRequest ppRequest( id, ResourcePostProcessRequest::UPLOADED );
- mPostProcessResourceDispatcher.DispatchPostProcessRequest(ppRequest);
+ ResourceId ppRequest( id );
+ mTextureUploadedDispatcher.DispatchTextureUploaded(ppRequest);
}
}
namespace SceneGraph
{
class RenderQueue;
-class PostProcessResourceDispatcher;
+class TextureUploadedDispatcher;
typedef std::map<ResourceId, TexturePointer > TextureContainer;
typedef std::pair<ResourceId, TexturePointer > TexturePair;
* @param[in] context GL Context
*/
TextureCache( RenderQueue& renderQueue,
- PostProcessResourceDispatcher& postProcessDispatcher,
+ TextureUploadedDispatcher& postProcessDispatcher,
Context& context );
/**
private:
- PostProcessResourceDispatcher& mPostProcessResourceDispatcher;
+ TextureUploadedDispatcher& mTextureUploadedDispatcher;
Context& mContext;
TextureContainer mTextures;
TextureContainer mFramebufferTextures;
// INTERNAL INCLUDES
#include <dali/integration-api/gl-defines.h>
#include <dali/internal/common/shader-saver.h>
-#include <dali/internal/update/resources/resource-manager-declarations.h>
-#include <dali/internal/render/shaders/program.h>
-#include <dali/internal/render/common/post-process-resource-dispatcher.h>
+#include <dali/internal/render/common/texture-uploaded-dispatcher.h>
#include <dali/internal/render/gl-resources/gl-call-debug.h>
+#include <dali/internal/render/shaders/program.h>
+#include <dali/internal/update/resources/resource-manager-declarations.h>
namespace Dali
{
*/
// INTERNAL INCLUDES
+#include <dali/devel-api/threading/mutex.h>
#include <dali/integration-api/resource-cache.h>
#include <dali/internal/update/common/double-buffered.h>
+#include <dali/public-api/common/dali-vector.h>
namespace Dali
{
* Post processing required on the resource after the resource has been modified by the render thread
* Should only be handled by update thread
*/
-struct ResourcePostProcessRequest
+
+typedef Dali::Vector< ResourceId > TextureUploadedQueue;
+
+class LockedResourceQueue
{
- enum PostProcess
+
+public:
+ void PushBack( ResourceId request )
{
- UPLOADED,
- DELETED
- };
+ Dali::Mutex::ScopedLock lock( mMutex );
+ mQueue.PushBack( request );
+ }
- ResourceId id;
- PostProcess postProcess;
+ bool IsEmpty() const
+ {
+ Dali::Mutex::ScopedLock lock( mMutex );
+ return mQueue.Empty();
+ }
- ResourcePostProcessRequest( ResourceId anId, PostProcess aPostProcess )
- : id(anId), postProcess(aPostProcess)
+ void SwapQueue( TextureUploadedQueue& list )
{
+ Dali::Mutex::ScopedLock lock( mMutex );
+ list.Clear();
+ mQueue.Swap( list );
}
+
+private:
+
+ TextureUploadedQueue mQueue;
+ mutable Dali::Mutex mMutex;
};
-typedef SceneGraph::DoubleBuffered<std::vector< ResourcePostProcessRequest> > ResourcePostProcessList;
} // Internal
} // Dali
#include <dali/internal/render/queue/render-queue.h>
#include <dali/internal/render/common/texture-cache-dispatcher.h>
-#include <dali/internal/render/common/post-process-resource-dispatcher.h>
using namespace Dali::Integration;
ResourceManagerImpl( PlatformAbstraction& platformAbstraction,
NotificationManager& notificationManager,
SceneGraph::TextureCacheDispatcher& textureCacheDispatcher,
- ResourcePostProcessList& resourcePostProcessQueue,
- SceneGraph::PostProcessResourceDispatcher& postProcessResourceDispatcher,
+ LockedResourceQueue& textureUploadedQueue,
DiscardQueue& discardQueue,
RenderQueue& renderQueue )
: mPlatformAbstraction(platformAbstraction),
mNotificationManager(notificationManager),
mResourceClient(NULL),
mTextureCacheDispatcher(textureCacheDispatcher),
- mResourcePostProcessQueue(resourcePostProcessQueue),
- mPostProcessResourceDispatcher(postProcessResourceDispatcher),
+ mTextureUploadedQueue(textureUploadedQueue),
+ mTextureUploadedProcessingQueue(),
mDiscardQueue(discardQueue),
mRenderQueue(renderQueue),
mNotificationCount(0),
{
}
- PlatformAbstraction& mPlatformAbstraction;
- NotificationManager& mNotificationManager;
- ResourceClient* mResourceClient; // (needs to be a ptr - it's not instantiated yet)
- TextureCacheDispatcher& mTextureCacheDispatcher;
- ResourcePostProcessList& mResourcePostProcessQueue;
- SceneGraph::PostProcessResourceDispatcher& mPostProcessResourceDispatcher;
- DiscardQueue& mDiscardQueue; ///< Unwanted resources are added here during UpdateCache()
- RenderQueue& mRenderQueue;
- unsigned int mNotificationCount;
- bool cacheUpdated; ///< returned by UpdateCache(). Set true in NotifyTickets to indicate a change in a resource
+ PlatformAbstraction& mPlatformAbstraction;
+ NotificationManager& mNotificationManager;
+ ResourceClient* mResourceClient; // (needs to be a ptr - it's not instantiated yet)
+ TextureCacheDispatcher& mTextureCacheDispatcher;
+ LockedResourceQueue& mTextureUploadedQueue;
+ TextureUploadedQueue mTextureUploadedProcessingQueue;
+ DiscardQueue& mDiscardQueue; ///< Unwanted resources are added here during UpdateCache()
+ RenderQueue& mRenderQueue;
+ unsigned int mNotificationCount;
+ bool cacheUpdated; ///< returned by UpdateCache(). Set true in NotifyTickets to indicate a change in a resource
/**
* These containers are used to processs requests, and ResourceCache callbacks.
ResourceManager::ResourceManager( PlatformAbstraction& platformAbstraction,
NotificationManager& notificationManager,
TextureCacheDispatcher& textureCacheDispatcher,
- ResourcePostProcessList& resourcePostProcessQueue,
- SceneGraph::PostProcessResourceDispatcher& postProcessResourceDispatcher,
+ LockedResourceQueue& resourcePostProcessQueue,
DiscardQueue& discardQueue,
RenderQueue& renderQueue )
{
notificationManager,
textureCacheDispatcher,
resourcePostProcessQueue,
- postProcessResourceDispatcher,
discardQueue,
renderQueue );
}
DALI_ASSERT_DEBUG( mImpl->mResourceClient != NULL );
DALI_LOG_INFO(Debug::Filter::gResource, Debug::Verbose, "ResourceManager: PostProcessResources()\n");
- unsigned int numIds = mImpl->mResourcePostProcessQueue[ updateBufferIndex ].size();
+ mImpl->mTextureUploadedQueue.SwapQueue( mImpl->mTextureUploadedProcessingQueue );
+
+ unsigned int numIds = mImpl->mTextureUploadedProcessingQueue.Size();
unsigned int i;
// process the list where RenderManager put post process requests
- for (i = 0; i < numIds; ++i)
+ for ( i = 0; i < numIds; ++i )
{
- ResourcePostProcessRequest ppRequest = mImpl->mResourcePostProcessQueue[ updateBufferIndex ][i];
- switch(ppRequest.postProcess)
- {
- case ResourcePostProcessRequest::UPLOADED:
- {
- SendToClient( UploadedMessage( *mImpl->mResourceClient, ppRequest.id ) );
- break;
- }
- case ResourcePostProcessRequest::DELETED:
- {
- // TextureObservers handled in TextureCache
- break;
- }
- }
+ ResourceId resourceId = mImpl->mTextureUploadedProcessingQueue[i];
+ SendToClient( UploadedMessage( *mImpl->mResourceClient, resourceId ) );
}
-
- mImpl->mResourcePostProcessQueue[ updateBufferIndex ].clear();
}
class DiscardQueue;
class RenderQueue;
class TextureCacheDispatcher;
-class PostProcessResourceDispatcher;
}
class NotificationManager;
* There should exactly one of these objects per Dali Core.
* @param[in] platformAbstraction Used to request resources from the native filesystem.
* @param[in] notificationManager Used to send NotifyTickets message.
- * @param[in] postProcessResourcesQueue Used for performing post processing on resources
+ * @param[in] textureUploadedProcessResourcesQueue Used for performing post processing on resources
* @param[in] discardQueue Used to cleanup nodes & resources when no longer in use.
* @param[in] renderQueue Used to queue resource updates until the next Render.
*/
ResourceManager( Integration::PlatformAbstraction& platformAbstraction,
NotificationManager& notificationManager,
SceneGraph::TextureCacheDispatcher& textureCacheDispatcher,
- ResourcePostProcessList& postProcessResourcesQueue,
- SceneGraph::PostProcessResourceDispatcher& postProcessResourceDispatcher,
+ LockedResourceQueue& textureUploadedProcessResourcesQueue,
SceneGraph::DiscardQueue& discardQueue,
SceneGraph::RenderQueue& renderQueue );
projects / platform / core / uifw / dali-core.git / commitdiff