forked from organicmaps/organicmaps
[drape] remove synchronization on Qt rendering. FR now render into texture, GUI thread blit this texture on screen
This commit is contained in:
ExMix
r.kuznetsov
parent
4fe196ed84
commit
ab3e1e12bd
7 changed files with 289 additions and 273 deletions
|
|
@ -13,6 +13,10 @@
|
|||
|
||||
#include <QtGui/QMouseEvent>
|
||||
#include <QtGui/QGuiApplication>
|
||||
#include <QtGui/QOpenGLShaderProgram>
|
||||
#include <QtGui/QOpenGLContextGroup>
|
||||
#include <QtGui/QOpenGLFunctions>
|
||||
#include <QtGui/QVector2D>
|
||||
|
||||
#include <QtWidgets/QMenu>
|
||||
#include <QtWidgets/QApplication>
|
||||
|
|
@ -21,6 +25,7 @@
|
|||
#include <QtCore/QLocale>
|
||||
#include <QtCore/QDateTime>
|
||||
#include <QtCore/QThread>
|
||||
#include <QtCore/QTimer>
|
||||
|
||||
namespace qt
|
||||
{
|
||||
|
|
@ -67,18 +72,15 @@ bool IsLocationEmulation(QMouseEvent * e)
|
|||
|
||||
void DummyDismiss() {}
|
||||
|
||||
DrawWidget::DrawWidget()
|
||||
: m_contextFactory(nullptr),
|
||||
DrawWidget::DrawWidget(QWidget * parent)
|
||||
: TBase(parent),
|
||||
m_contextFactory(nullptr),
|
||||
m_framework(new Framework()),
|
||||
m_ratio(1.0),
|
||||
m_rendererThread(nullptr),
|
||||
m_state(NotInitialized),
|
||||
m_pScale(nullptr),
|
||||
m_enableScaleUpdate(true),
|
||||
m_emulatingLocation(false)
|
||||
{
|
||||
setSurfaceType(QSurface::OpenGLSurface);
|
||||
|
||||
m_framework->SetUserMarkActivationListener([](unique_ptr<UserMarkCopy> mark)
|
||||
{
|
||||
});
|
||||
|
|
@ -88,6 +90,11 @@ bool IsLocationEmulation(QMouseEvent * e)
|
|||
vector<storage::TIndex> const &)
|
||||
{
|
||||
});
|
||||
|
||||
QTimer * timer = new QTimer(this);
|
||||
VERIFY(connect(timer, SIGNAL(timeout()), this, SLOT(update())), ());
|
||||
timer->setSingleShot(false);
|
||||
timer->start(30);
|
||||
}
|
||||
|
||||
DrawWidget::~DrawWidget()
|
||||
|
|
@ -106,17 +113,6 @@ bool IsLocationEmulation(QMouseEvent * e)
|
|||
|
||||
void DrawWidget::PrepareShutdown()
|
||||
{
|
||||
if (!m_contextFactory)
|
||||
return;
|
||||
|
||||
// Discard current and all future Swap requests
|
||||
m_contextFactory->shutDown();
|
||||
frameSwappedSlot(NotInitialized);
|
||||
|
||||
// Shutdown engine. FR have ogl context in this moment and can delete OGL resources
|
||||
// PrepareToShutdown make FR::join and after this call we can bind OGL context to gui thread
|
||||
m_framework->PrepareToShutdown();
|
||||
m_contextFactory.reset();
|
||||
}
|
||||
|
||||
void DrawWidget::UpdateAfterSettingsChanged()
|
||||
|
|
@ -197,27 +193,98 @@ bool IsLocationEmulation(QMouseEvent * e)
|
|||
|
||||
p.m_widgetsInitInfo[gui::WIDGET_SCALE_LABEL] = gui::Position(dp::LeftBottom);
|
||||
|
||||
m_framework->CreateDrapeEngine(make_ref(m_contextFactory), move(p));
|
||||
m_framework->CreateDrapeEngine(make_ref(m_contextFactory), std::move(p));
|
||||
m_framework->AddViewportListener(bind(&DrawWidget::OnViewportChanged, this, _1));
|
||||
}
|
||||
|
||||
void DrawWidget::initializeGL()
|
||||
{
|
||||
Qt::ConnectionType swapType = Qt::QueuedConnection;
|
||||
Qt::ConnectionType regType = Qt::BlockingQueuedConnection;
|
||||
VERIFY(connect(this, SIGNAL(Swap()), SLOT(OnSwap()), swapType), ());
|
||||
VERIFY(connect(this, SIGNAL(RegRenderingThread(QThread *)), SLOT(OnRegRenderingThread(QThread *)), regType), ());
|
||||
VERIFY(connect(this, SIGNAL(frameSwapped()), SLOT(frameSwappedSlot())), ());
|
||||
|
||||
ASSERT(m_contextFactory == nullptr, ());
|
||||
m_ratio = devicePixelRatio();
|
||||
QtOGLContextFactory::TRegisterThreadFn regFn = bind(&DrawWidget::CallRegisterThread, this, _1);
|
||||
QtOGLContextFactory::TSwapFn swapFn = bind(&DrawWidget::CallSwap, this);
|
||||
m_contextFactory = make_unique_dp<QtOGLContextFactory>(context(), QThread::currentThread(), regFn, swapFn);
|
||||
m_contextFactory.reset(new QtOGLContextFactory(context()));
|
||||
CreateEngine();
|
||||
LoadState();
|
||||
}
|
||||
|
||||
void DrawWidget::paintGL()
|
||||
{
|
||||
static QOpenGLShaderProgram * program = nullptr;
|
||||
if (program == nullptr)
|
||||
{
|
||||
const char * vertexSrc = "\
|
||||
attribute vec2 a_position; \
|
||||
attribute vec2 a_texCoord; \
|
||||
uniform mat4 u_projection; \
|
||||
varying vec2 v_texCoord; \
|
||||
\
|
||||
void main(void) \
|
||||
{ \
|
||||
gl_Position = u_projection * vec4(a_position, 0.0, 1.0);\
|
||||
v_texCoord = a_texCoord; \
|
||||
}";
|
||||
|
||||
const char * fragmentSrc = "\
|
||||
uniform sampler2D u_sampler; \
|
||||
varying vec2 v_texCoord; \
|
||||
\
|
||||
void main(void) \
|
||||
{ \
|
||||
gl_FragColor = texture2D(u_sampler, v_texCoord); \
|
||||
}";
|
||||
|
||||
program = new QOpenGLShaderProgram(this);
|
||||
program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexSrc);
|
||||
program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentSrc);
|
||||
program->link();
|
||||
}
|
||||
|
||||
if (m_contextFactory->LockFrame())
|
||||
{
|
||||
QOpenGLFunctions * funcs = context()->functions();
|
||||
funcs->glActiveTexture(GL_TEXTURE0);
|
||||
GLuint image = m_contextFactory->GetTextureHandle();
|
||||
funcs->glBindTexture(GL_TEXTURE_2D, image);
|
||||
|
||||
int projectionLocation = program->uniformLocation("u_projection");
|
||||
int samplerLocation = program->uniformLocation("u_sampler");
|
||||
|
||||
QMatrix4x4 projection;
|
||||
projection.ortho(rect());
|
||||
|
||||
program->bind();
|
||||
program->setUniformValue(projectionLocation, projection);
|
||||
program->setUniformValue(samplerLocation, 0);
|
||||
|
||||
float w = width();
|
||||
float h = height();
|
||||
|
||||
QVector2D positions[4] =
|
||||
{
|
||||
QVector2D(0.0, 0.0),
|
||||
QVector2D(w, 0.0),
|
||||
QVector2D(0.0, h),
|
||||
QVector2D(w, h)
|
||||
};
|
||||
|
||||
QRectF const & texRect = m_contextFactory->GetTexRect();
|
||||
QVector2D texCoords[4] =
|
||||
{
|
||||
QVector2D(texRect.bottomLeft()),
|
||||
QVector2D(texRect.bottomRight()),
|
||||
QVector2D(texRect.topLeft()),
|
||||
QVector2D(texRect.topRight())
|
||||
};
|
||||
|
||||
program->enableAttributeArray("a_position");
|
||||
program->enableAttributeArray("a_texCoord");
|
||||
program->setAttributeArray("a_position", positions, 0);
|
||||
program->setAttributeArray("a_texCoord", texCoords, 0);
|
||||
|
||||
funcs->glClearColor(0.65, 0.65, 0.65, 1.0);
|
||||
funcs->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
funcs->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
|
||||
|
||||
m_contextFactory->UnlockFrame();
|
||||
}
|
||||
|
||||
emit EngineCreated();
|
||||
}
|
||||
|
||||
void DrawWidget::resizeGL(int width, int height)
|
||||
|
|
@ -235,32 +302,10 @@ bool IsLocationEmulation(QMouseEvent * e)
|
|||
layout[w] = pos.m_pixelPivot;
|
||||
});
|
||||
|
||||
m_framework->SetWidgetLayout(move(layout));
|
||||
m_framework->SetWidgetLayout(std::move(layout));
|
||||
}
|
||||
}
|
||||
|
||||
void DrawWidget::paintGL() { /*Must be empty*/ }
|
||||
|
||||
void DrawWidget::exposeEvent(QExposeEvent * event)
|
||||
{
|
||||
if (isExposed())
|
||||
{
|
||||
m_swapMutex.lock();
|
||||
if (m_state == Render)
|
||||
{
|
||||
unique_lock<mutex> waitContextLock(m_waitContextMutex);
|
||||
m_state = WaitContext;
|
||||
m_swapMutex.unlock();
|
||||
|
||||
m_waitContextCond.wait(waitContextLock, [this](){ return m_state != WaitContext; });
|
||||
}
|
||||
else
|
||||
m_swapMutex.unlock();
|
||||
}
|
||||
|
||||
TBase::exposeEvent(event);
|
||||
}
|
||||
|
||||
void DrawWidget::mousePressEvent(QMouseEvent * e)
|
||||
{
|
||||
TBase::mousePressEvent(e);
|
||||
|
|
@ -339,87 +384,6 @@ bool IsLocationEmulation(QMouseEvent * e)
|
|||
m_emulatingLocation = false;
|
||||
}
|
||||
|
||||
void DrawWidget::CallSwap()
|
||||
{
|
||||
// Called on FR thread. In this point OGL context have already moved into GUI thread.
|
||||
unique_lock<mutex> lock(m_swapMutex);
|
||||
if (m_state == NotInitialized)
|
||||
{
|
||||
// This can be in two cases if GUI thread in PrepareToShutDown
|
||||
return;
|
||||
}
|
||||
|
||||
ASSERT(m_state != WaitSwap, ());
|
||||
if (m_state == WaitContext)
|
||||
{
|
||||
lock_guard<mutex> waitContextLock(m_waitContextMutex);
|
||||
m_state = Render;
|
||||
m_waitContextCond.notify_one();
|
||||
}
|
||||
|
||||
if (m_state == Render)
|
||||
{
|
||||
// We have to wait, while Qt on GUI thread finish composing widgets and make SwapBuffers
|
||||
// After SwapBuffers Qt will call our SLOT(frameSwappedSlot)
|
||||
m_state = WaitSwap;
|
||||
emit Swap();
|
||||
m_swapCond.wait(lock, [this]() { return m_state != WaitSwap; });
|
||||
}
|
||||
}
|
||||
|
||||
void DrawWidget::CallRegisterThread(QThread * thread)
|
||||
{
|
||||
// Called on FR thread. SIGNAL(RegRenderingThread) and SLOT(OnRegRenderingThread)
|
||||
// connected by through Qt::BlockingQueuedConnection and we don't need any synchronization
|
||||
ASSERT(m_state == NotInitialized, ());
|
||||
emit RegRenderingThread(thread);
|
||||
}
|
||||
|
||||
void DrawWidget::OnSwap()
|
||||
{
|
||||
// Called on GUI thread. In this point FR thread must wait SwapBuffers signal
|
||||
lock_guard<mutex> lock(m_swapMutex);
|
||||
if (m_state == WaitSwap)
|
||||
{
|
||||
context()->makeCurrent(this);
|
||||
update();
|
||||
}
|
||||
}
|
||||
|
||||
void DrawWidget::OnRegRenderingThread(QThread * thread)
|
||||
{
|
||||
// Called on GUI thread.
|
||||
// Here we register thread of FR, to return OGL context into it after SwapBuffers
|
||||
// After this operation we can start rendering into back buffer on FR thread
|
||||
lock_guard<mutex> lock(m_swapMutex);
|
||||
|
||||
ASSERT(m_state == NotInitialized, ());
|
||||
m_state = Render;
|
||||
m_rendererThread = thread;
|
||||
MoveContextToRenderThread();
|
||||
}
|
||||
|
||||
void DrawWidget::frameSwappedSlot(RenderingState state)
|
||||
{
|
||||
// Qt call this slot on GUI thread after glSwapBuffers perfomed
|
||||
// Here we move OGL context into FR thread and wake up FR
|
||||
lock_guard<mutex> lock(m_swapMutex);
|
||||
|
||||
if (m_state == WaitSwap)
|
||||
{
|
||||
MoveContextToRenderThread();
|
||||
m_state = state;
|
||||
m_swapCond.notify_all();
|
||||
}
|
||||
}
|
||||
|
||||
void DrawWidget::MoveContextToRenderThread()
|
||||
{
|
||||
QOpenGLContext * ctx = context();
|
||||
ctx->doneCurrent();
|
||||
ctx->moveToThread(m_rendererThread);
|
||||
}
|
||||
|
||||
void DrawWidget::wheelEvent(QWheelEvent * e)
|
||||
{
|
||||
m_framework->Scale(exp(e->delta() / 360.0), m2::PointD(L2D(e->x()), L2D(e->y())), false);
|
||||
|
|
@ -529,7 +493,7 @@ bool IsLocationEmulation(QMouseEvent * e)
|
|||
|
||||
void DrawWidget::UpdateScaleControl()
|
||||
{
|
||||
if (m_pScale && isExposed() && m_enableScaleUpdate)
|
||||
if (m_pScale && m_enableScaleUpdate)
|
||||
{
|
||||
// don't send ScaleChanged
|
||||
m_pScale->SetPosWithBlockedSignals(m_framework->GetDrawScale());
|
||||
|
|
|
|||
|
|
@ -12,15 +12,17 @@
|
|||
#include "std/mutex.hpp"
|
||||
#include "std/condition_variable.hpp"
|
||||
|
||||
#include <QtGui/QOpenGLWindow>
|
||||
#include <QtWidgets/QOpenGLWidget>
|
||||
|
||||
class QQuickWindow;
|
||||
|
||||
namespace qt
|
||||
{
|
||||
class QScaleSlider;
|
||||
|
||||
class DrawWidget : public QOpenGLWindow
|
||||
class DrawWidget : public QOpenGLWidget
|
||||
{
|
||||
using TBase = QOpenGLWindow;
|
||||
using TBase = QOpenGLWidget;
|
||||
|
||||
drape_ptr<QtOGLContextFactory> m_contextFactory;
|
||||
unique_ptr<Framework> m_framework;
|
||||
|
|
@ -41,7 +43,7 @@ namespace qt
|
|||
void SliderReleased();
|
||||
|
||||
public:
|
||||
DrawWidget();
|
||||
DrawWidget(QWidget * parent);
|
||||
~DrawWidget();
|
||||
|
||||
void SetScaleControl(QScaleSlider * pScale);
|
||||
|
|
@ -69,13 +71,11 @@ namespace qt
|
|||
void CreateEngine();
|
||||
|
||||
protected:
|
||||
void initializeGL() override;
|
||||
void paintGL() override;
|
||||
void resizeGL(int width, int height) override;
|
||||
/// @name Overriden from QOpenGLWindow.
|
||||
//@{
|
||||
void initializeGL() override;
|
||||
void resizeGL(int width, int height) override;
|
||||
void paintGL() override;
|
||||
|
||||
void exposeEvent(QExposeEvent * event) override;
|
||||
void mousePressEvent(QMouseEvent * e) override;
|
||||
void mouseDoubleClickEvent(QMouseEvent * e) override;
|
||||
void mouseMoveEvent(QMouseEvent * e) override;
|
||||
|
|
@ -83,35 +83,7 @@ namespace qt
|
|||
void wheelEvent(QWheelEvent * e) override;
|
||||
void keyPressEvent(QKeyEvent * e) override;
|
||||
void keyReleaseEvent(QKeyEvent * e) override;
|
||||
//@}a
|
||||
|
||||
private:
|
||||
enum RenderingState
|
||||
{
|
||||
NotInitialized,
|
||||
WaitContext,
|
||||
WaitSwap,
|
||||
Render,
|
||||
};
|
||||
|
||||
void CallSwap();
|
||||
void CallRegisterThread(QThread * thread);
|
||||
Q_SIGNAL void Swap();
|
||||
Q_SIGNAL void RegRenderingThread(QThread * thread);
|
||||
Q_SLOT void OnSwap();
|
||||
Q_SLOT void OnRegRenderingThread(QThread * thread);
|
||||
Q_SLOT void frameSwappedSlot(RenderingState state = Render);
|
||||
|
||||
void MoveContextToRenderThread();
|
||||
QThread * m_rendererThread;
|
||||
|
||||
mutex m_swapMutex;
|
||||
condition_variable m_swapCond;
|
||||
|
||||
mutex m_waitContextMutex;
|
||||
condition_variable m_waitContextCond;
|
||||
|
||||
RenderingState m_state;
|
||||
//@}
|
||||
|
||||
private:
|
||||
void SubmitFakeLocationPoint(m2::PointD const & pt);
|
||||
|
|
|
|||
|
|
@ -55,11 +55,11 @@ MainWindow::MainWindow() : m_locationService(CreateDesktopLocationService(*this)
|
|||
QDesktopWidget const * desktop(QApplication::desktop());
|
||||
setGeometry(desktop->screenGeometry(desktop->primaryScreen()));
|
||||
|
||||
m_pDrawWidget = new DrawWidget();
|
||||
QSurfaceFormat format = m_pDrawWidget->requestedFormat();
|
||||
m_pDrawWidget = new DrawWidget(this);
|
||||
QSurfaceFormat format = m_pDrawWidget->format();
|
||||
|
||||
format.setMajorVersion(3);
|
||||
format.setMinorVersion(2);
|
||||
format.setMajorVersion(2);
|
||||
format.setMinorVersion(1);
|
||||
|
||||
format.setAlphaBufferSize(0);
|
||||
format.setBlueBufferSize(8);
|
||||
|
|
@ -74,9 +74,8 @@ MainWindow::MainWindow() : m_locationService(CreateDesktopLocationService(*this)
|
|||
format.setProfile(QSurfaceFormat::CompatibilityProfile);
|
||||
//format.setOption(QSurfaceFormat::DebugContext);
|
||||
m_pDrawWidget->setFormat(format);
|
||||
QWidget * w = QWidget::createWindowContainer(m_pDrawWidget, this);
|
||||
w->setMouseTracking(true);
|
||||
setCentralWidget(w);
|
||||
m_pDrawWidget->setMouseTracking(true);
|
||||
setCentralWidget(m_pDrawWidget);
|
||||
|
||||
QObject::connect(m_pDrawWidget, SIGNAL(EngineCreated()), this, SLOT(OnEngineCreated()));
|
||||
|
||||
|
|
|
|||
|
|
@ -2,85 +2,122 @@
|
|||
|
||||
#include "base/assert.hpp"
|
||||
#include "base/logging.hpp"
|
||||
#include "base/macros.hpp"
|
||||
#include "base/math.hpp"
|
||||
|
||||
#include "drape/glfunctions.hpp"
|
||||
|
||||
QtRenderOGLContext::QtRenderOGLContext(QOpenGLContext * nativeContext, QThread * guiThread,
|
||||
TRegisterThreadFn const & regFn, TSwapFn const & swapFn)
|
||||
: m_surface(nativeContext->surface())
|
||||
, m_ctx(nativeContext)
|
||||
, m_guiThread(guiThread)
|
||||
, m_regFn(regFn)
|
||||
, m_swapFn(swapFn)
|
||||
, m_isRegistered(false)
|
||||
, m_shutedDown(false)
|
||||
QtRenderOGLContext::QtRenderOGLContext(QOpenGLContext * rootContext, QOffscreenSurface * surface)
|
||||
: m_surface(surface)
|
||||
{
|
||||
m_ctx = new QOpenGLContext();
|
||||
m_ctx->setFormat(rootContext->format());
|
||||
m_ctx->setShareContext(rootContext);
|
||||
m_ctx->create();
|
||||
ASSERT(m_ctx->isValid(), ());
|
||||
}
|
||||
|
||||
QtRenderOGLContext::~QtRenderOGLContext()
|
||||
{
|
||||
delete m_frontFrame;
|
||||
delete m_backFrame;
|
||||
delete m_ctx;
|
||||
}
|
||||
|
||||
void QtRenderOGLContext::present()
|
||||
{
|
||||
if (m_shutedDown)
|
||||
return;
|
||||
if (!m_resizeLock)
|
||||
lockFrame();
|
||||
|
||||
MoveContextOnGui();
|
||||
m_swapFn();
|
||||
m_resizeLock = false;
|
||||
GLFunctions::glFinish();
|
||||
|
||||
makeCurrent();
|
||||
swap(m_frontFrame, m_backFrame);
|
||||
unlockFrame();
|
||||
}
|
||||
|
||||
void QtRenderOGLContext::makeCurrent()
|
||||
{
|
||||
if (!m_isRegistered)
|
||||
{
|
||||
m_regFn(QThread::currentThread());
|
||||
m_isRegistered = true;
|
||||
}
|
||||
|
||||
m_ctx->makeCurrent(m_surface);
|
||||
VERIFY(m_ctx->makeCurrent(m_surface), ());
|
||||
}
|
||||
|
||||
void QtRenderOGLContext::doneCurrent()
|
||||
{
|
||||
MoveContextOnGui();
|
||||
m_ctx->doneCurrent();
|
||||
}
|
||||
|
||||
void QtRenderOGLContext::setDefaultFramebuffer()
|
||||
{
|
||||
GLFunctions::glBindFramebuffer(GL_FRAMEBUFFER, m_ctx->defaultFramebufferObject());
|
||||
if (m_backFrame == nullptr)
|
||||
{
|
||||
LOG(LWARNING, ("Back framebuffer has't been created"));
|
||||
return;
|
||||
}
|
||||
|
||||
m_backFrame->bind();
|
||||
}
|
||||
|
||||
void QtRenderOGLContext::shutDown()
|
||||
void QtRenderOGLContext::resize(int w, int h)
|
||||
{
|
||||
m_shutedDown = true;
|
||||
lockFrame();
|
||||
m_resizeLock = true;
|
||||
|
||||
delete m_frontFrame;
|
||||
delete m_backFrame;
|
||||
|
||||
QSize size(my::NextPowOf2(w), my::NextPowOf2(h));
|
||||
m_texRect = QRectF(0.0, 0.0, w / (float)size.width(), h / (float)size.height());
|
||||
|
||||
m_frontFrame = new QOpenGLFramebufferObject(size, QOpenGLFramebufferObject::Depth);
|
||||
m_backFrame = new QOpenGLFramebufferObject(size, QOpenGLFramebufferObject::Depth);
|
||||
}
|
||||
|
||||
void QtRenderOGLContext::MoveContextOnGui()
|
||||
void QtRenderOGLContext::lockFrame()
|
||||
{
|
||||
m_ctx->doneCurrent();
|
||||
m_ctx->moveToThread(m_guiThread);
|
||||
m_lock.lock();
|
||||
}
|
||||
|
||||
QtUploadOGLContext::QtUploadOGLContext(QSurface * surface, QOpenGLContext * contextToShareWith)
|
||||
QRectF const & QtRenderOGLContext::getTexRect() const
|
||||
{
|
||||
m_surface = surface;
|
||||
m_nativeContext = new QOpenGLContext();
|
||||
return m_texRect;
|
||||
}
|
||||
|
||||
ASSERT(contextToShareWith != nullptr, ());
|
||||
m_nativeContext->setShareContext(contextToShareWith);
|
||||
GLuint QtRenderOGLContext::getTextureHandle() const
|
||||
{
|
||||
if (m_frontFrame == nullptr)
|
||||
return 0;
|
||||
|
||||
m_nativeContext->setFormat(contextToShareWith->format());
|
||||
VERIFY(m_nativeContext->create(), ());
|
||||
return m_frontFrame->texture();
|
||||
}
|
||||
|
||||
void QtRenderOGLContext::unlockFrame()
|
||||
{
|
||||
m_lock.unlock();
|
||||
}
|
||||
|
||||
QtUploadOGLContext::QtUploadOGLContext(QOpenGLContext * rootContext, QOffscreenSurface * surface)
|
||||
: m_surface(surface)
|
||||
{
|
||||
m_ctx = new QOpenGLContext();
|
||||
m_ctx->setFormat(rootContext->format());
|
||||
m_ctx->setShareContext(rootContext);
|
||||
m_ctx->create();
|
||||
ASSERT(m_ctx->isValid(), ());
|
||||
}
|
||||
|
||||
QtUploadOGLContext::~QtUploadOGLContext()
|
||||
{
|
||||
delete m_nativeContext;
|
||||
delete m_ctx;
|
||||
}
|
||||
|
||||
void QtUploadOGLContext::makeCurrent()
|
||||
{
|
||||
ASSERT(m_nativeContext->isValid(), ());
|
||||
m_nativeContext->makeCurrent(m_surface);
|
||||
m_ctx->makeCurrent(m_surface);
|
||||
}
|
||||
|
||||
void QtUploadOGLContext::doneCurrent()
|
||||
{
|
||||
m_ctx->doneCurrent();
|
||||
}
|
||||
|
||||
void QtUploadOGLContext::present()
|
||||
|
|
|
|||
|
|
@ -1,57 +1,53 @@
|
|||
#pragma once
|
||||
|
||||
#include "drape/oglcontext.hpp"
|
||||
#include "std/mutex.hpp"
|
||||
|
||||
#include "std/function.hpp"
|
||||
#include "std/atomic.hpp"
|
||||
|
||||
#include <QtGui/QWindow>
|
||||
#include <QtGui/QOffscreenSurface>
|
||||
#include <QtGui/QOpenGLFramebufferObject>
|
||||
#include <QtGui/QOpenGLContext>
|
||||
|
||||
#include <QtCore/QThread>
|
||||
|
||||
class QtRenderOGLContext : public dp::OGLContext
|
||||
{
|
||||
public:
|
||||
using TRegisterThreadFn = function<void (QThread * thread)>;
|
||||
using TSwapFn = function<void ()>;
|
||||
QtRenderOGLContext(QOpenGLContext * rootContext, QOffscreenSurface * surface);
|
||||
~QtRenderOGLContext();
|
||||
|
||||
QtRenderOGLContext(QOpenGLContext * nativeContext, QThread * guiThread,
|
||||
TRegisterThreadFn const & regFn, TSwapFn const & swapFn);
|
||||
void present() override;
|
||||
void makeCurrent() override;
|
||||
void doneCurrent() override;
|
||||
void setDefaultFramebuffer() override;
|
||||
void resize(int w, int h) override;
|
||||
|
||||
void lockFrame();
|
||||
GLuint getTextureHandle() const;
|
||||
QRectF const & getTexRect() const;
|
||||
void unlockFrame();
|
||||
|
||||
private:
|
||||
QOffscreenSurface * m_surface = nullptr;
|
||||
QOpenGLContext * m_ctx = nullptr;
|
||||
|
||||
QOpenGLFramebufferObject * m_frontFrame = nullptr;
|
||||
QOpenGLFramebufferObject * m_backFrame = nullptr;
|
||||
QRectF m_texRect = QRectF(0.0, 0.0, 0.0, 0.0);
|
||||
|
||||
mutex m_lock;
|
||||
bool m_resizeLock = false;
|
||||
};
|
||||
|
||||
class QtUploadOGLContext: public dp::OGLContext
|
||||
{
|
||||
public:
|
||||
QtUploadOGLContext(QOpenGLContext * rootContext, QOffscreenSurface * surface);
|
||||
~QtUploadOGLContext();
|
||||
|
||||
void present() override;
|
||||
void makeCurrent() override;
|
||||
void doneCurrent() override;
|
||||
void setDefaultFramebuffer() override;
|
||||
|
||||
void shutDown();
|
||||
|
||||
QOpenGLContext * getNativeContext() { return m_ctx; }
|
||||
|
||||
private:
|
||||
void MoveContextOnGui();
|
||||
|
||||
private:
|
||||
QSurface * m_surface;
|
||||
QOpenGLContext * m_ctx;
|
||||
QThread * m_guiThread;
|
||||
TRegisterThreadFn m_regFn;
|
||||
TSwapFn m_swapFn;
|
||||
bool m_isRegistered;
|
||||
atomic<bool> m_shutedDown;
|
||||
};
|
||||
|
||||
class QtUploadOGLContext: public dp::OGLContext
|
||||
{
|
||||
public:
|
||||
QtUploadOGLContext(QSurface * surface, QOpenGLContext * contextToShareWith);
|
||||
~QtUploadOGLContext();
|
||||
|
||||
virtual void present();
|
||||
virtual void makeCurrent();
|
||||
virtual void setDefaultFramebuffer();
|
||||
|
||||
private:
|
||||
QOpenGLContext * m_nativeContext;
|
||||
QSurface * m_surface;
|
||||
QOpenGLContext * m_ctx = nullptr;
|
||||
QOffscreenSurface * m_surface = nullptr;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -2,13 +2,13 @@
|
|||
|
||||
#include "base/assert.hpp"
|
||||
|
||||
QtOGLContextFactory::QtOGLContextFactory(QOpenGLContext * renderContext, QThread * thread,
|
||||
TRegisterThreadFn const & regFn, TSwapFn const & swapFn)
|
||||
: m_drawContext(new QtRenderOGLContext(renderContext, thread, regFn, swapFn))
|
||||
QtOGLContextFactory::QtOGLContextFactory(QOpenGLContext * rootContext)
|
||||
: m_rootContext(rootContext)
|
||||
, m_drawContext(nullptr)
|
||||
, m_uploadContext(nullptr)
|
||||
{
|
||||
m_uploadThreadSurface = new QOffscreenSurface(renderContext->screen());
|
||||
m_uploadThreadSurface->create();
|
||||
m_uploadSurface = createSurface();
|
||||
m_drawSurface = createSurface();
|
||||
}
|
||||
|
||||
QtOGLContextFactory::~QtOGLContextFactory()
|
||||
|
|
@ -16,19 +16,63 @@ QtOGLContextFactory::~QtOGLContextFactory()
|
|||
delete m_drawContext;
|
||||
delete m_uploadContext;
|
||||
|
||||
m_uploadThreadSurface->destroy();
|
||||
delete m_uploadThreadSurface;
|
||||
m_drawSurface->destroy();
|
||||
m_uploadSurface->destroy();
|
||||
|
||||
delete m_drawSurface;
|
||||
delete m_uploadSurface;
|
||||
}
|
||||
|
||||
bool QtOGLContextFactory::LockFrame()
|
||||
{
|
||||
if (m_drawContext == nullptr)
|
||||
return false;
|
||||
|
||||
m_drawContext->lockFrame();
|
||||
return true;
|
||||
}
|
||||
|
||||
QRectF const & QtOGLContextFactory::GetTexRect() const
|
||||
{
|
||||
ASSERT(m_drawContext != nullptr, ());
|
||||
return m_drawContext->getTexRect();
|
||||
}
|
||||
|
||||
GLuint QtOGLContextFactory::GetTextureHandle() const
|
||||
{
|
||||
ASSERT(m_drawContext != nullptr, ());
|
||||
return m_drawContext->getTextureHandle();
|
||||
}
|
||||
|
||||
void QtOGLContextFactory::UnlockFrame()
|
||||
{
|
||||
ASSERT(m_drawContext != nullptr, ());
|
||||
m_drawContext->unlockFrame();
|
||||
}
|
||||
|
||||
dp::OGLContext * QtOGLContextFactory::getDrawContext()
|
||||
{
|
||||
if (m_drawContext == nullptr)
|
||||
m_drawContext = new QtRenderOGLContext(m_rootContext, m_drawSurface);
|
||||
|
||||
return m_drawContext;
|
||||
}
|
||||
|
||||
dp::OGLContext * QtOGLContextFactory::getResourcesUploadContext()
|
||||
{
|
||||
if (m_uploadContext == nullptr)
|
||||
m_uploadContext = new QtUploadOGLContext(m_uploadThreadSurface, m_drawContext->getNativeContext());
|
||||
m_uploadContext = new QtUploadOGLContext(m_rootContext, m_uploadSurface);
|
||||
|
||||
return m_uploadContext;
|
||||
}
|
||||
|
||||
QOffscreenSurface * QtOGLContextFactory::createSurface()
|
||||
{
|
||||
QSurfaceFormat format = m_rootContext->format();
|
||||
QOffscreenSurface * result = new QOffscreenSurface(m_rootContext->screen());
|
||||
result->setFormat(format);
|
||||
result->create();
|
||||
ASSERT(result->isValid(), ());
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,19 +3,19 @@
|
|||
#include "drape/oglcontextfactory.hpp"
|
||||
#include "qt/qtoglcontext.hpp"
|
||||
|
||||
#include <QtGui/QOffscreenSurface>
|
||||
#include <QtGui/QOpenGLContext>
|
||||
#include <QtGui/QOpenGLFramebufferObject>
|
||||
|
||||
class QtOGLContextFactory : public dp::OGLContextFactory
|
||||
{
|
||||
public:
|
||||
using TRegisterThreadFn = QtRenderOGLContext::TRegisterThreadFn;
|
||||
using TSwapFn = QtRenderOGLContext::TSwapFn;
|
||||
|
||||
QtOGLContextFactory(QOpenGLContext * renderContext, QThread * thread,
|
||||
TRegisterThreadFn const & regFn, TSwapFn const & swapFn);
|
||||
QtOGLContextFactory(QOpenGLContext * rootContext);
|
||||
~QtOGLContextFactory();
|
||||
|
||||
void shutDown() { m_drawContext->shutDown(); }
|
||||
bool LockFrame();
|
||||
GLuint GetTextureHandle() const;
|
||||
QRectF const & GetTexRect() const;
|
||||
void UnlockFrame();
|
||||
|
||||
virtual dp::OGLContext * getDrawContext();
|
||||
virtual dp::OGLContext * getResourcesUploadContext();
|
||||
|
|
@ -24,8 +24,12 @@ protected:
|
|||
virtual bool isDrawContextCreated() const { return m_drawContext != nullptr; }
|
||||
virtual bool isUploadContextCreated() const { return m_uploadContext != nullptr; }
|
||||
|
||||
QOffscreenSurface * createSurface();
|
||||
|
||||
private:
|
||||
QOpenGLContext * m_rootContext;
|
||||
QtRenderOGLContext * m_drawContext;
|
||||
QOffscreenSurface * m_drawSurface;
|
||||
QtUploadOGLContext * m_uploadContext;
|
||||
QOffscreenSurface * m_uploadThreadSurface;
|
||||
QOffscreenSurface * m_uploadSurface;
|
||||
};
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue