mScreenRotationFinished(true),
mResizeFinished(true),
mDefaultScreenRotationAvailable(false),
- mIsImeWindowSurface(false)
+ mIsImeWindowSurface(false),
+ mNeedWindowRotationAcknowledgement(false)
{
DALI_LOG_INFO(gWindowRenderSurfaceLogFilter, Debug::Verbose, "Creating Window\n");
Initialize(surface);
if(!mPostRenderTrigger)
{
mPostRenderTrigger = std::unique_ptr<TriggerEventInterface>(TriggerEventFactory::CreateTriggerEvent(MakeCallback(this, &WindowRenderSurface::ProcessPostRender),
- TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER));
+ TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER));
}
mPositionSize.width = width;
mWindowRotationAngle = angle;
mWindowRotationFinished = false;
- mResizeFinished = false;
+ mResizeFinished = false;
mWindowBase->SetWindowRotationAngle(mWindowRotationAngle);
void WindowRenderSurface::InitializeGraphics()
{
- mGraphics = &mAdaptor->GetGraphicsInterface();
+ if(mEGLContext == NULL)
+ {
+ mGraphics = &mAdaptor->GetGraphicsInterface();
- DALI_ASSERT_ALWAYS(mGraphics && "Graphics interface is not created");
+ DALI_ASSERT_ALWAYS(mGraphics && "Graphics interface is not created");
- auto eglGraphics = static_cast<EglGraphics*>(mGraphics);
- mEGL = &eglGraphics->GetEglInterface();
+ auto eglGraphics = static_cast<EglGraphics*>(mGraphics);
+ mEGL = &eglGraphics->GetEglInterface();
- if(mEGLContext == NULL)
- {
// Create the OpenGL context for this window
Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>(*mEGL);
eglImpl.ChooseConfig(true, mColorDepth);
bool WindowRenderSurface::PreRender(bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect)
{
+ InitializeGraphics();
+
mDamagedRects.assign(damagedRects.begin(), damagedRects.end());
Dali::Integration::Scene::FrameCallbackContainer callbacks;
SetBufferDamagedRects(mDamagedRects, clippingRect);
- if(clippingRect.IsEmpty())
+ Rect<int> surfaceRect(0, 0, mPositionSize.width, mPositionSize.height);
+ if(clippingRect == surfaceRect)
+ {
+ mDamagedRects.assign(1, surfaceRect);
+ }
+ else if(mDamagedRects.empty() && !clippingRect.IsEmpty())
{
- mDamagedRects.clear();
+ // We will render clippingRect area but mDamagedRects is empty.
+ // So make mDamagedRects same with clippingRect to swap buffers.
+ mDamagedRects.assign(1, clippingRect);
}
// This is now done when the render pass for the render surface begins
GlImplementation& mGLES = eglGraphics->GetGlesInterface();
mGLES.PostRender();
- if((mIsResizing && !mWindowRotationFinished) || mIsImeWindowSurface)
+ bool needWindowRotationCompleted = false;
+
+ if(!mWindowRotationFinished)
+ {
+ if(mNeedWindowRotationAcknowledgement)
+ {
+ Dali::Integration::Scene scene = mScene.GetHandle();
+ if(scene)
+ {
+ if(scene.IsRotationCompletedAcknowledgementSet())
+ {
+ needWindowRotationCompleted = true;
+ }
+ }
+ }
+ else
+ {
+ if(mIsResizing)
+ {
+ needWindowRotationCompleted = true;
+ }
+ }
+ }
+
+ if(needWindowRotationCompleted || mIsImeWindowSurface)
{
if(mThreadSynchronization)
{
}
}
+void WindowRenderSurface::SetNeedsRotationCompletedAcknowledgement(bool needAcknowledgement)
+{
+ mNeedWindowRotationAcknowledgement = needAcknowledgement;
+}
+
void WindowRenderSurface::OutputTransformed()
{
int screenRotationAngle = mWindowBase->GetScreenRotationAngle();
auto eglGraphics = static_cast<EglGraphics*>(mGraphics);
if(eglGraphics)
{
- Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
- if(!eglImpl.IsPartialUpdateRequired())
- {
- return;
- }
-
Rect<int> surfaceRect(0, 0, mPositionSize.width, mPositionSize.height);
- if(mFullSwapNextFrame)
+ Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
+ if(!eglImpl.IsPartialUpdateRequired() || mFullSwapNextFrame)
{
InsertRects(mBufferDamagedRects, std::vector<Rect<int>>(1, surfaceRect));
- clippingRect = Rect<int>();
+ clippingRect = surfaceRect;
return;
}
+ mGraphics->ActivateSurfaceContext(this);
+
EGLint bufferAge = eglImpl.GetBufferAge(mEGLSurface);
// Buffer age 0 means the back buffer in invalid and requires full swap
- if(!damagedRects.size() || bufferAge == 0)
+ if(bufferAge == 0)
{
InsertRects(mBufferDamagedRects, std::vector<Rect<int>>(1, surfaceRect));
- clippingRect = Rect<int>();
+ clippingRect = surfaceRect;
return;
}
if(!clippingRect.Intersect(surfaceRect) || clippingRect.Area() > surfaceRect.Area() * FULL_UPDATE_RATIO)
{
// clipping area too big or doesn't intersect surface rect
- clippingRect = Rect<int>();
+ clippingRect = surfaceRect;
return;
}
- std::vector<Rect<int>> damagedRegion;
- Dali::Integration::Scene scene = mScene.GetHandle();
- if(scene)
- {
- damagedRegion.push_back(RecalculateRect[std::min(scene.GetCurrentSurfaceOrientation() / 90, 3)](clippingRect, scene.GetCurrentSurfaceRect()));
- }
- else
+ if(!clippingRect.IsEmpty())
{
- damagedRegion.push_back(clippingRect);
- }
+ std::vector<Rect<int>> damagedRegion;
+ Dali::Integration::Scene scene = mScene.GetHandle();
+ if(scene)
+ {
+ damagedRegion.push_back(RecalculateRect[std::min(scene.GetCurrentSurfaceOrientation() / 90, 3)](clippingRect, scene.GetCurrentSurfaceRect()));
+ }
+ else
+ {
+ damagedRegion.push_back(clippingRect);
+ }
- eglImpl.SetDamageRegion(mEGLSurface, damagedRegion);
+ eglImpl.SetDamageRegion(mEGLSurface, damagedRegion);
+ }
}
}
Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
- if(!eglImpl.IsPartialUpdateRequired() || mFullSwapNextFrame || !damagedRects.size() || (damagedRects[0].Area() > surfaceRect.Area() * FULL_UPDATE_RATIO))
+ if(!eglImpl.IsPartialUpdateRequired() || mFullSwapNextFrame || (damagedRects.size() != 0 && damagedRects[0].Area() > surfaceRect.Area() * FULL_UPDATE_RATIO))
{
mFullSwapNextFrame = false;
eglImpl.SwapBuffers(mEGLSurface);
if(!mergedRects.size() || (mergedRects[0].Area() > surfaceRect.Area() * FULL_UPDATE_RATIO))
{
+ // In normal cases, WindowRenderSurface::SwapBuffers() will not be called if mergedRects.size() is 0.
+ // For exceptional cases, swap full area.
eglImpl.SwapBuffers(mEGLSurface);
}
else