Merge branch 'master' into shader-performance
This commit is contained in:
18
platform/darwin/application_root.mm
Normal file
18
platform/darwin/application_root.mm
Normal file
@@ -0,0 +1,18 @@
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
#include <mbgl/platform/platform.hpp>
|
||||
|
||||
namespace mbgl {
|
||||
namespace platform {
|
||||
|
||||
// Returns the path to the default shader cache on this system.
|
||||
std::string applicationRoot() {
|
||||
static const std::string root = []() -> std::string {
|
||||
NSString *path = [[[NSBundle mainBundle] resourceURL] path];
|
||||
return {[path cStringUsingEncoding : NSUTF8StringEncoding],
|
||||
[path lengthOfBytesUsingEncoding:NSUTF8StringEncoding]};
|
||||
}();
|
||||
return root;
|
||||
}
|
||||
}
|
||||
}
|
||||
15
platform/default/application_root.cpp
Normal file
15
platform/default/application_root.cpp
Normal file
@@ -0,0 +1,15 @@
|
||||
#include <mbgl/platform/platform.hpp>
|
||||
|
||||
#include <mbgl/util/uv.hpp>
|
||||
|
||||
namespace mbgl {
|
||||
namespace platform {
|
||||
|
||||
// Returns the path the application root.
|
||||
std::string applicationRoot() {
|
||||
static const std::string root = uv::cwd();
|
||||
return root;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
222
platform/default/asset_request_libuv.cpp
Normal file
222
platform/default/asset_request_libuv.cpp
Normal file
@@ -0,0 +1,222 @@
|
||||
#include <mbgl/storage/asset_request.hpp>
|
||||
#include <mbgl/storage/response.hpp>
|
||||
#include <mbgl/platform/platform.hpp>
|
||||
#include <mbgl/util/std.hpp>
|
||||
|
||||
#include <uv.h>
|
||||
|
||||
#include <limits>
|
||||
|
||||
namespace mbgl {
|
||||
|
||||
struct AssetRequestBaton {
|
||||
AssetRequestBaton(AssetRequest *request_, const std::string &path, uv_loop_t *loop);
|
||||
~AssetRequestBaton();
|
||||
|
||||
void cancel();
|
||||
static void file_opened(uv_fs_t *req);
|
||||
static void file_stated(uv_fs_t *req);
|
||||
static void file_read(uv_fs_t *req);
|
||||
static void file_closed(uv_fs_t *req);
|
||||
static void notify_error(uv_fs_t *req);
|
||||
static void cleanup(uv_fs_t *req);
|
||||
|
||||
const std::thread::id thread_id;
|
||||
AssetRequest *request = nullptr;
|
||||
uv_fs_t req;
|
||||
uv_file fd = -1;
|
||||
bool canceled = false;
|
||||
std::string body;
|
||||
uv_buf_t buffer;
|
||||
};
|
||||
|
||||
AssetRequestBaton::AssetRequestBaton(AssetRequest *request_, const std::string &path, uv_loop_t *loop)
|
||||
: thread_id(std::this_thread::get_id()), request(request_) {
|
||||
req.data = this;
|
||||
uv_fs_open(loop, &req, path.c_str(), O_RDONLY, S_IRUSR, file_opened);
|
||||
}
|
||||
|
||||
AssetRequestBaton::~AssetRequestBaton() {
|
||||
}
|
||||
|
||||
void AssetRequestBaton::cancel() {
|
||||
canceled = true;
|
||||
|
||||
// uv_cancel fails frequently when the request has already been started.
|
||||
// In that case, we have to let it complete and check the canceled bool
|
||||
// instead.
|
||||
uv_cancel((uv_req_t *)&req);
|
||||
}
|
||||
|
||||
void AssetRequestBaton::notify_error(uv_fs_t *req) {
|
||||
AssetRequestBaton *ptr = (AssetRequestBaton *)req->data;
|
||||
assert(ptr->thread_id == std::this_thread::get_id());
|
||||
|
||||
if (ptr->request && req->result < 0 && !ptr->canceled && req->result != UV_ECANCELED) {
|
||||
ptr->request->response = util::make_unique<Response>();
|
||||
ptr->request->response->code = req->result == UV_ENOENT ? 404 : 500;
|
||||
#if UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR <= 10
|
||||
ptr->request->response->message = uv_strerror(uv_last_error(req->loop));
|
||||
#else
|
||||
ptr->request->response->message = uv_strerror(int(req->result));
|
||||
#endif
|
||||
ptr->request->notify();
|
||||
}
|
||||
}
|
||||
|
||||
void AssetRequestBaton::file_opened(uv_fs_t *req) {
|
||||
AssetRequestBaton *ptr = (AssetRequestBaton *)req->data;
|
||||
assert(ptr->thread_id == std::this_thread::get_id());
|
||||
|
||||
if (req->result < 0) {
|
||||
// Opening failed or was canceled. There isn't much left we can do.
|
||||
notify_error(req);
|
||||
cleanup(req);
|
||||
} else {
|
||||
const uv_file fd = uv_file(req->result);
|
||||
|
||||
// We're going to reuse this handle, so we need to cleanup first.
|
||||
uv_fs_req_cleanup(req);
|
||||
|
||||
if (ptr->canceled || !ptr->request) {
|
||||
// Either the AssetRequest object has been destructed, or the
|
||||
// request was canceled.
|
||||
uv_fs_close(req->loop, req, fd, file_closed);
|
||||
} else {
|
||||
ptr->fd = fd;
|
||||
uv_fs_fstat(req->loop, req, fd, file_stated);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AssetRequestBaton::file_stated(uv_fs_t *req) {
|
||||
AssetRequestBaton *ptr = (AssetRequestBaton *)req->data;
|
||||
assert(ptr->thread_id == std::this_thread::get_id());
|
||||
|
||||
if (req->result != 0 || ptr->canceled || !ptr->request) {
|
||||
// Stating failed or was canceled. We already have an open file handle
|
||||
// though, which we'll have to close.
|
||||
notify_error(req);
|
||||
|
||||
uv_fs_req_cleanup(req);
|
||||
uv_fs_close(req->loop, req, ptr->fd, file_closed);
|
||||
} else {
|
||||
#if UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR <= 10
|
||||
const uv_statbuf_t *stat = static_cast<const uv_statbuf_t *>(req->ptr);
|
||||
#else
|
||||
const uv_stat_t *stat = static_cast<const uv_stat_t *>(req->ptr);
|
||||
#endif
|
||||
if (stat->st_size > std::numeric_limits<int>::max()) {
|
||||
// File is too large for us to open this way because uv_buf's only support unsigned
|
||||
// ints as maximum size.
|
||||
if (ptr->request) {
|
||||
ptr->request->response = util::make_unique<Response>();
|
||||
ptr->request->response->code = UV_EFBIG;
|
||||
#if UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR <= 10
|
||||
ptr->request->response->message = uv_strerror(uv_err_t {UV_EFBIG, 0});
|
||||
#else
|
||||
ptr->request->response->message = uv_strerror(UV_EFBIG);
|
||||
#endif
|
||||
ptr->request->notify();
|
||||
}
|
||||
|
||||
uv_fs_req_cleanup(req);
|
||||
uv_fs_close(req->loop, req, ptr->fd, file_closed);
|
||||
} else {
|
||||
const unsigned int size = (unsigned int)(stat->st_size);
|
||||
ptr->body.resize(size);
|
||||
ptr->buffer = uv_buf_init(const_cast<char *>(ptr->body.data()), size);
|
||||
uv_fs_req_cleanup(req);
|
||||
#if UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR <= 10
|
||||
uv_fs_read(req->loop, req, ptr->fd, ptr->buffer.base, ptr->buffer.len, -1, file_read);
|
||||
#else
|
||||
uv_fs_read(req->loop, req, ptr->fd, &ptr->buffer, 1, 0, file_read);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AssetRequestBaton::file_read(uv_fs_t *req) {
|
||||
AssetRequestBaton *ptr = (AssetRequestBaton *)req->data;
|
||||
assert(ptr->thread_id == std::this_thread::get_id());
|
||||
|
||||
if (req->result < 0 || ptr->canceled || !ptr->request) {
|
||||
// Stating failed or was canceled. We already have an open file handle
|
||||
// though, which we'll have to close.
|
||||
notify_error(req);
|
||||
} else {
|
||||
// File was successfully read.
|
||||
if (ptr->request) {
|
||||
ptr->request->response = util::make_unique<Response>();
|
||||
ptr->request->response->code = 200;
|
||||
ptr->request->response->data = std::move(ptr->body);
|
||||
ptr->request->notify();
|
||||
}
|
||||
}
|
||||
|
||||
uv_fs_req_cleanup(req);
|
||||
uv_fs_close(req->loop, req, ptr->fd, file_closed);
|
||||
}
|
||||
|
||||
void AssetRequestBaton::file_closed(uv_fs_t *req) {
|
||||
assert(((AssetRequestBaton *)req->data)->thread_id == std::this_thread::get_id());
|
||||
|
||||
if (req->result < 0) {
|
||||
// Closing the file failed. But there isn't anything we can do.
|
||||
}
|
||||
|
||||
cleanup(req);
|
||||
}
|
||||
|
||||
void AssetRequestBaton::cleanup(uv_fs_t *req) {
|
||||
AssetRequestBaton *ptr = (AssetRequestBaton *)req->data;
|
||||
assert(ptr->thread_id == std::this_thread::get_id());
|
||||
|
||||
if (ptr->request) {
|
||||
ptr->request->ptr = nullptr;
|
||||
}
|
||||
|
||||
uv_fs_req_cleanup(req);
|
||||
delete ptr;
|
||||
}
|
||||
|
||||
|
||||
AssetRequest::AssetRequest(const std::string &path_, uv_loop_t *loop)
|
||||
: BaseRequest(path_) {
|
||||
if (!path.empty() && path[0] == '/') {
|
||||
// This is an absolute path. We don't allow this. Note that this is not a way to absolutely
|
||||
// prevent access to resources outside the application bundle; e.g. there could be symlinks
|
||||
// in the application bundle that link to outside. We don't care about these.
|
||||
response = util::make_unique<Response>();
|
||||
response->code = 403;
|
||||
response->message = "Path is outside the application bundle";
|
||||
notify();
|
||||
} else {
|
||||
// Note: The AssetRequestBaton object is deleted in AssetRequestBaton::cleanup().
|
||||
ptr = new AssetRequestBaton(this, platform::applicationRoot() + "/" + path, loop);
|
||||
}
|
||||
}
|
||||
|
||||
void AssetRequest::cancel() {
|
||||
assert(thread_id == std::this_thread::get_id());
|
||||
|
||||
if (ptr) {
|
||||
ptr->cancel();
|
||||
|
||||
// When deleting a AssetRequest object with a uv_fs_* call is in progress, we are making sure
|
||||
// that the callback doesn't accidentally reference this object again.
|
||||
ptr->request = nullptr;
|
||||
ptr = nullptr;
|
||||
}
|
||||
|
||||
notify();
|
||||
}
|
||||
|
||||
AssetRequest::~AssetRequest() {
|
||||
assert(thread_id == std::this_thread::get_id());
|
||||
cancel();
|
||||
|
||||
// Note: The AssetRequestBaton object is deleted in AssetRequestBaton::cleanup().
|
||||
}
|
||||
|
||||
}
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
GLFWView::GLFWView(bool fullscreen_) : fullscreen(fullscreen_) {
|
||||
#ifdef NVIDIA
|
||||
glDiscardFramebufferEXT = (PFNGLDISCARDFRAMEBUFFEREXTPROC)glfwGetProcAddress("glDiscardFramebufferEXT");
|
||||
glDiscardFramebufferEXT = reinterpret_cast<PFNGLDISCARDFRAMEBUFFEREXTPROC>(glfwGetProcAddress("glDiscardFramebufferEXT"));
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -61,34 +61,34 @@ void GLFWView::initialize(mbgl::Map *map_) {
|
||||
|
||||
int width, height;
|
||||
glfwGetWindowSize(window, &width, &height);
|
||||
int fb_width, fb_height;
|
||||
glfwGetFramebufferSize(window, &fb_width, &fb_height);
|
||||
int fbWidth, fbHeight;
|
||||
glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
|
||||
|
||||
resize(window, 0, 0);
|
||||
|
||||
glfwSetCursorPosCallback(window, mousemove);
|
||||
glfwSetMouseButtonCallback(window, mouseclick);
|
||||
glfwSetCursorPosCallback(window, mouseMove);
|
||||
glfwSetMouseButtonCallback(window, mouseClick);
|
||||
glfwSetWindowSizeCallback(window, resize);
|
||||
glfwSetFramebufferSizeCallback(window, resize);
|
||||
glfwSetScrollCallback(window, scroll);
|
||||
glfwSetKeyCallback(window, key);
|
||||
|
||||
const std::string extensions = (char *)MBGL_CHECK_ERROR(glGetString(GL_EXTENSIONS));
|
||||
const std::string extensions = reinterpret_cast<const char *>(MBGL_CHECK_ERROR(glGetString(GL_EXTENSIONS)));
|
||||
{
|
||||
using namespace mbgl;
|
||||
|
||||
if (extensions.find("GL_KHR_debug") != std::string::npos) {
|
||||
gl::DebugMessageControl = (gl::PFNGLDEBUGMESSAGECONTROLPROC)glfwGetProcAddress("glDebugMessageControl");
|
||||
gl::DebugMessageInsert = (gl::PFNGLDEBUGMESSAGEINSERTPROC)glfwGetProcAddress("glDebugMessageInsert");
|
||||
gl::DebugMessageCallback = (gl::PFNGLDEBUGMESSAGECALLBACKPROC)glfwGetProcAddress("glDebugMessageCallback");
|
||||
gl::GetDebugMessageLog = (gl::PFNGLGETDEBUGMESSAGELOGPROC)glfwGetProcAddress("glGetDebugMessageLog");
|
||||
gl::GetPointerv = (gl::PFNGLGETPOINTERVPROC)glfwGetProcAddress("glGetPointerv");
|
||||
gl::PushDebugGroup = (gl::PFNGLPUSHDEBUGGROUPPROC)glfwGetProcAddress("glPushDebugGroup");
|
||||
gl::PopDebugGroup = (gl::PFNGLPOPDEBUGGROUPPROC)glfwGetProcAddress("glPopDebugGroup");
|
||||
gl::ObjectLabel = (gl::PFNGLOBJECTLABELPROC)glfwGetProcAddress("glObjectLabel");
|
||||
gl::GetObjectLabel = (gl::PFNGLGETOBJECTLABELPROC)glfwGetProcAddress("glGetObjectLabel");
|
||||
gl::ObjectPtrLabel = (gl::PFNGLOBJECTPTRLABELPROC)glfwGetProcAddress("glObjectPtrLabel");
|
||||
gl::GetObjectPtrLabel = (gl::PFNGLGETOBJECTPTRLABELPROC)glfwGetProcAddress("glGetObjectPtrLabel");
|
||||
gl::DebugMessageControl = reinterpret_cast<gl::PFNGLDEBUGMESSAGECONTROLPROC>(glfwGetProcAddress("glDebugMessageControl"));
|
||||
gl::DebugMessageInsert = reinterpret_cast<gl::PFNGLDEBUGMESSAGEINSERTPROC>(glfwGetProcAddress("glDebugMessageInsert"));
|
||||
gl::DebugMessageCallback = reinterpret_cast<gl::PFNGLDEBUGMESSAGECALLBACKPROC>(glfwGetProcAddress("glDebugMessageCallback"));
|
||||
gl::GetDebugMessageLog = reinterpret_cast<gl::PFNGLGETDEBUGMESSAGELOGPROC>(glfwGetProcAddress("glGetDebugMessageLog"));
|
||||
gl::GetPointerv = reinterpret_cast<gl::PFNGLGETPOINTERVPROC>(glfwGetProcAddress("glGetPointerv"));
|
||||
gl::PushDebugGroup = reinterpret_cast<gl::PFNGLPUSHDEBUGGROUPPROC>(glfwGetProcAddress("glPushDebugGroup"));
|
||||
gl::PopDebugGroup = reinterpret_cast<gl::PFNGLPOPDEBUGGROUPPROC>(glfwGetProcAddress("glPopDebugGroup"));
|
||||
gl::ObjectLabel = reinterpret_cast<gl::PFNGLOBJECTLABELPROC>(glfwGetProcAddress("glObjectLabel"));
|
||||
gl::GetObjectLabel = reinterpret_cast<gl::PFNGLGETOBJECTLABELPROC>(glfwGetProcAddress("glGetObjectLabel"));
|
||||
gl::ObjectPtrLabel = reinterpret_cast<gl::PFNGLOBJECTPTRLABELPROC>(glfwGetProcAddress("glObjectPtrLabel"));
|
||||
gl::GetObjectPtrLabel = reinterpret_cast<gl::PFNGLGETOBJECTPTRLABELPROC>(glfwGetProcAddress("glGetObjectPtrLabel"));
|
||||
assert(gl::DebugMessageControl != nullptr);
|
||||
assert(gl::DebugMessageInsert != nullptr);
|
||||
assert(gl::DebugMessageCallback != nullptr);
|
||||
@@ -102,11 +102,11 @@ void GLFWView::initialize(mbgl::Map *map_) {
|
||||
assert(gl::GetObjectPtrLabel != nullptr);
|
||||
} else {
|
||||
if (extensions.find("GL_ARB_debug_output") != std::string::npos) {
|
||||
gl::DebugMessageControl = (gl::PFNGLDEBUGMESSAGECONTROLPROC)glfwGetProcAddress("glDebugMessageControlARB");
|
||||
gl::DebugMessageInsert = (gl::PFNGLDEBUGMESSAGEINSERTPROC)glfwGetProcAddress("glDebugMessageInsertARB");
|
||||
gl::DebugMessageCallback = (gl::PFNGLDEBUGMESSAGECALLBACKPROC)glfwGetProcAddress("glDebugMessageCallbackARB");
|
||||
gl::GetDebugMessageLog = (gl::PFNGLGETDEBUGMESSAGELOGPROC)glfwGetProcAddress("glGetDebugMessageLogARB");
|
||||
gl::GetPointerv = (gl::PFNGLGETPOINTERVPROC)glfwGetProcAddress("glGetPointerv");
|
||||
gl::DebugMessageControl = reinterpret_cast<gl::PFNGLDEBUGMESSAGECONTROLPROC>(glfwGetProcAddress("glDebugMessageControlARB"));
|
||||
gl::DebugMessageInsert = reinterpret_cast<gl::PFNGLDEBUGMESSAGEINSERTPROC>(glfwGetProcAddress("glDebugMessageInsertARB"));
|
||||
gl::DebugMessageCallback = reinterpret_cast<gl::PFNGLDEBUGMESSAGECALLBACKPROC>(glfwGetProcAddress("glDebugMessageCallbackARB"));
|
||||
gl::GetDebugMessageLog = reinterpret_cast<gl::PFNGLGETDEBUGMESSAGELOGPROC>(glfwGetProcAddress("glGetDebugMessageLogARB"));
|
||||
gl::GetPointerv = reinterpret_cast<gl::PFNGLGETPOINTERVPROC>(glfwGetProcAddress("glGetPointerv"));
|
||||
assert(gl::DebugMessageControl != nullptr);
|
||||
assert(gl::DebugMessageInsert != nullptr);
|
||||
assert(gl::DebugMessageCallback != nullptr);
|
||||
@@ -115,36 +115,36 @@ void GLFWView::initialize(mbgl::Map *map_) {
|
||||
}
|
||||
|
||||
if (extensions.find("GL_EXT_debug_marker") != std::string::npos) {
|
||||
gl::InsertEventMarkerEXT = (gl::PFNGLINSERTEVENTMARKEREXTPROC)glfwGetProcAddress("glInsertEventMarkerEXT");
|
||||
gl::PushGroupMarkerEXT = (gl::PFNGLPUSHGROUPMARKEREXTPROC)glfwGetProcAddress("glPushGroupMarkerEXT");
|
||||
gl::PopGroupMarkerEXT = (gl::PFNGLPOPGROUPMARKEREXTPROC)glfwGetProcAddress("glPopGroupMarkerEXT");
|
||||
gl::InsertEventMarkerEXT = reinterpret_cast<gl::PFNGLINSERTEVENTMARKEREXTPROC>(glfwGetProcAddress("glInsertEventMarkerEXT"));
|
||||
gl::PushGroupMarkerEXT = reinterpret_cast<gl::PFNGLPUSHGROUPMARKEREXTPROC>(glfwGetProcAddress("glPushGroupMarkerEXT"));
|
||||
gl::PopGroupMarkerEXT = reinterpret_cast<gl::PFNGLPOPGROUPMARKEREXTPROC>(glfwGetProcAddress("glPopGroupMarkerEXT"));
|
||||
assert(gl::InsertEventMarkerEXT != nullptr);
|
||||
assert(gl::PushGroupMarkerEXT != nullptr);
|
||||
assert(gl::PopGroupMarkerEXT != nullptr);
|
||||
}
|
||||
|
||||
if (extensions.find("GL_EXT_debug_label") != std::string::npos) {
|
||||
gl::LabelObjectEXT = (gl::PFNGLLABELOBJECTEXTPROC)glfwGetProcAddress("glLabelObjectEXT");
|
||||
gl::GetObjectLabelEXT = (gl::PFNGLGETOBJECTLABELEXTPROC)glfwGetProcAddress("glGetObjectLabelEXT");
|
||||
gl::LabelObjectEXT = reinterpret_cast<gl::PFNGLLABELOBJECTEXTPROC>(glfwGetProcAddress("glLabelObjectEXT"));
|
||||
gl::GetObjectLabelEXT = reinterpret_cast<gl::PFNGLGETOBJECTLABELEXTPROC>(glfwGetProcAddress("glGetObjectLabelEXT"));
|
||||
assert(gl::LabelObjectEXT != nullptr);
|
||||
assert(gl::GetObjectLabelEXT != nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
if (extensions.find("GL_ARB_vertex_array_object") != std::string::npos) {
|
||||
gl::BindVertexArray = (gl::PFNGLBINDVERTEXARRAYPROC)glfwGetProcAddress("glBindVertexArray");
|
||||
gl::DeleteVertexArrays = (gl::PFNGLDELETEVERTEXARRAYSPROC)glfwGetProcAddress("glDeleteVertexArrays");
|
||||
gl::GenVertexArrays = (gl::PFNGLGENVERTEXARRAYSPROC)glfwGetProcAddress("glGenVertexArrays");
|
||||
gl::IsVertexArray = (gl::PFNGLISVERTEXARRAYPROC)glfwGetProcAddress("glIsVertexArray");
|
||||
gl::BindVertexArray = reinterpret_cast<gl::PFNGLBINDVERTEXARRAYPROC>(glfwGetProcAddress("glBindVertexArray"));
|
||||
gl::DeleteVertexArrays = reinterpret_cast<gl::PFNGLDELETEVERTEXARRAYSPROC>(glfwGetProcAddress("glDeleteVertexArrays"));
|
||||
gl::GenVertexArrays = reinterpret_cast<gl::PFNGLGENVERTEXARRAYSPROC>(glfwGetProcAddress("glGenVertexArrays"));
|
||||
gl::IsVertexArray = reinterpret_cast<gl::PFNGLISVERTEXARRAYPROC>(glfwGetProcAddress("glIsVertexArray"));
|
||||
assert(gl::BindVertexArray != nullptr);
|
||||
assert(gl::DeleteVertexArrays != nullptr);
|
||||
assert(gl::GenVertexArrays != nullptr);
|
||||
assert(gl::IsVertexArray != nullptr);
|
||||
} else if (extensions.find("GL_APPLE_vertex_array_object") != std::string::npos) {
|
||||
gl::BindVertexArray = (gl::PFNGLBINDVERTEXARRAYPROC)glfwGetProcAddress("glBindVertexArrayAPPLE");
|
||||
gl::DeleteVertexArrays = (gl::PFNGLDELETEVERTEXARRAYSPROC)glfwGetProcAddress("glDeleteVertexArraysAPPLE");
|
||||
gl::GenVertexArrays = (gl::PFNGLGENVERTEXARRAYSPROC)glfwGetProcAddress("glGenVertexArraysAPPLE");
|
||||
gl::IsVertexArray = (gl::PFNGLISVERTEXARRAYPROC)glfwGetProcAddress("glIsVertexArrayAPPLE");
|
||||
gl::BindVertexArray = reinterpret_cast<gl::PFNGLBINDVERTEXARRAYPROC>(glfwGetProcAddress("glBindVertexArrayAPPLE"));
|
||||
gl::DeleteVertexArrays = reinterpret_cast<gl::PFNGLDELETEVERTEXARRAYSPROC>(glfwGetProcAddress("glDeleteVertexArraysAPPLE"));
|
||||
gl::GenVertexArrays = reinterpret_cast<gl::PFNGLGENVERTEXARRAYSPROC>(glfwGetProcAddress("glGenVertexArraysAPPLE"));
|
||||
gl::IsVertexArray = reinterpret_cast<gl::PFNGLISVERTEXARRAYPROC>(glfwGetProcAddress("glIsVertexArrayAPPLE"));
|
||||
assert(gl::BindVertexArray != nullptr);
|
||||
assert(gl::DeleteVertexArrays != nullptr);
|
||||
assert(gl::GenVertexArrays != nullptr);
|
||||
@@ -152,12 +152,16 @@ void GLFWView::initialize(mbgl::Map *map_) {
|
||||
}
|
||||
|
||||
if (extensions.find("GL_ARB_get_program_binary") != std::string::npos) {
|
||||
gl::GetProgramBinary = (gl::PFNGLGETPROGRAMBINARYPROC)glfwGetProcAddress("glGetProgramBinary");
|
||||
gl::ProgramBinary = (gl::PFNGLPROGRAMBINARYPROC)glfwGetProcAddress("glProgramBinary");
|
||||
gl::ProgramParameteri = (gl::PFNGLPROGRAMPARAMETERIPROC)glfwGetProcAddress("glProgramParameteri");
|
||||
assert(gl::GetProgramBinary != nullptr);
|
||||
assert(gl::ProgramBinary != nullptr);
|
||||
assert(gl::ProgramParameteri != nullptr);
|
||||
GLint numBinaryFormats;
|
||||
MBGL_CHECK_ERROR(glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &numBinaryFormats));
|
||||
if (numBinaryFormats > 0) {
|
||||
gl::GetProgramBinary = reinterpret_cast<gl::PFNGLGETPROGRAMBINARYPROC>(glfwGetProcAddress("glGetProgramBinary"));
|
||||
gl::ProgramBinary = reinterpret_cast<gl::PFNGLPROGRAMBINARYPROC>(glfwGetProcAddress("glProgramBinary"));
|
||||
gl::ProgramParameteri = reinterpret_cast<gl::PFNGLPROGRAMPARAMETERIPROC>(glfwGetProcAddress("glProgramParameteri"));
|
||||
assert(gl::GetProgramBinary != nullptr);
|
||||
assert(gl::ProgramBinary != nullptr);
|
||||
assert(gl::ProgramParameteri != nullptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -165,7 +169,7 @@ void GLFWView::initialize(mbgl::Map *map_) {
|
||||
}
|
||||
|
||||
void GLFWView::key(GLFWwindow *window, int key, int /*scancode*/, int action, int mods) {
|
||||
GLFWView *view = (GLFWView *)glfwGetWindowUserPointer(window);
|
||||
GLFWView *view = reinterpret_cast<GLFWView *>(glfwGetWindowUserPointer(window));
|
||||
|
||||
if (action == GLFW_RELEASE) {
|
||||
switch (key) {
|
||||
@@ -193,17 +197,17 @@ void GLFWView::key(GLFWwindow *window, int key, int /*scancode*/, int action, in
|
||||
}
|
||||
}
|
||||
|
||||
void GLFWView::scroll(GLFWwindow *window, double /*xoffset*/, double yoffset) {
|
||||
GLFWView *view = (GLFWView *)glfwGetWindowUserPointer(window);
|
||||
double delta = yoffset * 40;
|
||||
void GLFWView::scroll(GLFWwindow *window, double /*xOffset*/, double yOffset) {
|
||||
GLFWView *view = reinterpret_cast<GLFWView *>(glfwGetWindowUserPointer(window));
|
||||
double delta = yOffset * 40;
|
||||
|
||||
bool is_wheel = delta != 0 && std::fmod(delta, 4.000244140625) == 0;
|
||||
bool isWheel = delta != 0 && std::fmod(delta, 4.000244140625) == 0;
|
||||
|
||||
double absdelta = delta < 0 ? -delta : delta;
|
||||
double scale = 2.0 / (1.0 + std::exp(-absdelta / 100.0));
|
||||
double absDelta = delta < 0 ? -delta : delta;
|
||||
double scale = 2.0 / (1.0 + std::exp(-absDelta / 100.0));
|
||||
|
||||
// Make the scroll wheel a bit slower.
|
||||
if (!is_wheel) {
|
||||
if (!isWheel) {
|
||||
scale = (scale - 1.0) / 2.0 + 1.0;
|
||||
}
|
||||
|
||||
@@ -213,22 +217,20 @@ void GLFWView::scroll(GLFWwindow *window, double /*xoffset*/, double yoffset) {
|
||||
}
|
||||
|
||||
view->map->startScaling();
|
||||
view->map->scaleBy(scale, view->last_x, view->last_y);
|
||||
view->map->scaleBy(scale, view->lastX, view->lastY);
|
||||
}
|
||||
|
||||
void GLFWView::resize(GLFWwindow *window, int, int) {
|
||||
GLFWView *view = (GLFWView *)glfwGetWindowUserPointer(window);
|
||||
void GLFWView::resize(GLFWwindow *window, int width, int height ) {
|
||||
GLFWView *view = reinterpret_cast<GLFWView *>(glfwGetWindowUserPointer(window));
|
||||
|
||||
int width, height;
|
||||
glfwGetWindowSize(window, &width, &height);
|
||||
int fb_width, fb_height;
|
||||
glfwGetFramebufferSize(window, &fb_width, &fb_height);
|
||||
int fbWidth, fbHeight;
|
||||
glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
|
||||
|
||||
view->map->resize(width, height, (float)fb_width / (float)width, fb_width, fb_height);
|
||||
view->map->resize(width, height, static_cast<float>(fbWidth) / static_cast<float>(width), fbWidth, fbHeight);
|
||||
}
|
||||
|
||||
void GLFWView::mouseclick(GLFWwindow *window, int button, int action, int modifiers) {
|
||||
GLFWView *view = (GLFWView *)glfwGetWindowUserPointer(window);
|
||||
void GLFWView::mouseClick(GLFWwindow *window, int button, int action, int modifiers) {
|
||||
GLFWView *view = reinterpret_cast<GLFWView *>(glfwGetWindowUserPointer(window));
|
||||
|
||||
if (button == GLFW_MOUSE_BUTTON_RIGHT ||
|
||||
(button == GLFW_MOUSE_BUTTON_LEFT && modifiers & GLFW_MOD_CONTROL)) {
|
||||
@@ -242,33 +244,33 @@ void GLFWView::mouseclick(GLFWwindow *window, int button, int action, int modifi
|
||||
if (action == GLFW_RELEASE) {
|
||||
view->map->stopPanning();
|
||||
double now = glfwGetTime();
|
||||
if (now - view->last_click < 0.4 /* ms */) {
|
||||
if (now - view->lastClick < 0.4 /* ms */) {
|
||||
if (modifiers & GLFW_MOD_SHIFT) {
|
||||
view->map->scaleBy(0.5, view->last_x, view->last_y, 0.5);
|
||||
view->map->scaleBy(0.5, view->lastX, view->lastY, 0.5);
|
||||
} else {
|
||||
view->map->scaleBy(2.0, view->last_x, view->last_y, 0.5);
|
||||
view->map->scaleBy(2.0, view->lastX, view->lastY, 0.5);
|
||||
}
|
||||
}
|
||||
view->last_click = now;
|
||||
view->lastClick = now;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GLFWView::mousemove(GLFWwindow *window, double x, double y) {
|
||||
GLFWView *view = (GLFWView *)glfwGetWindowUserPointer(window);
|
||||
void GLFWView::mouseMove(GLFWwindow *window, double x, double y) {
|
||||
GLFWView *view = reinterpret_cast<GLFWView *>(glfwGetWindowUserPointer(window));
|
||||
if (view->tracking) {
|
||||
double dx = x - view->last_x;
|
||||
double dy = y - view->last_y;
|
||||
double dx = x - view->lastX;
|
||||
double dy = y - view->lastY;
|
||||
if (dx || dy) {
|
||||
view->map->startPanning();
|
||||
view->map->moveBy(dx, dy);
|
||||
}
|
||||
} else if (view->rotating) {
|
||||
view->map->startRotating();
|
||||
view->map->rotateBy(view->last_x, view->last_y, x, y);
|
||||
view->map->rotateBy(view->lastX, view->lastY, x, y);
|
||||
}
|
||||
view->last_x = x;
|
||||
view->last_y = y;
|
||||
view->lastX = x;
|
||||
view->lastY = y;
|
||||
}
|
||||
|
||||
int GLFWView::run() {
|
||||
@@ -291,11 +293,11 @@ int GLFWView::run() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
void GLFWView::make_active() {
|
||||
void GLFWView::activate() {
|
||||
glfwMakeContextCurrent(window);
|
||||
}
|
||||
|
||||
void GLFWView::make_inactive() {
|
||||
void GLFWView::deactivate() {
|
||||
glfwMakeContextCurrent(nullptr);
|
||||
}
|
||||
|
||||
@@ -307,20 +309,20 @@ void GLFWView::swap() {
|
||||
glfwPostEmptyEvent();
|
||||
}
|
||||
|
||||
void GLFWView::notify_map_change(mbgl::MapChange /*change*/, mbgl::timestamp /*delay*/) {
|
||||
void GLFWView::notifyMapChange(mbgl::MapChange /*change*/, mbgl::timestamp /*delay*/) {
|
||||
// no-op
|
||||
}
|
||||
|
||||
void GLFWView::fps() {
|
||||
static int frames = 0;
|
||||
static double time_elapsed = 0;
|
||||
static double timeElapsed = 0;
|
||||
|
||||
frames++;
|
||||
double current_time = glfwGetTime();
|
||||
double currentTime = glfwGetTime();
|
||||
|
||||
if (current_time - time_elapsed >= 1) {
|
||||
fprintf(stderr, "FPS: %4.2f\n", frames / (current_time - time_elapsed));
|
||||
time_elapsed = current_time;
|
||||
if (currentTime - timeElapsed >= 1) {
|
||||
fprintf(stderr, "FPS: %4.2f\n", frames / (currentTime - timeElapsed));
|
||||
timeElapsed = currentTime;
|
||||
frames = 0;
|
||||
}
|
||||
}
|
||||
@@ -331,71 +333,71 @@ namespace platform {
|
||||
double elapsed() { return glfwGetTime(); }
|
||||
|
||||
#ifndef GL_ES_VERSION_2_0
|
||||
void show_debug_image(std::string name, const char *data, size_t width, size_t height) {
|
||||
void showDebugImage(std::string name, const char *data, size_t width, size_t height) {
|
||||
glfwInit();
|
||||
|
||||
static GLFWwindow *debug_window = nullptr;
|
||||
if (!debug_window) {
|
||||
debug_window = glfwCreateWindow(width, height, name.c_str(), nullptr, nullptr);
|
||||
if (!debug_window) {
|
||||
static GLFWwindow *debugWindow = nullptr;
|
||||
if (!debugWindow) {
|
||||
debugWindow = glfwCreateWindow(width, height, name.c_str(), nullptr, nullptr);
|
||||
if (!debugWindow) {
|
||||
glfwTerminate();
|
||||
fprintf(stderr, "Failed to initialize window\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
GLFWwindow *current_window = glfwGetCurrentContext();
|
||||
GLFWwindow *currentWindow = glfwGetCurrentContext();
|
||||
|
||||
glfwSetWindowSize(debug_window, width, height);
|
||||
glfwMakeContextCurrent(debug_window);
|
||||
glfwSetWindowSize(debugWindow, width, height);
|
||||
glfwMakeContextCurrent(debugWindow);
|
||||
|
||||
int fb_width, fb_height;
|
||||
glfwGetFramebufferSize(debug_window, &fb_width, &fb_height);
|
||||
float scale = (float)fb_width / (float)width;
|
||||
int fbWidth, fbHeight;
|
||||
glfwGetFramebufferSize(debugWindow, &fbWidth, &fbHeight);
|
||||
float scale = static_cast<float>(fbWidth) / static_cast<float>(width);
|
||||
|
||||
MBGL_CHECK_ERROR(glPixelZoom(scale, -scale));
|
||||
MBGL_CHECK_ERROR(glRasterPos2f(-1.0f, 1.0f));
|
||||
MBGL_CHECK_ERROR(glDrawPixels(width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, data));
|
||||
glfwSwapBuffers(debug_window);
|
||||
glfwSwapBuffers(debugWindow);
|
||||
|
||||
glfwMakeContextCurrent(current_window);
|
||||
glfwMakeContextCurrent(currentWindow);
|
||||
}
|
||||
|
||||
|
||||
void show_color_debug_image(std::string name, const char *data, size_t logical_width, size_t logical_height, size_t width, size_t height) {
|
||||
void showColorDebugImage(std::string name, const char *data, size_t logicalWidth, size_t logicalHeight, size_t width, size_t height) {
|
||||
glfwInit();
|
||||
|
||||
static GLFWwindow *debug_window = nullptr;
|
||||
if (!debug_window) {
|
||||
debug_window = glfwCreateWindow(logical_width, logical_height, name.c_str(), nullptr, nullptr);
|
||||
if (!debug_window) {
|
||||
static GLFWwindow *debugWindow = nullptr;
|
||||
if (!debugWindow) {
|
||||
debugWindow = glfwCreateWindow(logicalWidth, logicalHeight, name.c_str(), nullptr, nullptr);
|
||||
if (!debugWindow) {
|
||||
glfwTerminate();
|
||||
fprintf(stderr, "Failed to initialize window\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
GLFWwindow *current_window = glfwGetCurrentContext();
|
||||
GLFWwindow *currentWindow = glfwGetCurrentContext();
|
||||
|
||||
glfwSetWindowSize(debug_window, logical_width, logical_height);
|
||||
glfwMakeContextCurrent(debug_window);
|
||||
glfwSetWindowSize(debugWindow, logicalWidth, logicalHeight);
|
||||
glfwMakeContextCurrent(debugWindow);
|
||||
|
||||
int fb_width, fb_height;
|
||||
glfwGetFramebufferSize(debug_window, &fb_width, &fb_height);
|
||||
float x_scale = (float)fb_width / (float)width;
|
||||
float y_scale = (float)fb_height / (float)height;
|
||||
int fbWidth, fbHeight;
|
||||
glfwGetFramebufferSize(debugWindow, &fbWidth, &fbHeight);
|
||||
float xScale = static_cast<float>(fbWidth) / static_cast<float>(width);
|
||||
float yScale = static_cast<float>(fbHeight) / static_cast<float>(height);
|
||||
|
||||
MBGL_CHECK_ERROR(glClearColor(0.8, 0.8, 0.8, 1));
|
||||
MBGL_CHECK_ERROR(glClear(GL_COLOR_BUFFER_BIT));
|
||||
MBGL_CHECK_ERROR(glEnable(GL_BLEND));
|
||||
MBGL_CHECK_ERROR(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
|
||||
|
||||
MBGL_CHECK_ERROR(glPixelZoom(x_scale, -y_scale));
|
||||
MBGL_CHECK_ERROR(glPixelZoom(xScale, -yScale));
|
||||
MBGL_CHECK_ERROR(glRasterPos2f(-1.0f, 1.0f));
|
||||
MBGL_CHECK_ERROR(glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, data));
|
||||
glfwSwapBuffers(debug_window);
|
||||
glfwSwapBuffers(debugWindow);
|
||||
|
||||
glfwMakeContextCurrent(current_window);
|
||||
glfwMakeContextCurrent(currentWindow);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
@@ -11,9 +11,9 @@ HeadlessDisplay::HeadlessDisplay() {
|
||||
// If it is, use kCGLOGLPVersion_3_2_Core and enable that extension.
|
||||
CGLPixelFormatAttribute attributes[] = {
|
||||
kCGLPFAOpenGLProfile,
|
||||
(CGLPixelFormatAttribute) kCGLOGLPVersion_Legacy,
|
||||
static_cast<CGLPixelFormatAttribute>(kCGLOGLPVersion_Legacy),
|
||||
kCGLPFAAccelerated,
|
||||
(CGLPixelFormatAttribute) 0
|
||||
static_cast<CGLPixelFormatAttribute>(0)
|
||||
};
|
||||
|
||||
GLint num;
|
||||
@@ -38,7 +38,7 @@ HeadlessDisplay::HeadlessDisplay() {
|
||||
throw std::runtime_error("Failed to open X display.");
|
||||
}
|
||||
|
||||
const char *extensions = (char *)glXQueryServerString(xDisplay, DefaultScreen(xDisplay), GLX_EXTENSIONS);
|
||||
const char *extensions = reinterpret_cast<const char *>(glXQueryServerString(xDisplay, DefaultScreen(xDisplay), GLX_EXTENSIONS));
|
||||
if (!extensions) {
|
||||
throw std::runtime_error("Cannot read GLX extensions.");
|
||||
}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
#include <mbgl/platform/default/headless_view.hpp>
|
||||
#include <mbgl/platform/default/headless_display.hpp>
|
||||
#include <mbgl/platform/log.hpp>
|
||||
|
||||
#include <mbgl/util/std.hpp>
|
||||
|
||||
@@ -9,12 +10,6 @@
|
||||
#include <cstring>
|
||||
#include <cassert>
|
||||
|
||||
#if MBGL_USE_GLX
|
||||
#ifdef GLX_ARB_create_context
|
||||
static PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB = nullptr;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef MBGL_USE_CGL
|
||||
#include <CoreFoundation/CoreFoundation.h>
|
||||
|
||||
@@ -29,7 +24,7 @@ CGLProc CGLGetProcAddress(const char *proc) {
|
||||
}
|
||||
|
||||
CFStringRef name = CFStringCreateWithCString(kCFAllocatorDefault, proc, kCFStringEncodingASCII);
|
||||
CGLProc symbol = (CGLProc)CFBundleGetFunctionPointerForName(framework, name);
|
||||
CGLProc symbol = reinterpret_cast<CGLProc>(CFBundleGetFunctionPointerForName(framework, name));
|
||||
CFRelease(name);
|
||||
return symbol;
|
||||
}
|
||||
@@ -51,89 +46,40 @@ HeadlessView::HeadlessView(std::shared_ptr<HeadlessDisplay> display)
|
||||
}
|
||||
|
||||
void HeadlessView::loadExtensions() {
|
||||
make_active();
|
||||
const std::string extensions = (char *)MBGL_CHECK_ERROR(glGetString(GL_EXTENSIONS));
|
||||
activate();
|
||||
const char *extension_ptr = reinterpret_cast<const char *>(MBGL_CHECK_ERROR(glGetString(GL_EXTENSIONS)));
|
||||
|
||||
if (extension_ptr) {
|
||||
const std::string extensions = extension_ptr;
|
||||
|
||||
#ifdef MBGL_USE_CGL
|
||||
if (extensions.find("GL_APPLE_vertex_array_object") != std::string::npos) {
|
||||
gl::BindVertexArray = (gl::PFNGLBINDVERTEXARRAYPROC)CGLGetProcAddress("glBindVertexArrayAPPLE");
|
||||
gl::DeleteVertexArrays = (gl::PFNGLDELETEVERTEXARRAYSPROC)CGLGetProcAddress("glDeleteVertexArraysAPPLE");
|
||||
gl::GenVertexArrays = (gl::PFNGLGENVERTEXARRAYSPROC)CGLGetProcAddress("glGenVertexArraysAPPLE");
|
||||
gl::IsVertexArray = (gl::PFNGLISVERTEXARRAYPROC)CGLGetProcAddress("glIsVertexArrayAPPLE");
|
||||
assert(gl::BindVertexArray != nullptr);
|
||||
assert(gl::DeleteVertexArrays != nullptr);
|
||||
assert(gl::GenVertexArrays != nullptr);
|
||||
assert(gl::IsVertexArray != nullptr);
|
||||
}
|
||||
if (extensions.find("GL_APPLE_vertex_array_object") != std::string::npos) {
|
||||
gl::BindVertexArray = reinterpret_cast<gl::PFNGLBINDVERTEXARRAYPROC>(CGLGetProcAddress("glBindVertexArrayAPPLE"));
|
||||
gl::DeleteVertexArrays = reinterpret_cast<gl::PFNGLDELETEVERTEXARRAYSPROC>(CGLGetProcAddress("glDeleteVertexArraysAPPLE"));
|
||||
gl::GenVertexArrays = reinterpret_cast<gl::PFNGLGENVERTEXARRAYSPROC>(CGLGetProcAddress("glGenVertexArraysAPPLE"));
|
||||
gl::IsVertexArray = reinterpret_cast<gl::PFNGLISVERTEXARRAYPROC>(CGLGetProcAddress("glIsVertexArrayAPPLE"));
|
||||
assert(gl::BindVertexArray != nullptr);
|
||||
assert(gl::DeleteVertexArrays != nullptr);
|
||||
assert(gl::GenVertexArrays != nullptr);
|
||||
assert(gl::IsVertexArray != nullptr);
|
||||
}
|
||||
#endif
|
||||
#ifdef MBGL_USE_GLX
|
||||
if (extensions.find("GL_ARB_vertex_array_object") != std::string::npos) {
|
||||
gl::BindVertexArray = (gl::PFNGLBINDVERTEXARRAYPROC)glXGetProcAddress((const GLubyte *)"glBindVertexArray");
|
||||
gl::DeleteVertexArrays = (gl::PFNGLDELETEVERTEXARRAYSPROC)glXGetProcAddress((const GLubyte *)"glDeleteVertexArrays");
|
||||
gl::GenVertexArrays = (gl::PFNGLGENVERTEXARRAYSPROC)glXGetProcAddress((const GLubyte *)"glGenVertexArrays");
|
||||
gl::IsVertexArray = (gl::PFNGLISVERTEXARRAYPROC)glXGetProcAddress((const GLubyte *)"glIsVertexArray");
|
||||
assert(gl::BindVertexArray != nullptr);
|
||||
assert(gl::DeleteVertexArrays != nullptr);
|
||||
assert(gl::GenVertexArrays != nullptr);
|
||||
assert(gl::IsVertexArray != nullptr);
|
||||
}
|
||||
#endif
|
||||
|
||||
make_inactive();
|
||||
}
|
||||
|
||||
|
||||
#if MBGL_USE_GLX
|
||||
#ifdef GLX_ARB_create_context
|
||||
|
||||
// These are all of the OpenGL Core profile version that we know about.
|
||||
struct core_profile_version { int major, minor; };
|
||||
static const core_profile_version coreProfileVersions[] = {
|
||||
{4, 5},
|
||||
{4, 4},
|
||||
{4, 3},
|
||||
{4, 2},
|
||||
{4, 1},
|
||||
{4, 0},
|
||||
{3, 3},
|
||||
{3, 2},
|
||||
{3, 1},
|
||||
{3, 0},
|
||||
{0, 0},
|
||||
};
|
||||
|
||||
GLXContext createCoreProfile(Display *dpy, GLXFBConfig fbconfig) {
|
||||
static bool contextCreationFailed = false;
|
||||
GLXContext ctx = 0;
|
||||
|
||||
// Set the Error Handler to avoid crashing the program when the context creation fails.
|
||||
// It is expected that some context creation attempts fail, e.g. because the OpenGL
|
||||
// implementation does not support the version we're requesting.
|
||||
int (*previousErrorHandler)(Display *, XErrorEvent *) = XSetErrorHandler([](Display *, XErrorEvent *) {
|
||||
contextCreationFailed = true;
|
||||
return 0;
|
||||
});
|
||||
|
||||
// Try to create core profiles from the highest known version on down.
|
||||
for (int i = 0; !ctx && coreProfileVersions[i].major; i++) {
|
||||
contextCreationFailed = false;
|
||||
const int contextFlags[] = {
|
||||
GLX_CONTEXT_MAJOR_VERSION_ARB, coreProfileVersions[i].major,
|
||||
GLX_CONTEXT_MINOR_VERSION_ARB, coreProfileVersions[i].minor,
|
||||
0
|
||||
};
|
||||
ctx = glXCreateContextAttribsARB(dpy, fbconfig, 0, True, contextFlags);
|
||||
if (contextCreationFailed) {
|
||||
ctx = 0;
|
||||
if (extensions.find("GL_ARB_vertex_array_object") != std::string::npos) {
|
||||
gl::BindVertexArray = reinterpret_cast<gl::PFNGLBINDVERTEXARRAYPROC>(glXGetProcAddress((const GLubyte *)"glBindVertexArray"));
|
||||
gl::DeleteVertexArrays = reinterpret_cast<gl::PFNGLDELETEVERTEXARRAYSPROC>(glXGetProcAddress((const GLubyte *)"glDeleteVertexArrays"));
|
||||
gl::GenVertexArrays = reinterpret_cast<gl::PFNGLGENVERTEXARRAYSPROC>(glXGetProcAddress((const GLubyte *)"glGenVertexArrays"));
|
||||
gl::IsVertexArray = reinterpret_cast<gl::PFNGLISVERTEXARRAYPROC>(glXGetProcAddress((const GLubyte *)"glIsVertexArray"));
|
||||
assert(gl::BindVertexArray != nullptr);
|
||||
assert(gl::DeleteVertexArrays != nullptr);
|
||||
assert(gl::GenVertexArrays != nullptr);
|
||||
assert(gl::IsVertexArray != nullptr);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// Restore the old error handler.
|
||||
XSetErrorHandler(previousErrorHandler);
|
||||
return ctx;
|
||||
deactivate();
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
void HeadlessView::createContext() {
|
||||
#if MBGL_USE_CGL
|
||||
@@ -149,27 +95,15 @@ void HeadlessView::createContext() {
|
||||
#endif
|
||||
|
||||
#if MBGL_USE_GLX
|
||||
#ifdef GLX_ARB_create_context
|
||||
if (glXCreateContextAttribsARB == nullptr) {
|
||||
glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glXGetProcAddressARB((const GLubyte *)"glXCreateContextAttribsARB");
|
||||
}
|
||||
#endif
|
||||
|
||||
xDisplay = display_->xDisplay;
|
||||
fbConfigs = display_->fbConfigs;
|
||||
|
||||
#ifdef GLX_ARB_create_context
|
||||
if (glXCreateContextAttribsARB) {
|
||||
// Try to create a core profile context.
|
||||
glContext = createCoreProfile(xDisplay, fbConfigs[0]);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!glContext) {
|
||||
// Try to create a legacy context
|
||||
glContext = glXCreateNewContext(xDisplay, fbConfigs[0], GLX_RGBA_TYPE, 0, True);
|
||||
if (glContext) {
|
||||
if (!glXIsDirect(xDisplay, glContext)) {
|
||||
mbgl::Log::Error(mbgl::Event::OpenGL, "Failed to create direct OpenGL Legacy context");
|
||||
glXDestroyContext(xDisplay, glContext);
|
||||
glContext = 0;
|
||||
}
|
||||
@@ -192,7 +126,7 @@ void HeadlessView::createContext() {
|
||||
}
|
||||
|
||||
void HeadlessView::resize(uint16_t width, uint16_t height, float pixelRatio) {
|
||||
clear_buffers();
|
||||
clearBuffers();
|
||||
|
||||
width_ = width;
|
||||
height_ = height;
|
||||
@@ -201,7 +135,7 @@ void HeadlessView::resize(uint16_t width, uint16_t height, float pixelRatio) {
|
||||
const unsigned int w = width_ * pixelRatio_;
|
||||
const unsigned int h = height_ * pixelRatio_;
|
||||
|
||||
make_active();
|
||||
activate();
|
||||
|
||||
// Create depth/stencil buffer
|
||||
MBGL_CHECK_ERROR(glGenRenderbuffersEXT(1, &fboDepthStencil));
|
||||
@@ -237,7 +171,7 @@ void HeadlessView::resize(uint16_t width, uint16_t height, float pixelRatio) {
|
||||
throw std::runtime_error(error.str());
|
||||
}
|
||||
|
||||
make_inactive();
|
||||
deactivate();
|
||||
}
|
||||
|
||||
std::unique_ptr<uint32_t[]> HeadlessView::readPixels() {
|
||||
@@ -246,9 +180,9 @@ std::unique_ptr<uint32_t[]> HeadlessView::readPixels() {
|
||||
|
||||
auto pixels = util::make_unique<uint32_t[]>(w * h);
|
||||
|
||||
make_active();
|
||||
activate();
|
||||
MBGL_CHECK_ERROR(glReadPixels(0, 0, width_, height_, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get()));
|
||||
make_inactive();
|
||||
deactivate();
|
||||
|
||||
const int stride = w * 4;
|
||||
auto tmp = util::make_unique<char[]>(stride);
|
||||
@@ -262,8 +196,8 @@ std::unique_ptr<uint32_t[]> HeadlessView::readPixels() {
|
||||
return pixels;
|
||||
}
|
||||
|
||||
void HeadlessView::clear_buffers() {
|
||||
make_active();
|
||||
void HeadlessView::clearBuffers() {
|
||||
activate();
|
||||
|
||||
MBGL_CHECK_ERROR(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
|
||||
|
||||
@@ -282,11 +216,11 @@ void HeadlessView::clear_buffers() {
|
||||
fboDepthStencil = 0;
|
||||
}
|
||||
|
||||
make_inactive();
|
||||
deactivate();
|
||||
}
|
||||
|
||||
HeadlessView::~HeadlessView() {
|
||||
clear_buffers();
|
||||
clearBuffers();
|
||||
|
||||
#if MBGL_USE_CGL
|
||||
CGLDestroyContext(glContext);
|
||||
@@ -306,11 +240,11 @@ void HeadlessView::notify() {
|
||||
// no-op
|
||||
}
|
||||
|
||||
void HeadlessView::notify_map_change(mbgl::MapChange /*change*/, mbgl::timestamp /*delay*/) {
|
||||
void HeadlessView::notifyMapChange(mbgl::MapChange /*change*/, mbgl::timestamp /*delay*/) {
|
||||
// no-op
|
||||
}
|
||||
|
||||
void HeadlessView::make_active() {
|
||||
void HeadlessView::activate() {
|
||||
#if MBGL_USE_CGL
|
||||
CGLError error = CGLSetCurrentContext(glContext);
|
||||
if (error != kCGLNoError) {
|
||||
@@ -325,7 +259,7 @@ void HeadlessView::make_active() {
|
||||
#endif
|
||||
}
|
||||
|
||||
void HeadlessView::make_inactive() {
|
||||
void HeadlessView::deactivate() {
|
||||
#if MBGL_USE_CGL
|
||||
CGLError error = CGLSetCurrentContext(nullptr);
|
||||
if (error != kCGLNoError) {
|
||||
|
||||
Reference in New Issue
Block a user