Removed redundant resource loading & rendering code

[platform/core/uifw/dali-core.git] / dali / internal / common / core-impl.cpp

diff --git a/dali/internal/common/core-impl.cpp b/dali/internal/common/core-impl.cpp
index c9a810c..dccaacf 100644 (file)
--- a/dali/internal/common/core-impl.cpp
+++ b/dali/internal/common/core-impl.cpp
@@ -37,28 +37,21 @@
 #include <dali/internal/event/effects/shader-factory.h>
 #include <dali/internal/event/events/event-processor.h>
 #include <dali/internal/event/events/gesture-event-processor.h>
-#include <dali/internal/event/images/image-factory.h>
 #include <dali/internal/event/render-tasks/render-task-list-impl.h>
 #include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
 
 #include <dali/internal/update/common/discard-queue.h>
-#include <dali/internal/update/common/texture-cache-dispatcher.h>
 #include <dali/internal/update/manager/update-manager.h>
-#include <dali/internal/update/manager/geometry-batcher.h>
 #include <dali/internal/update/manager/render-task-processor.h>
-#include <dali/internal/update/resources/resource-manager.h>
 
 #include <dali/internal/render/common/performance-monitor.h>
 #include <dali/internal/render/common/render-manager.h>
-#include <dali/internal/render/gl-resources/texture-cache.h>
 #include <dali/internal/render/gl-resources/context.h>
 
 using Dali::Internal::SceneGraph::UpdateManager;
 using Dali::Internal::SceneGraph::RenderManager;
 using Dali::Internal::SceneGraph::DiscardQueue;
 using Dali::Internal::SceneGraph::RenderQueue;
-using Dali::Internal::SceneGraph::TextureCache;
-using Dali::Internal::SceneGraph::TextureCacheDispatcher;
 
 namespace
 {
@@ -95,11 +88,8 @@ Core::Core( RenderController& renderController, PlatformAbstraction& platform,
   mUpdateManager(NULL),
   mRenderManager(NULL),
   mDiscardQueue(NULL),
-  mTextureUploadedQueue(),
   mNotificationManager(NULL),
-  mImageFactory(NULL),
   mShaderFactory(NULL),
-  mGeometryBatcher( NULL ),
   mIsActive(true),
   mProcessingEvent(false)
 {
@@ -115,45 +105,21 @@ Core::Core( RenderController& renderController, PlatformAbstraction& platform,
 
   mPropertyNotificationManager = PropertyNotificationManager::New();
 
-  mTextureUploadedQueue = new LockedResourceQueue;
-
-  mGeometryBatcher = new SceneGraph::GeometryBatcher();
-
   mRenderTaskProcessor = new SceneGraph::RenderTaskProcessor();
 
-  mRenderManager = RenderManager::New( glAbstraction, glSyncAbstraction, *mGeometryBatcher, *mTextureUploadedQueue );
+  mRenderManager = RenderManager::New( glAbstraction, glSyncAbstraction );
 
   RenderQueue& renderQueue = mRenderManager->GetRenderQueue();
-  TextureCache& textureCache = mRenderManager->GetTextureCache();
-
-  ResourcePolicy::Discardable discardPolicy = ResourcePolicy::OWNED_DISCARD;
-  if( dataRetentionPolicy == ResourcePolicy::DALI_RETAINS_ALL_DATA )
-  {
-    discardPolicy = ResourcePolicy::OWNED_RETAIN;
-  }
-  textureCache.SetDiscardBitmapsPolicy(discardPolicy);
-
-  mTextureCacheDispatcher = new SceneGraph::TextureCacheDispatcher( renderQueue, textureCache );
 
   mDiscardQueue = new DiscardQueue( renderQueue );
 
-  mResourceManager = new ResourceManager(  mPlatform,
-                                          *mNotificationManager,
-                                          *mTextureCacheDispatcher,
-                                          *mTextureUploadedQueue,
-                                          *mDiscardQueue,
-                                           renderQueue );
-
   mUpdateManager = new UpdateManager( *mNotificationManager,
                                       *mAnimationPlaylist,
                                       *mPropertyNotificationManager,
-                                      *mResourceManager,
                                       *mDiscardQueue,
                                        renderController,
                                       *mRenderManager,
                                        renderQueue,
-                                      *mTextureCacheDispatcher,
-                                      *mGeometryBatcher,
                                       *mRenderTaskProcessor );
 
   mRenderManager->SetShaderSaver( *mUpdateManager );
@@ -165,12 +131,9 @@ Core::Core( RenderController& renderController, PlatformAbstraction& platform,
 
   mStage->Initialize();
 
-  mResourceClient = new ResourceClient( *mResourceManager, *mStage );
-
   mGestureEventProcessor = new GestureEventProcessor(*mStage, gestureManager, mRenderController);
   mEventProcessor = new EventProcessor(*mStage, *mNotificationManager, *mGestureEventProcessor);
 
-  mImageFactory = new ImageFactory( *mResourceClient );
   mShaderFactory = new ShaderFactory();
   mUpdateManager->SetShaderSaver( *mShaderFactory );
 
@@ -179,12 +142,6 @@ Core::Core( RenderController& renderController, PlatformAbstraction& platform,
 
 Core::~Core()
 {
-  /**
-   * TODO this should be done by Adaptor, Core does not know about threading
-   * First stop the resource loading thread(s)
-   */
-  mPlatform.JoinLoaderThreads();
-
   /*
    * The order of destructing these singletons is important!!!
    */
@@ -196,6 +153,7 @@ Core::~Core()
   if( tls )
   {
     tls->Remove();
+    delete tls;
   }
 
   // Stop relayout requests being raised on stage destruction
@@ -210,17 +168,11 @@ Core::~Core()
   delete mEventProcessor;
   delete mGestureEventProcessor;
   delete mNotificationManager;
-  delete mImageFactory;
   delete mShaderFactory;
-  delete mResourceClient;
-  delete mResourceManager;
   delete mDiscardQueue;
-  delete mTextureCacheDispatcher;
   delete mUpdateManager;
   delete mRenderManager;
   delete mRenderTaskProcessor;
-  delete mGeometryBatcher;
-  delete mTextureUploadedQueue;
 }
 
 Integration::ContextNotifierInterface* Core::GetContextNotifier()
@@ -232,7 +184,6 @@ void Core::RecoverFromContextLoss()
 {
   DALI_LOG_INFO(gCoreFilter, Debug::Verbose, "Core::RecoverFromContextLoss()\n");
 
-  mImageFactory->RecoverFromContextLoss(); // Reload images from files
   mStage->GetRenderTaskList().RecoverFromContextLoss(); // Re-trigger render-tasks
 }
 
@@ -286,12 +237,6 @@ void Core::Update( float elapsedSeconds, unsigned int lastVSyncTimeMilliseconds,
 
   // No need to keep update running if there are notifications to process.
   // Any message to update will wake it up anyways
-
-  if ( mResourceManager->ResourcesToProcess() )
-  {
-    // If we are still processing resources, then we have to continue the update
-    status.keepUpdating |= Integration::KeepUpdating::LOADING_RESOURCES;
-  }
 }
 
 void Core::Render( RenderStatus& status )
@@ -303,15 +248,11 @@ void Core::Render( RenderStatus& status )
 
 void Core::Suspend()
 {
-  mPlatform.Suspend();
-
   mIsActive = false;
 }
 
 void Core::Resume()
 {
-  mPlatform.Resume();
-
   mIsActive = true;
 
   // trigger processing of events queued up while paused
@@ -359,9 +300,6 @@ void Core::ProcessEvents()
     // Run the size negotiation after event processing finished signal
     mRelayoutController->Relayout();
 
-    // Flush discard queue for image factory
-    mImageFactory->FlushReleaseQueue();
-
     // Flush any queued messages for the update-thread
     const bool messagesToProcess = mUpdateManager->FlushQueue();
 
@@ -436,21 +374,6 @@ NotificationManager& Core::GetNotificationManager()
   return *(mNotificationManager);
 }
 
-ResourceManager& Core::GetResourceManager()
-{
-  return *(mResourceManager);
-}
-
-ResourceClient& Core::GetResourceClient()
-{
-  return *(mResourceClient);
-}
-
-ImageFactory& Core::GetImageFactory()
-{
-  return *(mImageFactory);
-}
-
 ShaderFactory& Core::GetShaderFactory()
 {
   return *(mShaderFactory);
@@ -469,7 +392,7 @@ RelayoutController& Core::GetRelayoutController()
 void Core::CreateThreadLocalStorage()
 {
   // a pointer to the ThreadLocalStorage object will be stored in TLS
-  // and automatically deleted when the thread is killed
+  // The ThreadLocalStorage object should be deleted by the Core destructor
   new ThreadLocalStorage(this);
 }