X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fwindow-system%2Fcommon%2Fwindow-render-surface.cpp;h=76bf702dc2f175c25388360697f8d51ee7e99aac;hb=e96676a48a1948833044e39fc35af16e220d1580;hp=2727430dba26c7bf43c55675ba3a0f1bd42e1a21;hpb=1d86c6e649b87e3152ca5049cec6a9c7b96e987a;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/dali/internal/window-system/common/window-render-surface.cpp b/dali/internal/window-system/common/window-render-surface.cpp old mode 100644 new mode 100755 index 2727430..76bf702 --- a/dali/internal/window-system/common/window-render-surface.cpp +++ b/dali/internal/window-system/common/window-render-surface.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * Copyright (c) 2019 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. @@ -27,10 +27,12 @@ #include #include #include +#include #include #include #include #include +#include namespace Dali @@ -44,6 +46,7 @@ namespace { const int MINIMUM_DIMENSION_CHANGE( 1 ); ///< Minimum change for window to be considered to have moved +const int TILE_SIZE = 16u; ///< Unit of tile size at GPU driver #if defined(DEBUG_ENABLED) Debug::Filter* gWindowRenderSurfaceLogFilter = Debug::Filter::New(Debug::Verbose, false, "LOG_WINDOW_RENDER_SURFACE"); @@ -52,21 +55,30 @@ Debug::Filter* gWindowRenderSurfaceLogFilter = Debug::Filter::New(Debug::Verbose } // unnamed namespace WindowRenderSurface::WindowRenderSurface( Dali::PositionSize positionSize, Any surface, bool isTransparent ) -: mPositionSize( positionSize ), +: mEGL( nullptr ), + mDisplayConnection( nullptr ), + mPositionSize( positionSize ), mWindowBase(), mThreadSynchronization( NULL ), mRenderNotification( NULL ), mRotationTrigger( NULL ), mGraphics( nullptr ), + mEGLSurface( nullptr ), + mEGLContext( nullptr ), mColorDepth( isTransparent ? COLOR_DEPTH_32 : COLOR_DEPTH_24 ), mOutputTransformedSignal(), mRotationAngle( 0 ), mScreenRotationAngle( 0 ), + mBufferAge( 0 ), + mPreBufferAge( 0 ), mOwnSurface( false ), mRotationSupported( false ), mRotationFinished( true ), mScreenRotationFinished( true ), - mResizeFinished( true ) + mResizeFinished( true ), + mDpiHorizontal( 0 ), + mDpiVertical( 0 ), + mPreDamagedRect() { DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "Creating Window\n" ); Initialize( surface ); @@ -78,6 +90,11 @@ WindowRenderSurface::~WindowRenderSurface() { delete mRotationTrigger; } + + if ( mEGLSurface ) + { + DestroySurface(); + } } void WindowRenderSurface::Initialize( Any surface ) @@ -104,6 +121,7 @@ void WindowRenderSurface::Initialize( Any surface ) if( mScreenRotationAngle != 0 ) { mScreenRotationFinished = false; + mResizeFinished = false; } } @@ -134,12 +152,6 @@ void WindowRenderSurface::SetTransparency( bool transparent ) void WindowRenderSurface::RequestRotation( int angle, int width, int height ) { - if( !mRotationSupported ) - { - DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::Rotate: Rotation is not supported!\n" ); - return; - } - if( !mRotationTrigger ) { TriggerEventFactoryInterface& triggerFactory = Internal::Adaptor::Adaptor::GetImplementation( Adaptor::Get() ).GetTriggerEventFactoryInterface(); @@ -174,31 +186,47 @@ PositionSize WindowRenderSurface::GetPositionSize() const void WindowRenderSurface::GetDpi( unsigned int& dpiHorizontal, unsigned int& dpiVertical ) { - mWindowBase->GetDpi( dpiHorizontal, dpiVertical ); -} + if( mDpiHorizontal == 0 || mDpiVertical == 0 ) + { + const char* environmentDpiHorizontal = std::getenv( DALI_ENV_DPI_HORIZONTAL ); + mDpiHorizontal = environmentDpiHorizontal ? std::atoi( environmentDpiHorizontal ) : 0; -void WindowRenderSurface::InitializeGraphics( GraphicsInterface& graphics, Dali::DisplayConnection& displayConnection ) -{ - mGraphics = &graphics; + const char* environmentDpiVertical = std::getenv( DALI_ENV_DPI_VERTICAL ); + mDpiVertical = environmentDpiVertical ? std::atoi( environmentDpiVertical ) : 0; - auto eglGraphics = static_cast(mGraphics); + if( mDpiHorizontal == 0 || mDpiVertical == 0 ) + { + mWindowBase->GetDpi( mDpiHorizontal, mDpiVertical ); + } + } - EglInterface* mEGL = eglGraphics->Create(); + dpiHorizontal = mDpiHorizontal; + dpiVertical = mDpiVertical; +} - // Initialize EGL & OpenGL - displayConnection.Initialize(); +int WindowRenderSurface::GetOrientation() const +{ + return mWindowBase->GetOrientation(); +} - Internal::Adaptor::EglImplementation& eglImpl = static_cast(*mEGL); - eglImpl.ChooseConfig(true, mColorDepth); +void WindowRenderSurface::InitializeGraphics() +{ - // Create the OpenGL context - mEGL->CreateContext(); + mGraphics = &mAdaptor->GetGraphicsInterface(); - // Create the OpenGL surface - CreateSurface(); + auto eglGraphics = static_cast(mGraphics); + mEGL = &eglGraphics->GetEglInterface(); + + if ( mEGLContext == NULL ) + { + // Create the OpenGL context for this window + Internal::Adaptor::EglImplementation& eglImpl = static_cast(*mEGL); + eglImpl.ChooseConfig(true, mColorDepth); + eglImpl.CreateWindowContext( mEGLContext ); - // Make it current - mEGL->MakeContextCurrent(); + // Create the OpenGL surface + CreateSurface(); + } } void WindowRenderSurface::CreateSurface() @@ -223,12 +251,15 @@ void WindowRenderSurface::CreateSurface() auto eglGraphics = static_cast(mGraphics); Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation(); - eglImpl.CreateSurfaceWindow( window, mColorDepth ); + mEGLSurface = eglImpl.CreateSurfaceWindow( window, mColorDepth ); // Check rotation capability mRotationSupported = mWindowBase->IsEglWindowRotationSupported(); - DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::CreateSurface: w = %d h = %d angle = %d screen rotation = %d\n", mPositionSize.width, mPositionSize.height, mRotationAngle, mScreenRotationAngle ); + int screenWidth, screenHeight; + WindowSystem::GetScreenSize( screenWidth, screenHeight ); + DALI_LOG_RELEASE_INFO("WindowRenderSurface::CreateSurface: w = %d h = %d screenWidth = %d screenHeight = %d angle = %d screen rotation = %d\n", + mPositionSize.width, mPositionSize.height, screenWidth, screenHeight, mRotationAngle, mScreenRotationAngle ); } void WindowRenderSurface::DestroySurface() @@ -238,7 +269,7 @@ void WindowRenderSurface::DestroySurface() auto eglGraphics = static_cast(mGraphics); Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation(); - eglImpl.DestroySurface(); + eglImpl.DestroySurface( mEGLSurface ); mWindowBase->DestroyEglWindow(); } @@ -271,7 +302,7 @@ bool WindowRenderSurface::ReplaceGraphicsSurface() auto eglGraphics = static_cast(mGraphics); Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation(); - return eglImpl.ReplaceSurfaceWindow( window ); + return eglImpl.ReplaceSurfaceWindow( window, mEGLSurface, mEGLContext ); } void WindowRenderSurface::MoveResize( Dali::PositionSize positionSize ) @@ -326,14 +357,15 @@ void WindowRenderSurface::StartRender() bool WindowRenderSurface::PreRender( bool resizingSurface ) { + MakeContextCurrent(); + if( resizingSurface ) { -#ifdef OVER_TIZEN_VERSION_4 + int totalAngle = (mRotationAngle + mScreenRotationAngle) % 360; + // Window rotate or screen rotate if( !mRotationFinished || !mScreenRotationFinished ) { - int totalAngle = (mRotationAngle + mScreenRotationAngle) % 360; - mWindowBase->SetEglWindowRotation( totalAngle ); mWindowBase->SetEglWindowBufferTransform( totalAngle ); @@ -348,12 +380,25 @@ bool WindowRenderSurface::PreRender( bool resizingSurface ) { mWindowBase->SetEglWindowTransform( mRotationAngle ); } -#endif // Resize case - if( !mResizeFinished ) + if ( !mResizeFinished ) { - mWindowBase->ResizeEglWindow( mPositionSize ); + Dali::PositionSize positionSize; + positionSize.x = mPositionSize.x; + positionSize.y = mPositionSize.y; + if( totalAngle == 0 || totalAngle == 180 ) + { + positionSize.width = mPositionSize.width; + positionSize.height = mPositionSize.height; + } + else + { + positionSize.width = mPositionSize.height; + positionSize.height = mPositionSize.width; + } + + mWindowBase->ResizeEglWindow( positionSize ); mResizeFinished = true; DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::PreRender: Set resize\n" ); @@ -361,49 +406,145 @@ bool WindowRenderSurface::PreRender( bool resizingSurface ) } auto eglGraphics = static_cast(mGraphics); - auto mGLES = eglGraphics->GetGlesInterface(); - mGLES.PreRender(); + if ( eglGraphics ) + { + GlImplementation& mGLES = eglGraphics->GetGlesInterface(); + mGLES.PreRender(); + } return true; } -void WindowRenderSurface::PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface ) +std::vector WindowRenderSurface::MergeRect( Rect damagedRect, int bufferAge ) { - // Inform the gl implementation that rendering has finished before informing the surface - auto eglGraphics = static_cast(mGraphics); - auto mGLES = eglGraphics->GetGlesInterface(); - mGLES.PostRender(); + std::vector mergedRectArray; + // merge bounding + int dx1 = mPositionSize.width, dx2 = 0, dy1 = mPositionSize.height, dy2 = 0; + int checkWidth = mPositionSize.width - TILE_SIZE; + int checkHeight = mPositionSize.height - TILE_SIZE; + + dx1 = std::min( damagedRect.x, dx1 ); + dx2 = std::max( damagedRect.x + damagedRect.width, dx2); + dy1 = std::min( damagedRect.y, dy1 ); + dy2 = std::max( damagedRect.y + damagedRect.height, dy2 ); + + for( int j = 0; j <= bufferAge; j++ ) + { + if( !mPreDamagedRect[j].IsEmpty() ) + { + dx1 = std::min( mPreDamagedRect[j].x, dx1 ); + dx2 = std::max( mPreDamagedRect[j].x + mPreDamagedRect[j].width, dx2); + dy1 = std::min( mPreDamagedRect[j].y, dy1 ); + dy2 = std::max( mPreDamagedRect[j].y + mPreDamagedRect[j].height, dy2 ); + + if( dx1 < TILE_SIZE && dx2 > checkWidth && dy1 < TILE_SIZE && dy2 > checkHeight ) + { + dx1 = 0, dx2 = mPositionSize.width, dy1 = 0, dy2 = mPositionSize.height; + break; + } + } + } + + dx1 = TILE_SIZE * (dx1 / TILE_SIZE); + dy1 = TILE_SIZE * (dy1 / TILE_SIZE); + dx2 = TILE_SIZE * ((dx2 + TILE_SIZE - 1) / TILE_SIZE); + dy2 = TILE_SIZE * ((dy2 + TILE_SIZE - 1) / TILE_SIZE); + + mergedRectArray.push_back( dx1 ); + mergedRectArray.push_back( dy1 ); + mergedRectArray.push_back( dx2 - dx1 ); + mergedRectArray.push_back( dy2 - dy1 ); + + return mergedRectArray; +} + - if( renderToFbo ) +Rect WindowRenderSurface::SetDamagedRect( Rect damagedRect ) +{ + auto eglGraphics = static_cast( mGraphics ); + std::vector rectArray; + Rect mergedDamagedRect; + if( eglGraphics ) { - mGLES.Flush(); - mGLES.Finish(); + Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation(); + + rectArray = MergeRect( damagedRect, mBufferAge ); + + mPreDamagedRect[4] = std::move( mPreDamagedRect[3] ); + mPreDamagedRect[3] = std::move( mPreDamagedRect[2] ); + mPreDamagedRect[2] = std::move( mPreDamagedRect[1] ); + mPreDamagedRect[1] = std::move( mPreDamagedRect[0] ); + mPreDamagedRect[0] = std::move( damagedRect ); + + eglImpl.SetDamagedRect( rectArray, mEGLSurface ); } - else + + if( !rectArray.empty() ) { - if( resizingSurface ) + mergedDamagedRect.x = rectArray[0]; + mergedDamagedRect.y = rectArray[1]; + mergedDamagedRect.width = rectArray[2]; + mergedDamagedRect.height = rectArray[3]; + } + + return mergedDamagedRect; +} + +int WindowRenderSurface::GetBufferAge() +{ + auto result = mBufferAge = 0; + auto eglGraphics = static_cast( mGraphics ); + if( eglGraphics ) + { + Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation(); + mBufferAge = eglImpl.GetBufferAge( mEGLSurface );; + result = ( mBufferAge != mPreBufferAge ) ? 0 : mBufferAge; + mPreBufferAge = mBufferAge; + } + return result; +} + +void WindowRenderSurface::PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface ) +{ + // Inform the gl implementation that rendering has finished before informing the surface + auto eglGraphics = static_cast(mGraphics); + if ( eglGraphics ) + { + GlImplementation& mGLES = eglGraphics->GetGlesInterface(); + mGLES.PostRender(); + + if( renderToFbo ) { - if( !mRotationFinished ) + mGLES.Flush(); + mGLES.Finish(); + } + else + { + if( resizingSurface ) { - DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::PostRender: Trigger rotation event\n" ); + if( !mRotationFinished ) + { + DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::PostRender: Trigger rotation event\n" ); - mRotationTrigger->Trigger(); + mRotationTrigger->Trigger(); - if( mThreadSynchronization ) - { - // Wait until the event-thread complete the rotation event processing - mThreadSynchronization->PostRenderWaitForCompletion(); + if( mThreadSynchronization ) + { + // Wait until the event-thread complete the rotation event processing + mThreadSynchronization->PostRenderWaitForCompletion(); + } } } } - } - Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation(); - eglImpl.SwapBuffers(); + Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation(); - if( mRenderNotification ) - { - mRenderNotification->Trigger(); + eglImpl.SwapBuffers( mEGLSurface ); + + if( mRenderNotification ) + { + mRenderNotification->Trigger(); + } } } @@ -423,11 +564,29 @@ void WindowRenderSurface::ReleaseLock() // Nothing to do. } -RenderSurface::Type WindowRenderSurface::GetSurfaceType() +Integration::RenderSurface::Type WindowRenderSurface::GetSurfaceType() { return RenderSurface::WINDOW_RENDER_SURFACE; } +void WindowRenderSurface::MakeContextCurrent() +{ + if ( mEGL != nullptr ) + { + mEGL->MakeContextCurrent( mEGLSurface, mEGLContext ); + } +} + +Integration::DepthBufferAvailable WindowRenderSurface::GetDepthBufferRequired() +{ + return mGraphics ? mGraphics->GetDepthBufferRequired() : Integration::DepthBufferAvailable::FALSE; +} + +Integration::StencilBufferAvailable WindowRenderSurface::GetStencilBufferRequired() +{ + return mGraphics ? mGraphics->GetStencilBufferRequired() : Integration::StencilBufferAvailable::FALSE; +} + void WindowRenderSurface::OutputTransformed() { int screenRotationAngle = mWindowBase->GetScreenRotationAngle(); @@ -436,6 +595,7 @@ void WindowRenderSurface::OutputTransformed() { mScreenRotationAngle = screenRotationAngle; mScreenRotationFinished = false; + mResizeFinished = false; mOutputTransformedSignal.Emit();