X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Frender-tasks%2Fscene-graph-render-task.cpp;h=d4305b97a3001982249ebeed566ff9fded30c87d;hb=4d75040ab200bd306ec5a48f2a617480062eef4c;hp=ce19a81349319f6e9deb1817a36ff254a0d92f56;hpb=5c66381841dd4dfd82c5a118d34104a00a2e0e1c;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/render-tasks/scene-graph-render-task.cpp b/dali/internal/update/render-tasks/scene-graph-render-task.cpp index ce19a81..d4305b9 100644 --- a/dali/internal/update/render-tasks/scene-graph-render-task.cpp +++ b/dali/internal/update/render-tasks/scene-graph-render-task.cpp @@ -1,38 +1,32 @@ -// -// Copyright (c) 2014 Samsung Electronics Co., Ltd. -// -// Licensed under the Flora License, Version 1.0 (the License); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://floralicense.org/license/ -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an AS IS BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// +/* + * Copyright (c) 2018 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ // CLASS HEADER #include // INTERNAL INCLUDES #include -#include -#include +#include #include -#include #include +#include #include -namespace -{ -const unsigned int NUM_FRAMES_BEFORE_NOTIFY_FINISHED(3); -const unsigned int COUNTDOWN_COMPLETE(-1); -} // anonymous namespace - namespace Dali { namespace Internal @@ -56,12 +50,17 @@ RenderTask::~RenderTask() mSourceNode->SetExclusiveRenderTask( NULL ); } } - if( mFrameBufferResourceId ) + if( mRenderSyncTracker ) { - mCompleteStatusManager->StopTrackingResource( mFrameBufferResourceId ); + mRenderMessageDispatcher->RemoveRenderTracker( *mRenderSyncTracker ); } } +void RenderTask::Initialize( RenderMessageDispatcher& renderMessageDispatcher ) +{ + mRenderMessageDispatcher = &renderMessageDispatcher; +} + void RenderTask::SetSourceNode( Node* node ) { // Remove exclusive flag from the old node, if necessary @@ -106,52 +105,20 @@ bool RenderTask::IsExclusive() const return mExclusive; } -void RenderTask::SetCameraNode( Node* cameraNode ) +void RenderTask::SetCamera( Node* cameraNode, Camera* camera ) { - // if camera changed - if( cameraNode != mCameraNode ) - { - if( cameraNode ) - { - // get attachment. when camera node is changed we will get a message from event thread object - // so no need to observe the node here - mCameraAttachment = dynamic_cast< CameraAttachment* >( &cameraNode->GetAttachment() ); - DALI_ASSERT_DEBUG( mCameraAttachment && "Camera without attachment" ); - } - mCameraNode = cameraNode; - } + mCameraNode = cameraNode; + mCamera = camera; } -Node* RenderTask::GetCameraNode() const +void RenderTask::SetFrameBuffer( Render::FrameBuffer* frameBuffer ) { - return mCameraNode; -} - -void RenderTask::SetFrameBufferId( unsigned int resourceId ) -{ - if ( mFrameBufferResourceId != resourceId ) - { - DALI_ASSERT_DEBUG(mCompleteStatusManager && "Complete status tracker is null"); - if( mCompleteStatusManager ) - { - if( resourceId && mState == RENDER_ONCE_WAITING_FOR_RESOURCES ) - { - mCompleteStatusManager->TrackResource( resourceId ); - } - - if( mFrameBufferResourceId ) - { - mCompleteStatusManager->StopTrackingResource( mFrameBufferResourceId ); - } - } - - mFrameBufferResourceId = resourceId; - } + mFrameBuffer = frameBuffer; } -unsigned int RenderTask::GetFrameBufferId() const +Render::FrameBuffer* RenderTask::GetFrameBuffer() { - return mFrameBufferResourceId; + return mFrameBuffer; } bool RenderTask::QueryViewport( BufferIndex bufferIndex, Viewport& viewport ) const @@ -194,6 +161,16 @@ bool RenderTask::GetClearEnabled() const return mClearEnabled; } +void RenderTask::SetCullMode( bool mode ) +{ + mCullMode = mode; +} + +bool RenderTask::GetCullMode() const +{ + return mCullMode; +} + void RenderTask::SetRefreshRate( unsigned int refreshRate ) { DALI_LOG_TRACE_METHOD_FMT(gRenderTaskLogFilter, "this:%p RefreshRate:%d\n", this, refreshRate); @@ -203,31 +180,12 @@ void RenderTask::SetRefreshRate( unsigned int refreshRate ) if( mRefreshRate > 0 ) { mState = RENDER_CONTINUOUSLY; - - if( mFrameBufferResourceId ) - { - // Don't need tracking - DALI_ASSERT_DEBUG(mCompleteStatusManager && "Ready state tracker is null"); - if( mCompleteStatusManager != NULL ) - { - mCompleteStatusManager->StopTrackingResource( mFrameBufferResourceId ); - } - } } else { mState = RENDER_ONCE_WAITING_FOR_RESOURCES; mWaitingToRender = true; mNotifyTrigger = false; - - if( mFrameBufferResourceId ) - { - DALI_ASSERT_DEBUG(mCompleteStatusManager && "Ready state tracker is null"); - if( mCompleteStatusManager != NULL ) - { - mCompleteStatusManager->TrackResource( mFrameBufferResourceId ); - } - } } mFrameCounter = 0u; @@ -240,33 +198,29 @@ unsigned int RenderTask::GetRefreshRate() const bool RenderTask::ReadyToRender( BufferIndex updateBufferIndex ) { - if ( NULL == mSourceNode || - ( !mSourceNode->IsRoot() && NULL == mSourceNode->GetParent() ) ) - { - TASK_LOG_FMT(Debug::General, " =F No source actor FC:%d\n", mFrameCounter ); + // If the source node of the render task is invisible we should still render + // We want the render task to complete and possible clear colors to happen - // Source node is missing or disconnected - return false; - } - - // Check if the source node (root actor) and all its ancestors are visible. - if( !mSourceNode->IsFullyVisible( updateBufferIndex ) ) + // Check the source node. + if( NULL == mSourceNode || + ( !mSourceNode->IsRoot() && NULL == mSourceNode->GetParent() ) ) { - TASK_LOG_FMT(Debug::General, " =F No visible source FC:%d\n", mFrameCounter ); + TASK_LOG_FMT( Debug::General, " Source actor not on stage. Frame counter: %d\n", mFrameCounter ); + + // The source node is missing or disconnected. return false; } - if ( NULL == mCameraNode || - NULL == mCameraNode->GetParent() || - !mCameraNode->HasAttachment() ) + // Check camera node + if( NULL == mCameraNode || + NULL == mCameraNode->GetParent() || + NULL == mCamera ) { - // Camera node is missing or disconnected + // The camera node is missing or disconnected. TASK_LOG_FMT(Debug::General, " =F No Camera FC:%d\n", mFrameCounter ); - return false; } - TASK_LOG_FMT(Debug::General, " =T (FBO ID:%d) FC:%d\n", mFrameBufferResourceId , mFrameCounter ); return true; } @@ -277,16 +231,20 @@ bool RenderTask::IsRenderRequired() switch( mState ) { case RENDER_CONTINUOUSLY: + { required = (mFrameCounter == 0); break; - + } case RENDER_ONCE_WAITING_FOR_RESOURCES: + { required = true; break; - + } default: + { required = false; break; + } } TASK_LOG_FMT( Debug::General, " State:%s = %s\n", STATE_STRING(mState), required?"T":"F" ); @@ -296,9 +254,9 @@ bool RenderTask::IsRenderRequired() // Called every frame regardless of whether render was required. // If render was not required, ignore resourcesFinished. -void RenderTask::UpdateState(bool resourcesFinished) +void RenderTask::UpdateState() { - TASK_LOG_FMT( Debug::General, "(resourcesFinished:%s) FC:%d State:%s RR:%d\n", resourcesFinished?"T":"F", mFrameCounter, STATE_STRING(mState), mRefreshRate ); + TASK_LOG_FMT( Debug::General, "FC:%d State:%s RR:%d\n", mFrameCounter, STATE_STRING(mState), mRefreshRate ); switch( mState ) { @@ -308,12 +266,9 @@ void RenderTask::UpdateState(bool resourcesFinished) { if( mFrameCounter == 0 ) { - if( resourcesFinished ) - { - ++mFrameCounter; // Only start missing frames when resources are loaded - } + ++mFrameCounter; // Only start skipping frames when resources are loaded } - else // Continue counting to miss frames + else // Continue counting to skip frames { ++mFrameCounter; if( mFrameCounter >= mRefreshRate ) @@ -328,29 +283,21 @@ void RenderTask::UpdateState(bool resourcesFinished) case RENDER_ONCE_WAITING_FOR_RESOURCES: { - if( resourcesFinished ) - { - mState = RENDERED_ONCE; - } + mState = RENDERED_ONCE; } break; case RENDERED_ONCE: { - if( mFrameBufferResourceId > 0 ) + mWaitingToRender = true; + mNotifyTrigger = false; + if( mFrameBuffer ) { - // Query if the framebuffer is complete: - DALI_ASSERT_DEBUG(mCompleteStatusManager && "Complete status tracker is null"); - if( mCompleteStatusManager != NULL && - CompleteStatusManager::COMPLETE == mCompleteStatusManager->GetStatus( mFrameBufferResourceId ) ) + if( !mRenderSyncTracker || (mRenderSyncTracker && mRenderSyncTracker->IsSynced() )) { mWaitingToRender = false; mNotifyTrigger = true; } - else - { - mWaitingToRender = true; - } } else { @@ -358,6 +305,7 @@ void RenderTask::UpdateState(bool resourcesFinished) mNotifyTrigger = true; } } + break; default: @@ -396,47 +344,66 @@ unsigned int RenderTask::GetRenderedOnceCounter() const const Matrix& RenderTask::GetViewMatrix( BufferIndex bufferIndex ) const { - DALI_ASSERT_DEBUG( NULL != mCameraAttachment ); + DALI_ASSERT_DEBUG( NULL != mCamera ); - return mCameraAttachment->GetViewMatrix( bufferIndex ); + return mCamera->GetViewMatrix( bufferIndex ); +} + +SceneGraph::Camera& RenderTask::GetCamera() const +{ + DALI_ASSERT_DEBUG( NULL != mCamera ); + return *mCamera; } const Matrix& RenderTask::GetProjectionMatrix( BufferIndex bufferIndex ) const { - DALI_ASSERT_DEBUG( NULL != mCameraAttachment ); + DALI_ASSERT_DEBUG( NULL != mCamera ); - return mCameraAttachment->GetProjectionMatrix( bufferIndex ); + return mCamera->GetProjectionMatrix( bufferIndex ); } void RenderTask::PrepareRenderInstruction( RenderInstruction& instruction, BufferIndex updateBufferIndex ) { + DALI_ASSERT_DEBUG( NULL != mCamera ); + TASK_LOG(Debug::General); Viewport viewport; bool viewportSet = QueryViewport( updateBufferIndex, viewport ); - instruction.Reset( &GetViewMatrix( updateBufferIndex ), - &GetProjectionMatrix( updateBufferIndex ), - GetFrameBufferId(), + instruction.Reset( mCamera, + GetFrameBuffer(), viewportSet ? &viewport : NULL, mClearEnabled ? &GetClearColor( updateBufferIndex ) : NULL ); + + if( mRequiresSync && + mRefreshRate == Dali::RenderTask::REFRESH_ONCE ) + { + // create tracker if one doesn't yet exist. + if( !mRenderSyncTracker ) + { + mRenderSyncTracker = new Render::RenderTracker(); + mRenderMessageDispatcher->AddRenderTracker( *mRenderSyncTracker ); + } + instruction.mRenderTracker = mRenderSyncTracker; + } + else + { + // no sync needed, texture FBOs are "ready" the same frame they are rendered to + instruction.mRenderTracker = NULL; + } } bool RenderTask::ViewMatrixUpdated() { bool retval = false; - if( mCameraAttachment ) + if( mCamera ) { - retval = mCameraAttachment->ViewMatrixUpdated(); + retval = mCamera->ViewMatrixUpdated(); } return retval; } -void RenderTask::SetCompleteStatusManager(CompleteStatusManager* completeStatusManager) -{ - mCompleteStatusManager = completeStatusManager; -} - void RenderTask::SetViewportPosition( BufferIndex updateBufferIndex, const Vector2& value ) { mViewportPosition.Set( updateBufferIndex, value ); @@ -480,34 +447,34 @@ bool RenderTask::GetViewportEnabled( BufferIndex bufferIndex ) const return false; } -void RenderTask::ResetDefaultProperties( BufferIndex updateBufferIndex ) +void RenderTask::SetSyncRequired( bool requiresSync ) { - // Reset default properties - mViewportPosition.ResetToBaseValue( updateBufferIndex ); - mViewportSize.ResetToBaseValue( updateBufferIndex ); - mClearColor.ResetToBaseValue( updateBufferIndex ); + mRequiresSync = requiresSync; } + RenderTask::RenderTask() : mViewportPosition( Vector2::ZERO), mViewportSize( Vector2::ZERO), mClearColor( Dali::RenderTask::DEFAULT_CLEAR_COLOR ), - mCompleteStatusManager( NULL ), + mRenderMessageDispatcher( NULL ), + mRenderSyncTracker( NULL ), mSourceNode( NULL ), mCameraNode( NULL ), - mCameraAttachment( NULL ), - mFrameBufferResourceId( 0 ), + mCamera( NULL ), + mFrameBuffer(0), mWaitingToRender( false ), mNotifyTrigger( false ), mExclusive( Dali::RenderTask::DEFAULT_EXCLUSIVE ), mClearEnabled( Dali::RenderTask::DEFAULT_CLEAR_ENABLED ), - mRenderTarget( NULL ), + mCullMode( Dali::RenderTask::DEFAULT_CULL_MODE ), mState( (Dali::RenderTask::DEFAULT_REFRESH_RATE == Dali::RenderTask::REFRESH_ALWAYS) ? RENDER_CONTINUOUSLY : RENDER_ONCE_WAITING_FOR_RESOURCES ), mRefreshRate( Dali::RenderTask::DEFAULT_REFRESH_RATE ), mFrameCounter( 0u ), - mRenderedOnceCounter( 0u ) + mRenderedOnceCounter( 0u ), + mRequiresSync( false ) { }