[core] Refactor HeadlessBackend

This commit is contained in:
Bruno de Oliveira Abinader
2016-11-06 20:39:13 +02:00
parent 297c303e88
commit d0ac12309b
7 changed files with 216 additions and 161 deletions

View File

@@ -1,23 +1,9 @@
#pragma once
#include <mbgl/gl/implementation.hpp>
#if MBGL_USE_QT
class QGLWidget;
#elif MBGL_USE_CGL
#include <OpenGL/OpenGL.h>
#elif MBGL_USE_GLX
typedef struct _XDisplay Display;
typedef struct __GLXcontextRec* GLXContext;
typedef struct __GLXFBConfigRec* GLXFBConfig;
typedef long unsigned int XID;
typedef XID GLXPbuffer;
#elif MBGL_USE_OSMESA
#include <GL/osmesa.h>
#endif
#include <mbgl/gl/extension.hpp>
#include <mbgl/map/backend.hpp>
#include <mbgl/gl/extension.hpp>
#include <memory>
#include <functional>
@@ -39,47 +25,34 @@ public:
void setMapChangeCallback(std::function<void(MapChange)>&& cb) { mapChangeCallback = std::move(cb); }
private:
void activateContext();
void deactivateContext();
struct Impl {
virtual ~Impl() {}
virtual void activateContext() = 0;
virtual void deactivateContext() {}
};
private:
// Implementation specific functions
static gl::glProc initializeExtension(const char*);
bool hasContext() const { return bool(impl); }
bool hasDisplay();
void createContext();
private:
void destroyContext();
void activateContext();
void deactivateContext();
std::unique_ptr<Impl> impl;
std::shared_ptr<HeadlessDisplay> display;
bool extensionsLoaded = false;
bool active = false;
#if MBGL_USE_QT
QGLWidget* glContext = nullptr;
#endif
#if MBGL_USE_CGL
CGLContextObj glContext = nullptr;
#endif
#if MBGL_USE_EAGL
void *glContext = nullptr;
#endif
#if MBGL_USE_GLX
Display *xDisplay = nullptr;
GLXFBConfig *fbConfigs = nullptr;
GLXContext glContext = nullptr;
GLXPbuffer glxPbuffer = 0;
#endif
#if MBGL_USE_OSMESA
OSMesaContext glContext = nullptr;
GLubyte fakeBuffer = 0;
#endif
std::function<void(MapChange)> mapChangeCallback;
};
} // namespace mbgl

View File

@@ -1,6 +1,7 @@
#include <mbgl/platform/default/headless_backend.hpp>
#include <mbgl/platform/default/headless_display.hpp>
#include <OpenGL/OpenGL.h>
#include <CoreFoundation/CoreFoundation.h>
#include <string>
@@ -8,6 +9,33 @@
namespace mbgl {
struct CGLImpl : public HeadlessBackend::Impl {
CGLImpl(CGLContextObj glContext_) : glContext(glContext_) {
}
~CGLImpl() {
CGLDestroyContext(glContext);
}
void activateContext() final {
CGLError error = CGLSetCurrentContext(glContext);
if (error != kCGLNoError) {
throw std::runtime_error(std::string("Switching OpenGL context failed:") +
CGLErrorString(error) + "\n");
}
}
void deactivateContext() final {
CGLError error = CGLSetCurrentContext(nullptr);
if (error != kCGLNoError) {
throw std::runtime_error(std::string("Removing OpenGL context failed:") +
CGLErrorString(error) + "\n");
}
}
CGLContextObj glContext = nullptr;
};
gl::glProc HeadlessBackend::initializeExtension(const char* name) {
static CFBundleRef framework = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl"));
if (!framework) {
@@ -21,7 +49,17 @@ gl::glProc HeadlessBackend::initializeExtension(const char* name) {
return reinterpret_cast<gl::glProc>(symbol);
}
bool HeadlessBackend::hasDisplay() {
if (!display) {
display.reset(new HeadlessDisplay);
}
return bool(display);
}
void HeadlessBackend::createContext() {
assert(!hasContext());
CGLContextObj glContext = nullptr;
CGLError error = CGLCreateContext(display->attribute<CGLPixelFormatObj>(), nullptr, &glContext);
if (error != kCGLNoError) {
throw std::runtime_error(std::string("Error creating GL context object:") +
@@ -33,26 +71,8 @@ void HeadlessBackend::createContext() {
throw std::runtime_error(std::string("Error enabling OpenGL multithreading:") +
CGLErrorString(error) + "\n");
}
}
void HeadlessBackend::destroyContext() {
CGLDestroyContext(glContext);
}
void HeadlessBackend::activateContext() {
CGLError error = CGLSetCurrentContext(glContext);
if (error != kCGLNoError) {
throw std::runtime_error(std::string("Switching OpenGL context failed:") +
CGLErrorString(error) + "\n");
}
}
void HeadlessBackend::deactivateContext() {
CGLError error = CGLSetCurrentContext(nullptr);
if (error != kCGLNoError) {
throw std::runtime_error(std::string("Removing OpenGL context failed:") +
CGLErrorString(error) + "\n");
}
impl.reset(new CGLImpl(glContext));
}
} // namespace mbgl

View File

@@ -8,6 +8,27 @@
namespace mbgl {
struct EAGLImpl : public HeadlessBackend::Impl {
EAGLImpl(EAGLContext* glContext_) : glContext(glContext_) {
[reinterpret_cast<EAGLContext*>(glContext) retain];
reinterpret_cast<EAGLContext*>(glContext).multiThreaded = YES;
}
~EAGLImpl() {
[glContext release];
}
void activateContext() {
[EAGLContext setCurrentContext:glContext];
}
void deactivateContext() {
[EAGLContext setCurrentContext:nil];
}
EAGLContext* glContext = nullptr;
};
gl::glProc HeadlessBackend::initializeExtension(const char* name) {
static CFBundleRef framework = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengles"));
if (!framework) {
@@ -21,26 +42,17 @@ gl::glProc HeadlessBackend::initializeExtension(const char* name) {
return reinterpret_cast<gl::glProc>(symbol);
}
bool HeadlessBackend::hasDisplay() {
return true;
}
void HeadlessBackend::createContext() {
glContext = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
EAGLContext* glContext = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
if (glContext == nil) {
throw std::runtime_error("Error creating GL context object");
}
[reinterpret_cast<EAGLContext*>(glContext) retain];
reinterpret_cast<EAGLContext*>(glContext).multiThreaded = YES;
}
void HeadlessBackend::destroyContext() {
[reinterpret_cast<EAGLContext*>(glContext) release];
glContext = nil;
}
void HeadlessBackend::activateContext() {
[EAGLContext setCurrentContext:reinterpret_cast<EAGLContext*>(glContext)];
}
void HeadlessBackend::deactivateContext() {
[EAGLContext setCurrentContext:nil];
impl.reset(new EAGLImpl(glContext));
}
} // namespace mbgl

View File

@@ -3,15 +3,16 @@
#include <cassert>
#include <stdexcept>
#include <type_traits>
namespace mbgl {
HeadlessBackend::HeadlessBackend() : display(std::make_shared<HeadlessDisplay>()) {
HeadlessBackend::HeadlessBackend() {
activate();
}
HeadlessBackend::HeadlessBackend(std::shared_ptr<HeadlessDisplay> display_)
: display(std::move(display_)) {
: display(std::move(display_)) {
activate();
}
@@ -23,8 +24,8 @@ HeadlessBackend::~HeadlessBackend() {
void HeadlessBackend::activate() {
active = true;
if (!glContext) {
if (!display) {
if (!hasContext()) {
if (!hasDisplay()) {
throw std::runtime_error("Display is not set");
}
createContext();
@@ -47,6 +48,21 @@ void HeadlessBackend::invalidate() {
assert(false);
}
void HeadlessBackend::destroyContext() {
assert(hasContext());
impl.reset();
}
void HeadlessBackend::activateContext() {
assert(hasContext());
impl->activateContext();
}
void HeadlessBackend::deactivateContext() {
assert(hasContext());
impl->deactivateContext();
}
void HeadlessBackend::notifyMapChange(MapChange change) {
if (mapChangeCallback) {
mapChangeCallback(change);

View File

@@ -1,47 +1,54 @@
#include <mbgl/platform/default/headless_backend.hpp>
#include <mbgl/platform/log.hpp>
#include <GL/osmesa.h>
#include <cassert>
namespace mbgl {
struct OSMesaImpl : public HeadlessBackend::Impl {
OSMesaImpl(OSMesaContext glContext_) : glContext(glContext_) {
}
~OSMesaImpl() {
if (glContext != OSMesaGetCurrentContext()) {
activateContext();
}
OSMesaDestroyContext(glContext);
}
void activateContext() final {
if (!OSMesaMakeCurrent(glContext, &fakeBuffer, GL_UNSIGNED_BYTE, 1, 1)) {
throw std::runtime_error("Switching OpenGL context failed.\n");
}
}
OSMesaContext glContext = nullptr;
GLubyte fakeBuffer = 0;
};
gl::glProc HeadlessBackend::initializeExtension(const char* name) {
return OSMesaGetProcAddress(name);
}
void HeadlessBackend::createContext() {
if (glContext == nullptr) {
#if OSMESA_MAJOR_VERSION * 100 + OSMESA_MINOR_VERSION >= 305
glContext = OSMesaCreateContextExt(OSMESA_RGBA, 16, 0, 0, nullptr);
#else
glContext = OSMesaCreateContext(OSMESA_RGBA, nullptr);
#endif
if (glContext == nullptr) {
Log::Error(Event::OpenGL, "failed to create OSMesa context");
}
}
bool HeadlessBackend::hasDisplay() {
return true;
};
void HeadlessBackend::createContext() {
assert(!hasContext());
#if OSMESA_MAJOR_VERSION * 100 + OSMESA_MINOR_VERSION >= 305
OSMesaContext glContext = OSMesaCreateContextExt(OSMESA_RGBA, 16, 0, 0, nullptr);
#else
OSMesaContext glContext = OSMesaCreateContext(OSMESA_RGBA, nullptr);
#endif
if (glContext == nullptr) {
throw std::runtime_error("Error creating GL context object.");
}
}
void HeadlessBackend::destroyContext() {
if (glContext) {
if (glContext != OSMesaGetCurrentContext()) {
activateContext();
}
OSMesaDestroyContext(glContext);
glContext = nullptr;
}
}
void HeadlessBackend::activateContext() {
if (!OSMesaMakeCurrent(glContext, &fakeBuffer, GL_UNSIGNED_BYTE, 1, 1)) {
throw std::runtime_error("Switching OpenGL context failed.\n");
}
}
void HeadlessBackend::deactivateContext() {
// no-op.
impl.reset(new OSMesaImpl(glContext));
}
} // namespace mbgl

View File

@@ -3,32 +3,71 @@
#include <mbgl/platform/log.hpp>
// #include <cassert>
#include <cassert>
#include <GL/glx.h>
namespace mbgl {
struct GLXImpl : public HeadlessBackend::Impl {
GLXImpl(GLXContext glContext_, GLXPbuffer glxPbuffer_, Display* xDisplay_, GLXFBConfig* fbConfigs_)
: glContext(glContext_),
glxPbuffer(glxPbuffer_),
xDisplay(xDisplay_),
fbConfigs(fbConfigs_) {
}
~GLXImpl() {
if (glxPbuffer) {
glXDestroyPbuffer(xDisplay, glxPbuffer);
}
glXDestroyContext(xDisplay, glContext);
}
void activateContext() final {
if (!glXMakeContextCurrent(xDisplay, glxPbuffer, glxPbuffer, glContext)) {
throw std::runtime_error("Switching OpenGL context failed.\n");
}
}
void deactivateContext() final {
if (!glXMakeContextCurrent(xDisplay, 0, 0, nullptr)) {
throw std::runtime_error("Removing OpenGL context failed.\n");
}
}
GLXContext glContext = nullptr;
GLXPbuffer glxPbuffer = 0;
// Needed for ImplDeleter.
Display* xDisplay = nullptr;
GLXFBConfig* fbConfigs = nullptr;
};
gl::glProc HeadlessBackend::initializeExtension(const char* name) {
return glXGetProcAddress(reinterpret_cast<const GLubyte*>(name));
}
void HeadlessBackend::createContext() {
xDisplay = display->attribute<Display*>();
fbConfigs = display->attribute<GLXFBConfig*>();
if (!glContext) {
// Try to create a legacy context
glContext = glXCreateNewContext(xDisplay, fbConfigs[0], GLX_RGBA_TYPE, None, True);
if (glContext) {
if (!glXIsDirect(xDisplay, glContext)) {
Log::Error(Event::OpenGL, "failed to create direct OpenGL Legacy context");
glXDestroyContext(xDisplay, glContext);
glContext = nullptr;
}
}
bool HeadlessBackend::hasDisplay() {
if (!display) {
display.reset(new HeadlessDisplay);
}
return bool(display);
};
void HeadlessBackend::createContext() {
assert(!hasContext());
Display* xDisplay = display->attribute<Display*>();
GLXFBConfig* fbConfigs = display->attribute<GLXFBConfig*>();
// Try to create a legacy context.
GLXContext glContext = glXCreateNewContext(xDisplay, fbConfigs[0], GLX_RGBA_TYPE, None, True);
if (glContext && !glXIsDirect(xDisplay, glContext)) {
Log::Error(Event::OpenGL, "failed to create direct OpenGL Legacy context");
glXDestroyContext(xDisplay, glContext);
glContext = nullptr;
}
if (glContext == nullptr) {
throw std::runtime_error("Error creating GL context object.");
}
@@ -40,28 +79,9 @@ void HeadlessBackend::createContext() {
GLX_PBUFFER_HEIGHT, 8,
None
};
glxPbuffer = glXCreatePbuffer(xDisplay, fbConfigs[0], pbufferAttributes);
}
GLXPbuffer glxPbuffer = glXCreatePbuffer(xDisplay, fbConfigs[0], pbufferAttributes);
void HeadlessBackend::destroyContext() {
if (glxPbuffer) {
glXDestroyPbuffer(xDisplay, glxPbuffer);
glxPbuffer = 0;
}
glXDestroyContext(xDisplay, glContext);
}
void HeadlessBackend::activateContext() {
if (!glXMakeContextCurrent(xDisplay, glxPbuffer, glxPbuffer, glContext)) {
throw std::runtime_error("Switching OpenGL context failed.\n");
}
}
void HeadlessBackend::deactivateContext() {
if (!glXMakeContextCurrent(xDisplay, 0, 0, nullptr)) {
throw std::runtime_error("Removing OpenGL context failed.\n");
}
impl.reset(new GLXImpl(glContext, glxPbuffer, xDisplay, fbConfigs));
}
} // namespace mbgl

View File

@@ -1,5 +1,4 @@
#include <mbgl/platform/default/headless_backend.hpp>
#include <mbgl/platform/default/headless_display.hpp>
#include <QApplication>
#include <QGLContext>
@@ -9,8 +8,22 @@
#include <QOpenGLContext>
#endif
#include <cassert>
namespace mbgl {
struct QtImpl : public HeadlessBackend::Impl {
void activateContext() final {
widget.makeCurrent();
}
void deactivateContext() final {
widget.doneCurrent();
}
QGLWidget widget;
};
gl::glProc HeadlessBackend::initializeExtension(const char* name) {
#if QT_VERSION >= 0x050000
QOpenGLContext* thisContext = QOpenGLContext::currentContext();
@@ -21,26 +34,20 @@ gl::glProc HeadlessBackend::initializeExtension(const char* name) {
#endif
}
bool HeadlessBackend::hasDisplay() {
return true;
};
void HeadlessBackend::createContext() {
assert(!hasContext());
static const char* argv[] = { "mbgl" };
static int argc = 1;
static auto* app = new QApplication(argc, const_cast<char**>(argv));
Q_UNUSED(app);
glContext = new QGLWidget;
}
void HeadlessBackend::destroyContext() {
delete glContext;
}
void HeadlessBackend::activateContext() {
glContext->makeCurrent();
}
void HeadlessBackend::deactivateContext() {
glContext->doneCurrent();
impl.reset(new QtImpl);
}
} // namespace mbgl