ThreadedCompositor.cpp [plain text]
#include "config.h"
#include "ThreadedCompositor.h"
#if USE(COORDINATED_GRAPHICS)
#include "CompositingRunLoop.h"
#include "ThreadedDisplayRefreshMonitor.h"
#include <WebCore/PlatformDisplay.h>
#include <WebCore/TransformationMatrix.h>
#include <wtf/SetForScope.h>
#if USE(LIBEPOXY)
#include <epoxy/gl.h>
#elif USE(OPENGL_ES)
#include <GLES2/gl2.h>
#else
#include <GL/gl.h>
#endif
namespace WebKit {
using namespace WebCore;
Ref<ThreadedCompositor> ThreadedCompositor::create(Client& client, ThreadedDisplayRefreshMonitor::Client& displayRefreshMonitorClient, PlatformDisplayID displayID, const IntSize& viewportSize, float scaleFactor, TextureMapper::PaintFlags paintFlags)
{
return adoptRef(*new ThreadedCompositor(client, displayRefreshMonitorClient, displayID, viewportSize, scaleFactor, paintFlags));
}
ThreadedCompositor::ThreadedCompositor(Client& client, ThreadedDisplayRefreshMonitor::Client& displayRefreshMonitorClient, PlatformDisplayID displayID, const IntSize& viewportSize, float scaleFactor, TextureMapper::PaintFlags paintFlags)
: m_client(client)
, m_paintFlags(paintFlags)
, m_compositingRunLoop(makeUnique<CompositingRunLoop>([this] { renderLayerTree(); }))
, m_displayRefreshMonitor(ThreadedDisplayRefreshMonitor::create(displayID, displayRefreshMonitorClient))
{
{
LockHolder locker(m_attributes.lock);
m_attributes.viewportSize = viewportSize;
m_attributes.scaleFactor = scaleFactor;
m_attributes.needsResize = !viewportSize.isEmpty();
}
m_compositingRunLoop->performTaskSync([this, protectedThis = makeRef(*this)] {
m_scene = adoptRef(new CoordinatedGraphicsScene(this));
m_nativeSurfaceHandle = m_client.nativeSurfaceHandleForCompositing();
m_scene->setActive(!!m_nativeSurfaceHandle);
if (m_nativeSurfaceHandle)
createGLContext();
});
}
ThreadedCompositor::~ThreadedCompositor()
{
}
void ThreadedCompositor::createGLContext()
{
ASSERT(!RunLoop::isMain());
ASSERT(m_nativeSurfaceHandle);
m_context = GLContext::createContextForWindow(reinterpret_cast<GLNativeWindowType>(m_nativeSurfaceHandle), &PlatformDisplay::sharedDisplayForCompositing());
if (m_context)
m_context->makeContextCurrent();
}
void ThreadedCompositor::invalidate()
{
m_scene->detach();
m_compositingRunLoop->stopUpdates();
m_displayRefreshMonitor->invalidate();
m_compositingRunLoop->performTaskSync([this, protectedThis = makeRef(*this)] {
if (!m_context || !m_context->makeContextCurrent())
return;
m_scene->purgeGLResources();
m_context = nullptr;
m_client.didDestroyGLContext();
m_scene = nullptr;
});
m_compositingRunLoop = nullptr;
}
void ThreadedCompositor::suspend()
{
if (++m_suspendedCount > 1)
return;
m_compositingRunLoop->suspend();
m_compositingRunLoop->performTaskSync([this, protectedThis = makeRef(*this)] {
m_scene->setActive(false);
});
}
void ThreadedCompositor::resume()
{
ASSERT(m_suspendedCount > 0);
if (--m_suspendedCount > 0)
return;
m_compositingRunLoop->performTaskSync([this, protectedThis = makeRef(*this)] {
m_scene->setActive(true);
});
m_compositingRunLoop->resume();
}
void ThreadedCompositor::setScaleFactor(float scale)
{
LockHolder locker(m_attributes.lock);
m_attributes.scaleFactor = scale;
m_compositingRunLoop->scheduleUpdate();
}
void ThreadedCompositor::setScrollPosition(const IntPoint& scrollPosition, float scale)
{
LockHolder locker(m_attributes.lock);
m_attributes.scrollPosition = scrollPosition;
m_attributes.scaleFactor = scale;
m_compositingRunLoop->scheduleUpdate();
}
void ThreadedCompositor::setViewportSize(const IntSize& viewportSize, float scale)
{
LockHolder locker(m_attributes.lock);
m_attributes.viewportSize = viewportSize;
m_attributes.scaleFactor = scale;
m_attributes.needsResize = true;
m_compositingRunLoop->scheduleUpdate();
}
void ThreadedCompositor::updateViewport()
{
m_compositingRunLoop->scheduleUpdate();
}
void ThreadedCompositor::forceRepaint()
{
#if PLATFORM(GTK) && !USE(WPE_RENDERER)
m_compositingRunLoop->performTaskSync([this, protectedThis = makeRef(*this)] {
renderLayerTree();
});
#endif
}
void ThreadedCompositor::renderLayerTree()
{
if (!m_scene || !m_scene->isActive())
return;
if (!m_context || !m_context->makeContextCurrent())
return;
m_client.willRenderFrame();
WebCore::IntSize viewportSize;
WebCore::IntPoint scrollPosition;
float scaleFactor;
bool needsResize;
Vector<WebCore::CoordinatedGraphicsState> states;
{
LockHolder locker(m_attributes.lock);
viewportSize = m_attributes.viewportSize;
scrollPosition = m_attributes.scrollPosition;
scaleFactor = m_attributes.scaleFactor;
needsResize = m_attributes.needsResize;
states = WTFMove(m_attributes.states);
if (!states.isEmpty()) {
m_attributes.clientRendersNextFrame = true;
}
m_attributes.needsResize = false;
}
if (needsResize) {
m_client.resize(viewportSize);
glViewport(0, 0, viewportSize.width(), viewportSize.height());
}
TransformationMatrix viewportTransform;
viewportTransform.scale(scaleFactor);
viewportTransform.translate(-scrollPosition.x(), -scrollPosition.y());
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
m_scene->applyStateChanges(states);
m_scene->paintToCurrentGLContext(viewportTransform, FloatRect { FloatPoint { }, viewportSize }, m_paintFlags);
m_context->swapBuffers();
if (m_scene->isActive())
m_client.didRenderFrame();
}
void ThreadedCompositor::sceneUpdateFinished()
{
bool shouldDispatchDisplayRefreshCallback { false };
{
LockHolder locker(m_attributes.lock);
shouldDispatchDisplayRefreshCallback = m_attributes.clientRendersNextFrame
|| m_displayRefreshMonitor->requiresDisplayRefreshCallback();
}
LockHolder stateLocker(m_compositingRunLoop->stateLock());
if (shouldDispatchDisplayRefreshCallback)
m_displayRefreshMonitor->dispatchDisplayRefreshCallback();
m_compositingRunLoop->updateCompleted(stateLocker);
}
void ThreadedCompositor::updateSceneState(const CoordinatedGraphicsState& state)
{
LockHolder locker(m_attributes.lock);
m_attributes.states.append(state);
m_compositingRunLoop->scheduleUpdate();
}
void ThreadedCompositor::updateScene()
{
m_compositingRunLoop->scheduleUpdate();
}
RefPtr<WebCore::DisplayRefreshMonitor> ThreadedCompositor::displayRefreshMonitor(PlatformDisplayID)
{
return m_displayRefreshMonitor.copyRef();
}
void ThreadedCompositor::frameComplete()
{
ASSERT(!RunLoop::isMain());
sceneUpdateFinished();
}
}
#endif // USE(COORDINATED_GRAPHICS)