297 lines
10 KiB
C++
297 lines
10 KiB
C++
#include <mbgl/gl/gl.hpp>
|
|
#include <mbgl/util/string.hpp>
|
|
#include <mbgl/platform/log.hpp>
|
|
|
|
#include <cassert>
|
|
#include <iostream>
|
|
#include <unordered_map>
|
|
#include <mutex>
|
|
|
|
namespace mbgl {
|
|
namespace gl {
|
|
|
|
ExtensionFunction<void (GLuint array)>
|
|
BindVertexArray({
|
|
{"GL_ARB_vertex_array_object", "glBindVertexArray"},
|
|
{"GL_OES_vertex_array_object", "glBindVertexArrayOES"},
|
|
{"GL_APPLE_vertex_array_object", "glBindVertexArrayAPPLE"}
|
|
});
|
|
|
|
ExtensionFunction<void (GLsizei n, const GLuint* arrays)>
|
|
DeleteVertexArrays({
|
|
{"GL_ARB_vertex_array_object", "glDeleteVertexArrays"},
|
|
{"GL_OES_vertex_array_object", "glDeleteVertexArraysOES"},
|
|
{"GL_APPLE_vertex_array_object", "glDeleteVertexArraysAPPLE"}
|
|
});
|
|
|
|
ExtensionFunction<void (GLsizei n, GLuint* arrays)>
|
|
GenVertexArrays({
|
|
{"GL_ARB_vertex_array_object", "glGenVertexArrays"},
|
|
{"GL_OES_vertex_array_object", "glGenVertexArraysOES"},
|
|
{"GL_APPLE_vertex_array_object", "glGenVertexArraysAPPLE"}
|
|
});
|
|
|
|
std::vector<ExtensionFunctionBase*>& ExtensionFunctionBase::functions() {
|
|
static std::vector<ExtensionFunctionBase*> functions;
|
|
return functions;
|
|
}
|
|
|
|
static std::once_flag initializeExtensionsOnce;
|
|
|
|
void InitializeExtensions(glProc (*getProcAddress)(const char *)) {
|
|
std::call_once(initializeExtensionsOnce, [getProcAddress] {
|
|
const char * extensionsPtr = reinterpret_cast<const char *>(
|
|
MBGL_CHECK_ERROR(glGetString(GL_EXTENSIONS)));
|
|
|
|
if (!extensionsPtr)
|
|
return;
|
|
|
|
const std::string extensions = extensionsPtr;
|
|
for (auto fn : ExtensionFunctionBase::functions()) {
|
|
for (auto probe : fn->probes) {
|
|
if (extensions.find(probe.first) != std::string::npos) {
|
|
#ifdef GL_TRACK
|
|
fn->foundName = probe.second;
|
|
#endif
|
|
fn->ptr = getProcAddress(probe.second);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
namespace {
|
|
|
|
constexpr const char* stringFromError(GLenum err) {
|
|
switch (err) {
|
|
case GL_INVALID_ENUM:
|
|
return "GL_INVALID_ENUM";
|
|
|
|
case GL_INVALID_VALUE:
|
|
return "GL_INVALID_VALUE";
|
|
|
|
case GL_INVALID_OPERATION:
|
|
return "GL_INVALID_OPERATION";
|
|
|
|
case GL_INVALID_FRAMEBUFFER_OPERATION:
|
|
return "GL_INVALID_FRAMEBUFFER_OPERATION";
|
|
|
|
case GL_OUT_OF_MEMORY:
|
|
return "GL_OUT_OF_MEMORY";
|
|
|
|
#ifdef GL_TABLE_TOO_LARGE
|
|
case GL_TABLE_TOO_LARGE:
|
|
return "GL_TABLE_TOO_LARGE";
|
|
#endif
|
|
|
|
#ifdef GL_STACK_OVERFLOW
|
|
case GL_STACK_OVERFLOW:
|
|
return "GL_STACK_OVERFLOW";
|
|
#endif
|
|
|
|
#ifdef GL_STACK_UNDERFLOW
|
|
case GL_STACK_UNDERFLOW:
|
|
return "GL_STACK_UNDERFLOW";
|
|
#endif
|
|
|
|
#ifdef GL_CONTEXT_LOST
|
|
case GL_CONTEXT_LOST:
|
|
return "GL_CONTEXT_LOST";
|
|
#endif
|
|
|
|
default:
|
|
return "GL_UNKNOWN";
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void checkError(const char* cmd, const char* file, int line) {
|
|
GLenum err = GL_NO_ERROR;
|
|
if ((err = glGetError()) != GL_NO_ERROR) {
|
|
std::string message = std::string(cmd) + ": Error " + stringFromError(err);
|
|
|
|
// Check for further errors
|
|
while ((err = glGetError()) != GL_NO_ERROR) {
|
|
message += ", ";
|
|
message += stringFromError(err);
|
|
}
|
|
|
|
throw Error(message + " at " + file + ":" + util::toString(line));
|
|
}
|
|
}
|
|
|
|
} // namespace gl
|
|
} // namespace mbgl
|
|
|
|
#ifdef GL_TRACK
|
|
#undef glBindTexture
|
|
#undef glDeleteTextures
|
|
#undef glTexImage2D
|
|
#undef glClear
|
|
#undef glShaderSource
|
|
#undef glBufferData
|
|
#undef glBindBuffer
|
|
#undef glDeleteBuffers
|
|
#undef glBufferData
|
|
static unsigned int currentUsedBytes = 0;
|
|
static GLint currentBoundTexture = 0;
|
|
static std::unordered_map<GLint, unsigned int> bindingToSizeMap;
|
|
|
|
static GLuint currentArrayBuffer = 0;
|
|
static GLuint currentElementArrayBuffer = 0;
|
|
static std::unordered_map<GLint, GLsizeiptr> bufferBindingToSizeMap;
|
|
static unsigned int currentUsedBufferBytes = 0;
|
|
static unsigned int largestAmountUsedSoFar = 0;
|
|
|
|
static std::unordered_map<GLuint, GLuint> vertexArrayToArrayBufferMap;
|
|
static GLuint currentVertexArray = 0;
|
|
|
|
static std::mutex gDebugMutex;
|
|
|
|
namespace mbgl {
|
|
namespace gl {
|
|
void mbx_trapExtension(const char *) { }
|
|
void mbx_trapExtension(const char *, GLint, const char *) { }
|
|
void mbx_trapExtension(const char *, GLsizei, GLuint *) { }
|
|
void mbx_trapExtension(const char *, GLsizei, const GLuint *) { }
|
|
void mbx_trapExtension(const char *, GLenum, GLenum, GLenum, GLsizei, const GLuint *, GLboolean) { }
|
|
void mbx_trapExtension(const char *, GLenum, GLuint, GLsizei, const GLchar *) { }
|
|
void mbx_trapExtension(const char *, GLDEBUGPROC, const void *) { }
|
|
void mbx_trapExtension(const char *, GLuint, GLuint, GLuint, GLuint, GLint, const char *, const void*) { }
|
|
|
|
void mbx_trapExtension(const char *name, GLuint array) {
|
|
if(strncasecmp(name, "glBindVertexArray", 17) == 0) {
|
|
currentVertexArray = array;
|
|
std::cout << name << ": " << array << std::endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void mbx_glBindBuffer(GLenum target,
|
|
GLuint buffer) {
|
|
std::unique_lock<std::mutex> lock(gDebugMutex);
|
|
if (target == GL_ARRAY_BUFFER) {
|
|
currentArrayBuffer = buffer;
|
|
if (currentVertexArray != 0) {
|
|
if (vertexArrayToArrayBufferMap.find(currentVertexArray) != vertexArrayToArrayBufferMap.end()) {
|
|
if (vertexArrayToArrayBufferMap[currentVertexArray] != currentArrayBuffer) {
|
|
std::cout << "glBindBuffer: ERROR: You are re-binding a VAO to point to a new array buffer. This is almost certainly unintended." << std::endl;
|
|
}
|
|
}
|
|
std::cout << "glBindBuffer: binding VAO " << currentVertexArray << " to array buffer " << currentArrayBuffer << std::endl;
|
|
vertexArrayToArrayBufferMap[currentVertexArray] = currentArrayBuffer;
|
|
}
|
|
} else if (target == GL_ELEMENT_ARRAY_BUFFER) {
|
|
currentElementArrayBuffer = buffer;
|
|
}
|
|
lock.unlock();
|
|
glBindBuffer(target, buffer);
|
|
}
|
|
|
|
void mbx_glDeleteBuffers(GLsizei n,
|
|
const GLuint * buffers) {
|
|
std::unique_lock<std::mutex> lock(gDebugMutex);
|
|
for (int i = 0; i < n; ++i) {
|
|
if (bufferBindingToSizeMap.find(buffers[i]) != bufferBindingToSizeMap.end()) {
|
|
currentUsedBufferBytes -= bufferBindingToSizeMap[buffers[i]];
|
|
std::cout << "GL glDeleteBuffers: " << buffers[i] << " freeing " << bufferBindingToSizeMap[buffers[i]] << " bytes current total " << currentUsedBufferBytes << "\n";
|
|
bufferBindingToSizeMap.erase(buffers[i]);
|
|
}
|
|
}
|
|
lock.unlock();
|
|
glDeleteBuffers(n, buffers);
|
|
}
|
|
|
|
void mbx_glBufferData(GLenum target,
|
|
GLsizeiptr size,
|
|
const GLvoid * data,
|
|
GLenum usage) {
|
|
std::unique_lock<std::mutex> lock(gDebugMutex);
|
|
GLuint currentBinding = 0;
|
|
if (target == GL_ARRAY_BUFFER) {
|
|
currentBinding = currentArrayBuffer;
|
|
} else if (target == GL_ELEMENT_ARRAY_BUFFER) {
|
|
currentBinding = currentElementArrayBuffer;
|
|
}
|
|
if (bufferBindingToSizeMap.find(currentBinding) != bufferBindingToSizeMap.end()) {
|
|
currentUsedBufferBytes -= bufferBindingToSizeMap[currentBinding];
|
|
std::cout << "GL glBufferData: " << currentBinding << " freeing " << bufferBindingToSizeMap[currentBinding] << " bytes current total " << currentUsedBufferBytes << "\n";
|
|
}
|
|
bufferBindingToSizeMap[currentBinding] = size;
|
|
currentUsedBufferBytes += size;
|
|
if (currentUsedBufferBytes > largestAmountUsedSoFar) {
|
|
largestAmountUsedSoFar = currentUsedBufferBytes;
|
|
}
|
|
std::cout << "GL glBufferData: " << currentBinding << " using " << bufferBindingToSizeMap[currentBinding] << " bytes current total " << currentUsedBufferBytes << " high water mark " << largestAmountUsedSoFar << "\n";
|
|
lock.unlock();
|
|
|
|
glBufferData(target, size, data, usage);
|
|
}
|
|
|
|
|
|
void mbx_glShaderSource(GLuint shader,
|
|
GLsizei count,
|
|
const GLchar * const *string,
|
|
const GLint *length) {
|
|
//std::cout << "Calling glShaderSource: " << *string << std::endl;
|
|
glShaderSource(shader, count, const_cast<const GLchar **>(string), length);
|
|
}
|
|
|
|
void mbx_glClear(GLbitfield mask) {
|
|
//std::cout << "Calling glClear" << std::endl;
|
|
glClear(mask);
|
|
}
|
|
|
|
void mbx_glBindTexture( GLenum target,
|
|
GLuint texture) {
|
|
std::unique_lock<std::mutex> lock(gDebugMutex);
|
|
if (target == GL_TEXTURE_2D) {
|
|
currentBoundTexture = texture;
|
|
}
|
|
lock.unlock();
|
|
glBindTexture(target, texture);
|
|
}
|
|
|
|
void mbx_glDeleteTextures(GLsizei n,
|
|
const GLuint * textures) {
|
|
std::unique_lock<std::mutex> lock(gDebugMutex);
|
|
for (int i = 0; i < n; ++i) {
|
|
if (bindingToSizeMap.find(textures[i]) != bindingToSizeMap.end()) {
|
|
std::cout << "GL deleteTexture:" << textures[i] << "freeing " << bindingToSizeMap[textures[i]] << " bytes current total " << currentUsedBytes << "\n";
|
|
currentUsedBytes -= bindingToSizeMap[textures[i]];
|
|
bindingToSizeMap.erase(textures[i]);
|
|
}
|
|
}
|
|
lock.unlock();
|
|
glDeleteTextures(n, textures);
|
|
}
|
|
|
|
void mbx_glTexImage2D(GLenum target,
|
|
GLint level,
|
|
GLint internalformat,
|
|
GLsizei width,
|
|
GLsizei height,
|
|
GLint border,
|
|
GLenum format,
|
|
GLenum type,
|
|
const GLvoid * data) {
|
|
std::unique_lock<std::mutex> lock(gDebugMutex);
|
|
if (internalformat == GL_RGBA &&
|
|
type == GL_UNSIGNED_BYTE) {
|
|
if (bindingToSizeMap.find(currentBoundTexture) != bindingToSizeMap.end()) {
|
|
currentUsedBytes -= bindingToSizeMap[currentBoundTexture];
|
|
std::cout << "GL glTexImage2D: " << currentBoundTexture << " freeing " << bindingToSizeMap[currentBoundTexture] << " bytes current total " << currentUsedBytes << "\n";
|
|
}
|
|
bindingToSizeMap[currentBoundTexture] = width * height * 4;
|
|
currentUsedBytes += bindingToSizeMap[currentBoundTexture];
|
|
std::cout << "GL glTexImage2D: " << currentBoundTexture << " freeing " << bindingToSizeMap[currentBoundTexture] << " bytes current total " << currentUsedBytes << "\n";
|
|
}
|
|
lock.unlock();
|
|
glTexImage2D(target, level, internalformat, width, height, border, format, type, data);
|
|
}
|
|
#endif
|
|
|