X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fcommon%2Fcore-impl.cpp;h=8f07f3594a607ffbf12b27e322a545130b7525b7;hb=40ddb0164aa0c1849826125530fdaca115389a7e;hp=91559e7c1faefa4e3695864d1af7c9e45fcbd59e;hpb=27619bbc4c1d443e89a6cdd116e544f6d9657fa4;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/common/core-impl.cpp b/dali/internal/common/core-impl.cpp index 91559e7..8f07f35 100644 --- a/dali/internal/common/core-impl.cpp +++ b/dali/internal/common/core-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2016 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,33 +21,34 @@ // INTERNAL INCLUDES #include #include -#include +#include +#include #include +#include #include + #include -#include #include -#include #include -#include +#include +#include +#include +#include +#include #include #include -#include -#include -#include +#include +#include +#include + #include -#include -#include +#include +#include +#include #include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include #include #include @@ -56,9 +57,17 @@ 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 +{ // The Update for frame N+1 may be processed whilst frame N is being rendered. -static const unsigned int MAXIMUM_UPDATE_COUNT = 2u; +const unsigned int MAXIMUM_UPDATE_COUNT = 2u; + +#if defined(DEBUG_ENABLED) +Debug::Filter* gCoreFilter = Debug::Filter::New(Debug::Concise, false, "LOG_CORE"); +#endif +} namespace Dali { @@ -77,7 +86,7 @@ using Integration::RenderStatus; Core::Core( RenderController& renderController, PlatformAbstraction& platform, GlAbstraction& glAbstraction, GlSyncAbstraction& glSyncAbstraction, - GestureManager& gestureManager) + GestureManager& gestureManager, ResourcePolicy::DataRetention dataRetentionPolicy) : mRenderController( renderController ), mPlatform(platform), mGestureEventProcessor(NULL), @@ -85,14 +94,10 @@ Core::Core( RenderController& renderController, PlatformAbstraction& platform, mUpdateManager(NULL), mRenderManager(NULL), mDiscardQueue(NULL), - mResourcePostProcessQueue(), + mTextureUploadedQueue(), mNotificationManager(NULL), - mFrameTime(NULL), - mFontFactory(NULL), mImageFactory(NULL), - mModelFactory(NULL), mShaderFactory(NULL), - mEmojiFactory(NULL), mIsActive(true), mProcessingEvent(false) { @@ -108,27 +113,34 @@ Core::Core( RenderController& renderController, PlatformAbstraction& platform, mPropertyNotificationManager = PropertyNotificationManager::New(); - std::vector< ResourcePostProcessRequest> init; - mResourcePostProcessQueue = new ResourcePostProcessList(init); + mTextureUploadedQueue = new LockedResourceQueue; - mRenderManager = RenderManager::New( glAbstraction, *mResourcePostProcessQueue ); + mRenderManager = RenderManager::New( glAbstraction, glSyncAbstraction, *mTextureUploadedQueue ); + + mRenderTaskProcessor = new SceneGraph::RenderTaskProcessor(); 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, - textureCache, - *mResourcePostProcessQueue, - *mRenderManager, + *mTextureCacheDispatcher, + *mTextureUploadedQueue, *mDiscardQueue, renderQueue ); - mTouchResampler = TouchResampler::New(); - mUpdateManager = new UpdateManager( *mNotificationManager, - glSyncAbstraction, *mAnimationPlaylist, *mPropertyNotificationManager, *mResourceManager, @@ -136,27 +148,27 @@ Core::Core( RenderController& renderController, PlatformAbstraction& platform, renderController, *mRenderManager, renderQueue, - textureCache, - *mTouchResampler ); + *mTextureCacheDispatcher, + *mRenderTaskProcessor ); - mResourceClient = new ResourceClient( *mResourceManager, *mUpdateManager ); + mRenderManager->SetShaderSaver( *mUpdateManager ); mStage = IntrusivePtr( Stage::New( *mAnimationPlaylist, *mPropertyNotificationManager, *mUpdateManager, *mNotificationManager ) ); + // This must be called after stage is created but before stage initialization + mRelayoutController = IntrusivePtr< RelayoutController >( new RelayoutController( mRenderController ) ); + mStage->Initialize(); - mUpdateManager->SetRenderTaskList( &mStage->GetRenderTaskList() ); + mResourceClient = new ResourceClient( *mResourceManager, *mStage ); mGestureEventProcessor = new GestureEventProcessor(*mStage, gestureManager, mRenderController); mEventProcessor = new EventProcessor(*mStage, *mNotificationManager, *mGestureEventProcessor); - mFrameTime = new FrameTime( mPlatform ); - mFontFactory = new FontFactory(*mResourceClient); mImageFactory = new ImageFactory( *mResourceClient ); - mModelFactory = new ModelFactory(*mResourceClient); - mShaderFactory = new ShaderFactory(*mResourceClient); + mShaderFactory = new ShaderFactory(); + mUpdateManager->SetShaderSaver( *mShaderFactory ); mShaderFactory->LoadDefaultShaders(); - mEmojiFactory = new EmojiFactory(); GetImplementation(Dali::TypeRegistry::Get()).CallInitFunctions(); } @@ -176,7 +188,15 @@ Core::~Core() // clear the thread local storage first // allows core to be created / deleted many times in the same thread (how TET cases work). // Do this before mStage.Reset() so Stage::IsInstalled() returns false - ThreadLocalStorage::Get().Remove(); + ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal(); + if( tls ) + { + tls->Remove(); + delete tls; + } + + // Stop relayout requests being raised on stage destruction + mRelayoutController.Reset(); // Clean-up stage - remove default camera and root layer mStage->Uninitialize(); @@ -187,19 +207,29 @@ Core::~Core() delete mEventProcessor; delete mGestureEventProcessor; delete mNotificationManager; - delete mFontFactory; delete mImageFactory; - delete mModelFactory; delete mShaderFactory; delete mResourceClient; delete mResourceManager; + delete mDiscardQueue; + delete mTextureCacheDispatcher; delete mUpdateManager; - delete mTouchResampler; - delete mEmojiFactory; delete mRenderManager; - delete mDiscardQueue; - delete mResourcePostProcessQueue; - delete mFrameTime; + delete mRenderTaskProcessor; + delete mTextureUploadedQueue; +} + +Integration::ContextNotifierInterface* Core::GetContextNotifier() +{ + return mStage.Get(); +} + +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 } void Core::ContextCreated() @@ -207,55 +237,51 @@ void Core::ContextCreated() mRenderManager->ContextCreated(); } -void Core::ContextToBeDestroyed() +void Core::ContextDestroyed() { mRenderManager->ContextDestroyed(); } -void Core::SurfaceResized(unsigned int width, unsigned int height) +void Core::SurfaceResized( unsigned int width, unsigned int height ) { - mStage->SetSize(width, height); + mStage->SurfaceResized( width, height ); + + // The stage-size may be less than surface-size (reduced by top-margin) + Vector2 size = mStage->GetSize(); + mRelayoutController->SetStageSize( size.width, size.height ); } -void Core::SetDpi(unsigned int dpiHorizontal, unsigned int dpiVertical) +void Core::SetTopMargin( unsigned int margin ) { - mPlatform.SetDpi( dpiHorizontal, dpiVertical ); - mFontFactory->SetDpi( dpiHorizontal, dpiVertical); - mStage->SetDpi( Vector2( dpiHorizontal , dpiVertical) ); + mStage->SetTopMargin( margin ); + + // The stage-size may be less than surface-size (reduced by top-margin) + Vector2 size = mStage->GetSize(); + mRelayoutController->SetStageSize( size.width, size.height ); } -void Core::SetMinimumFrameTimeInterval(unsigned int interval) +void Core::SetDpi( unsigned int dpiHorizontal, unsigned int dpiVertical ) { - mFrameTime->SetMinimumFrameTimeInterval(interval); + mStage->SetDpi( Vector2( dpiHorizontal , dpiVertical) ); } -void Core::Update( UpdateStatus& status ) +void Core::Update( float elapsedSeconds, unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds, Integration::UpdateStatus& status ) { - // get the last delta and the predict when this update will be rendered - float lastFrameDelta( 0.0f ); - unsigned int lastVSyncTime( 0 ); - unsigned int nextVSyncTime( 0 ); - mFrameTime->PredictNextVSyncTime( lastFrameDelta, lastVSyncTime, nextVSyncTime ); - // set the time delta so adaptor can easily print FPS with a release build with 0 as // it is cached by frametime - status.secondsFromLastFrame = lastFrameDelta; + status.secondsFromLastFrame = elapsedSeconds; // Render returns true when there are updates on the stage or one or more animations are completed. // Use the estimated time diff till we render as the elapsed time. - status.keepUpdating = mUpdateManager->Update( lastFrameDelta, lastVSyncTime, nextVSyncTime ); + status.keepUpdating = mUpdateManager->Update( elapsedSeconds, + lastVSyncTimeMilliseconds, + nextVSyncTimeMilliseconds ); // Check the Notification Manager message queue to set needsNotification status.needsNotification = mNotificationManager->MessagesToProcess(); - // If there are notifications to process keep the update thread running as well. - // A notification event might add a new actor or animation to the stage which needs - // update thread to process it. This also prevents update thread from sleeping - // while actor thread is still processing events. - if ( status.needsNotification ) - { - status.keepUpdating |= Integration::KeepUpdating::NOTIFICATIONS_PENDING; - } + // No need to keep update running if there are notifications to process. + // Any message to update will wake it up anyways if ( mResourceManager->ResourcesToProcess() ) { @@ -273,11 +299,6 @@ void Core::Render( RenderStatus& status ) void Core::Suspend() { - if( mFrameTime ) - { - mFrameTime->Suspend(); - } - mPlatform.Suspend(); mIsActive = false; @@ -285,11 +306,6 @@ void Core::Suspend() void Core::Resume() { - if( mFrameTime ) - { - mFrameTime->Resume(); - } - mPlatform.Resume(); mIsActive = true; @@ -298,26 +314,11 @@ void Core::Resume() ProcessEvents(); } -void Core::Sleep() +void Core::SceneCreated() { - if( mFrameTime ) - { - mFrameTime->Sleep(); - } -} - -void Core::WakeUp() -{ - if( mFrameTime ) - { - mFrameTime->WakeUp(); - } -} + mStage->EmitSceneCreatedSignal(); -void Core::VSync( unsigned int frameNumber, unsigned int seconds, unsigned int microseconds ) -{ - // Can't use passed in time as that is not the clock the touch events use so our predicted render value will be meaningless. - mFrameTime->SetVSyncTime( frameNumber ); + mRelayoutController->OnApplicationSceneCreated(); } void Core::QueueEvent( const Integration::Event& event ) @@ -330,17 +331,16 @@ void Core::ProcessEvents() // Guard against calls to ProcessEvents() during ProcessEvents() if( mProcessingEvent ) { - DALI_LOG_ERROR( "ProcessEvents should not be called from within ProcessEvents!" ); + DALI_LOG_ERROR( "ProcessEvents should not be called from within ProcessEvents!\n" ); mRenderController.RequestProcessEventsOnIdle(); return; } mProcessingEvent = true; - - EventToUpdate& eventToUpdate = mUpdateManager->GetEventToUpdate(); + mRelayoutController->SetProcessingCoreEvents( true ); // Signal that any messages received will be flushed soon - eventToUpdate.EventProcessingStarted(); + mUpdateManager->EventProcessingStarted(); mEventProcessor->ProcessEvents(); @@ -352,35 +352,31 @@ void Core::ProcessEvents() // Emit signal here to start size negotiation and control relayout. mStage->EmitEventProcessingFinishedSignal(); + // Run the size negotiation after event processing finished signal + mRelayoutController->Relayout(); + // Flush discard queue for image factory mImageFactory->FlushReleaseQueue(); - // send text requests if required - mFontFactory->SendTextRequests(); - // Flush any queued messages for the update-thread - const bool messagesToProcess = eventToUpdate.FlushQueue(); + const bool messagesToProcess = mUpdateManager->FlushQueue(); // Check if the touch or gestures require updates. - const bool touchNeedsUpdate = mTouchResampler->NeedsUpdate(); const bool gestureNeedsUpdate = mGestureEventProcessor->NeedsUpdate(); - if( messagesToProcess || touchNeedsUpdate || gestureNeedsUpdate ) + if( messagesToProcess || gestureNeedsUpdate ) { // tell the render controller to keep update thread running mRenderController.RequestUpdate(); } } + mRelayoutController->SetProcessingCoreEvents( false ); + // ProcessEvents() may now be called again mProcessingEvent = false; } -void Core::UpdateTouchData(const Integration::TouchData& touch) -{ - mTouchResampler->SendTouchData( touch ); -} - unsigned int Core::GetMaximumUpdateCount() const { return MAXIMUM_UPDATE_COUNT; @@ -446,21 +442,11 @@ ResourceClient& Core::GetResourceClient() return *(mResourceClient); } -FontFactory& Core::GetFontFactory() -{ - return *(mFontFactory); -} - ImageFactory& Core::GetImageFactory() { return *(mImageFactory); } -ModelFactory& Core::GetModelFactory() -{ - return *(mModelFactory); -} - ShaderFactory& Core::GetShaderFactory() { return *(mShaderFactory); @@ -471,15 +457,15 @@ GestureEventProcessor& Core::GetGestureEventProcessor() return *(mGestureEventProcessor); } -EmojiFactory& Core::GetEmojiFactory() +RelayoutController& Core::GetRelayoutController() { - return *mEmojiFactory; + return *(mRelayoutController.Get()); } 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); }