Google Git
Sign in
android / platform / tools / gpu / a2a12ceb46cae934815bf94301e7d628d87c41d6 / . / cc / gapir / gfx_api.cpp
blob: b4de41b5c398ede1a54948ab1033e4c3aaeed455 [file] [log] [blame]
////////////////////////////////////////////////////////////////////////////////
// Automatically generated file. Do not modify!
////////////////////////////////////////////////////////////////////////////////
#include "gfx_api.h"
#include "interpreter.h"
#include "stack.h"
#include <gapic/get_gfx_proc_address.h>
#include <gapic/log.h>
#define __STDC_FORMAT_MACROS
#include <inttypes.h>
namespace gapir {
namespace gfxapi {
namespace {
bool callEglInitialize(Stack* stack, bool pushReturn) {
int* minor = stack->pop<int*>();
int* major = stack->pop<int*>();
void* dpy = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("eglInitialize(%p, %p, %p)\n", dpy, major, minor);
if (eglInitialize != nullptr) {
int return_value = eglInitialize(dpy, major, minor);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("eglInitialize returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function eglInitialize\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function eglInitialize\n");
return false;
}
}
bool callEglCreateContext(Stack* stack, bool pushReturn) {
int* attrib_list = stack->pop<int*>();
void* share_context = stack->pop<void*>();
void* config = stack->pop<void*>();
void* display = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("eglCreateContext(%p, %p, %p, %p)\n", display, config, share_context,
attrib_list);
if (eglCreateContext != nullptr) {
void* return_value = eglCreateContext(display, config, share_context, attrib_list);
GAPID_INFO("Returned: %p\n", return_value);
if (pushReturn) {
stack->push<void*>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("eglCreateContext returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function eglCreateContext\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function eglCreateContext\n");
return false;
}
}
bool callEglMakeCurrent(Stack* stack, bool pushReturn) {
void* context = stack->pop<void*>();
void* read = stack->pop<void*>();
void* draw = stack->pop<void*>();
void* display = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("eglMakeCurrent(%p, %p, %p, %p)\n", display, draw, read, context);
if (eglMakeCurrent != nullptr) {
int return_value = eglMakeCurrent(display, draw, read, context);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("eglMakeCurrent returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function eglMakeCurrent\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function eglMakeCurrent\n");
return false;
}
}
bool callEglSwapBuffers(Stack* stack, bool pushReturn) {
void* surface = stack->pop<void*>();
void* display = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("eglSwapBuffers(%p, %p)\n", display, surface);
if (eglSwapBuffers != nullptr) {
int return_value = eglSwapBuffers(display, surface);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("eglSwapBuffers returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function eglSwapBuffers\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function eglSwapBuffers\n");
return false;
}
}
bool callEglQuerySurface(Stack* stack, bool pushReturn) {
int* value = stack->pop<int*>();
int attribute = stack->pop<int>();
void* surface = stack->pop<void*>();
void* display = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("eglQuerySurface(%p, %p, %d, %p)\n", display, surface, attribute, value);
if (eglQuerySurface != nullptr) {
int return_value = eglQuerySurface(display, surface, attribute, value);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("eglQuerySurface returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function eglQuerySurface\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function eglQuerySurface\n");
return false;
}
}
bool callGlXCreateContext(Stack* stack, bool pushReturn) {
bool direct = stack->pop<bool>();
void* shareList = stack->pop<void*>();
void* vis = stack->pop<void*>();
void* dpy = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("glXCreateContext(%p, %p, %p, %d)\n", dpy, vis, shareList, direct);
if (glXCreateContext != nullptr) {
void* return_value = glXCreateContext(dpy, vis, shareList, direct);
GAPID_INFO("Returned: %p\n", return_value);
if (pushReturn) {
stack->push<void*>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glXCreateContext returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glXCreateContext\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glXCreateContext\n");
return false;
}
}
bool callGlXCreateNewContext(Stack* stack, bool pushReturn) {
bool direct = stack->pop<bool>();
void* shared = stack->pop<void*>();
uint32_t type = stack->pop<uint32_t>();
void* fbconfig = stack->pop<void*>();
void* display = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("glXCreateNewContext(%p, %p, %" PRIu32 ", %p, %d)\n", display, fbconfig, type,
shared, direct);
if (glXCreateNewContext != nullptr) {
void* return_value = glXCreateNewContext(display, fbconfig, type, shared, direct);
GAPID_INFO("Returned: %p\n", return_value);
if (pushReturn) {
stack->push<void*>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glXCreateNewContext returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glXCreateNewContext\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glXCreateNewContext\n");
return false;
}
}
bool callGlXMakeContextCurrent(Stack* stack, bool pushReturn) {
void* ctx = stack->pop<void*>();
void* read = stack->pop<void*>();
void* draw = stack->pop<void*>();
void* display = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("glXMakeContextCurrent(%p, %p, %p, %p)\n", display, draw, read, ctx);
if (glXMakeContextCurrent != nullptr) {
int return_value = glXMakeContextCurrent(display, draw, read, ctx);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glXMakeContextCurrent returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glXMakeContextCurrent\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glXMakeContextCurrent\n");
return false;
}
}
bool callGlXMakeCurrent(Stack* stack, bool pushReturn) {
void* ctx = stack->pop<void*>();
void* drawable = stack->pop<void*>();
void* display = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("glXMakeCurrent(%p, %p, %p)\n", display, drawable, ctx);
if (glXMakeCurrent != nullptr) {
int return_value = glXMakeCurrent(display, drawable, ctx);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glXMakeCurrent returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glXMakeCurrent\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glXMakeCurrent\n");
return false;
}
}
bool callGlXSwapBuffers(Stack* stack, bool pushReturn) {
void* drawable = stack->pop<void*>();
void* display = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("glXSwapBuffers(%p, %p)\n", display, drawable);
if (glXSwapBuffers != nullptr) {
glXSwapBuffers(display, drawable);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glXSwapBuffers returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glXSwapBuffers\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glXSwapBuffers\n");
return false;
}
}
bool callGlXQueryDrawable(Stack* stack, bool pushReturn) {
int* value = stack->pop<int*>();
int attribute = stack->pop<int>();
void* draw = stack->pop<void*>();
void* display = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("glXQueryDrawable(%p, %p, %d, %p)\n", display, draw, attribute, value);
if (glXQueryDrawable != nullptr) {
int return_value = glXQueryDrawable(display, draw, attribute, value);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glXQueryDrawable returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glXQueryDrawable\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glXQueryDrawable\n");
return false;
}
}
bool callWglCreateContext(Stack* stack, bool pushReturn) {
void* hdc = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("wglCreateContext(%p)\n", hdc);
if (wglCreateContext != nullptr) {
void* return_value = wglCreateContext(hdc);
GAPID_INFO("Returned: %p\n", return_value);
if (pushReturn) {
stack->push<void*>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("wglCreateContext returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function wglCreateContext\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function wglCreateContext\n");
return false;
}
}
bool callWglCreateContextAttribsARB(Stack* stack, bool pushReturn) {
int* attribList = stack->pop<int*>();
void* hShareContext = stack->pop<void*>();
void* hdc = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("wglCreateContextAttribsARB(%p, %p, %p)\n", hdc, hShareContext, attribList);
if (wglCreateContextAttribsARB != nullptr) {
void* return_value = wglCreateContextAttribsARB(hdc, hShareContext, attribList);
GAPID_INFO("Returned: %p\n", return_value);
if (pushReturn) {
stack->push<void*>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("wglCreateContextAttribsARB returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function wglCreateContextAttribsARB\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function wglCreateContextAttribsARB\n");
return false;
}
}
bool callWglMakeCurrent(Stack* stack, bool pushReturn) {
void* hglrc = stack->pop<void*>();
void* hdc = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("wglMakeCurrent(%p, %p)\n", hdc, hglrc);
if (wglMakeCurrent != nullptr) {
int return_value = wglMakeCurrent(hdc, hglrc);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("wglMakeCurrent returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function wglMakeCurrent\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function wglMakeCurrent\n");
return false;
}
}
bool callWglSwapBuffers(Stack* stack, bool pushReturn) {
void* hdc = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("wglSwapBuffers(%p)\n", hdc);
if (wglSwapBuffers != nullptr) {
wglSwapBuffers(hdc);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("wglSwapBuffers returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function wglSwapBuffers\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function wglSwapBuffers\n");
return false;
}
}
bool callCGLCreateContext(Stack* stack, bool pushReturn) {
void** ctx = stack->pop<void**>();
void* share = stack->pop<void*>();
void* pix = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("CGLCreateContext(%p, %p, %p)\n", pix, share, ctx);
if (CGLCreateContext != nullptr) {
int return_value = CGLCreateContext(pix, share, ctx);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("CGLCreateContext returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function CGLCreateContext\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function CGLCreateContext\n");
return false;
}
}
bool callCGLSetCurrentContext(Stack* stack, bool pushReturn) {
void* ctx = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("CGLSetCurrentContext(%p)\n", ctx);
if (CGLSetCurrentContext != nullptr) {
int return_value = CGLSetCurrentContext(ctx);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("CGLSetCurrentContext returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function CGLSetCurrentContext\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function CGLSetCurrentContext\n");
return false;
}
}
bool callCGLGetSurface(Stack* stack, bool pushReturn) {
int32_t* sid = stack->pop<int32_t*>();
int32_t* wid = stack->pop<int32_t*>();
void** cid = stack->pop<void**>();
void* ctx = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("CGLGetSurface(%p, %p, %p, %p)\n", ctx, cid, wid, sid);
if (CGLGetSurface != nullptr) {
int return_value = CGLGetSurface(ctx, cid, wid, sid);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("CGLGetSurface returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function CGLGetSurface\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function CGLGetSurface\n");
return false;
}
}
bool callCGSGetSurfaceBounds(Stack* stack, bool pushReturn) {
double* bounds = stack->pop<double*>();
int32_t sid = stack->pop<int32_t>();
int32_t wid = stack->pop<int32_t>();
void* cid = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("CGSGetSurfaceBounds(%p, %" PRId32 ", %" PRId32 ", %p)\n", cid, wid, sid,
bounds);
if (CGSGetSurfaceBounds != nullptr) {
int return_value = CGSGetSurfaceBounds(cid, wid, sid, bounds);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("CGSGetSurfaceBounds returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function CGSGetSurfaceBounds\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function CGSGetSurfaceBounds\n");
return false;
}
}
bool callCGLFlushDrawable(Stack* stack, bool pushReturn) {
void* ctx = stack->pop<void*>();
if (stack->isValid()) {
GAPID_INFO("CGLFlushDrawable(%p)\n", ctx);
if (CGLFlushDrawable != nullptr) {
int return_value = CGLFlushDrawable(ctx);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<int>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("CGLFlushDrawable returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function CGLFlushDrawable\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function CGLFlushDrawable\n");
return false;
}
}
bool callGlEnableClientState(Stack* stack, bool pushReturn) {
GLenum type = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glEnableClientState(%u)\n", type);
if (glEnableClientState != nullptr) {
glEnableClientState(type);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glEnableClientState returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glEnableClientState\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glEnableClientState\n");
return false;
}
}
bool callGlDisableClientState(Stack* stack, bool pushReturn) {
GLenum type = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glDisableClientState(%u)\n", type);
if (glDisableClientState != nullptr) {
glDisableClientState(type);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDisableClientState returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDisableClientState\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDisableClientState\n");
return false;
}
}
bool callGlGetProgramBinaryOES(Stack* stack, bool pushReturn) {
void* binary = stack->pop<void*>();
uint32_t* binary_format = stack->pop<uint32_t*>();
int32_t* bytes_written = stack->pop<int32_t*>();
int32_t buffer_size = stack->pop<int32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetProgramBinaryOES(%" PRIu32 ", %" PRId32 ", %p, %p, %p)\n", program,
buffer_size, bytes_written, binary_format, binary);
if (glGetProgramBinaryOES != nullptr) {
glGetProgramBinaryOES(program, buffer_size, bytes_written, binary_format, binary);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetProgramBinaryOES returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetProgramBinaryOES\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetProgramBinaryOES\n");
return false;
}
}
bool callGlProgramBinaryOES(Stack* stack, bool pushReturn) {
int32_t binary_size = stack->pop<int32_t>();
void* binary = stack->pop<void*>();
uint32_t binary_format = stack->pop<uint32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glProgramBinaryOES(%" PRIu32 ", %" PRIu32 ", %p, %" PRId32 ")\n", program,
binary_format, binary, binary_size);
if (glProgramBinaryOES != nullptr) {
glProgramBinaryOES(program, binary_format, binary, binary_size);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glProgramBinaryOES returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glProgramBinaryOES\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glProgramBinaryOES\n");
return false;
}
}
bool callGlStartTilingQCOM(Stack* stack, bool pushReturn) {
GLbitfield preserveMask = stack->pop<GLbitfield>();
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
int32_t y = stack->pop<int32_t>();
int32_t x = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glStartTilingQCOM(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u)\n", x,
y, width, height, preserveMask);
if (glStartTilingQCOM != nullptr) {
glStartTilingQCOM(x, y, width, height, preserveMask);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glStartTilingQCOM returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glStartTilingQCOM\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glStartTilingQCOM\n");
return false;
}
}
bool callGlEndTilingQCOM(Stack* stack, bool pushReturn) {
GLbitfield preserve_mask = stack->pop<GLbitfield>();
if (stack->isValid()) {
GAPID_INFO("glEndTilingQCOM(%u)\n", preserve_mask);
if (glEndTilingQCOM != nullptr) {
glEndTilingQCOM(preserve_mask);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glEndTilingQCOM returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glEndTilingQCOM\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glEndTilingQCOM\n");
return false;
}
}
bool callGlDiscardFramebufferEXT(Stack* stack, bool pushReturn) {
GLenum* attachments = stack->pop<GLenum*>();
int32_t numAttachments = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glDiscardFramebufferEXT(%u, %" PRId32 ", %p)\n", target, numAttachments,
attachments);
if (glDiscardFramebufferEXT != nullptr) {
glDiscardFramebufferEXT(target, numAttachments, attachments);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDiscardFramebufferEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDiscardFramebufferEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDiscardFramebufferEXT\n");
return false;
}
}
bool callGlInsertEventMarkerEXT(Stack* stack, bool pushReturn) {
char* marker = stack->pop<char*>();
int32_t length = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glInsertEventMarkerEXT(%" PRId32 ", %p)\n", length, marker);
if (glInsertEventMarkerEXT != nullptr) {
glInsertEventMarkerEXT(length, marker);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glInsertEventMarkerEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glInsertEventMarkerEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glInsertEventMarkerEXT\n");
return false;
}
}
bool callGlPushGroupMarkerEXT(Stack* stack, bool pushReturn) {
char* marker = stack->pop<char*>();
int32_t length = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glPushGroupMarkerEXT(%" PRId32 ", %p)\n", length, marker);
if (glPushGroupMarkerEXT != nullptr) {
glPushGroupMarkerEXT(length, marker);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glPushGroupMarkerEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glPushGroupMarkerEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glPushGroupMarkerEXT\n");
return false;
}
}
bool callGlPopGroupMarkerEXT(Stack* stack, bool pushReturn) {
if (stack->isValid()) {
GAPID_INFO("glPopGroupMarkerEXT()\n");
if (glPopGroupMarkerEXT != nullptr) {
glPopGroupMarkerEXT();
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glPopGroupMarkerEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glPopGroupMarkerEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glPopGroupMarkerEXT\n");
return false;
}
}
bool callGlTexStorage1DEXT(Stack* stack, bool pushReturn) {
int32_t width = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
int32_t levels = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glTexStorage1DEXT(%u, %" PRId32 ", %u, %" PRId32 ")\n", target, levels, format,
width);
if (glTexStorage1DEXT != nullptr) {
glTexStorage1DEXT(target, levels, format, width);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glTexStorage1DEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glTexStorage1DEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glTexStorage1DEXT\n");
return false;
}
}
bool callGlTexStorage2DEXT(Stack* stack, bool pushReturn) {
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
int32_t levels = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glTexStorage2DEXT(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")\n", target,
levels, format, width, height);
if (glTexStorage2DEXT != nullptr) {
glTexStorage2DEXT(target, levels, format, width, height);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glTexStorage2DEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glTexStorage2DEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glTexStorage2DEXT\n");
return false;
}
}
bool callGlTexStorage3DEXT(Stack* stack, bool pushReturn) {
int32_t depth = stack->pop<int32_t>();
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
int32_t levels = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glTexStorage3DEXT(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32
")\n",
target, levels, format, width, height, depth);
if (glTexStorage3DEXT != nullptr) {
glTexStorage3DEXT(target, levels, format, width, height, depth);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glTexStorage3DEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glTexStorage3DEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glTexStorage3DEXT\n");
return false;
}
}
bool callGlTextureStorage1DEXT(Stack* stack, bool pushReturn) {
int32_t width = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
int32_t levels = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
uint32_t texture = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glTextureStorage1DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ")\n",
texture, target, levels, format, width);
if (glTextureStorage1DEXT != nullptr) {
glTextureStorage1DEXT(texture, target, levels, format, width);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glTextureStorage1DEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glTextureStorage1DEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glTextureStorage1DEXT\n");
return false;
}
}
bool callGlTextureStorage2DEXT(Stack* stack, bool pushReturn) {
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
int32_t levels = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
uint32_t texture = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glTextureStorage2DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ", %" PRId32
")\n",
texture, target, levels, format, width, height);
if (glTextureStorage2DEXT != nullptr) {
glTextureStorage2DEXT(texture, target, levels, format, width, height);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glTextureStorage2DEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glTextureStorage2DEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glTextureStorage2DEXT\n");
return false;
}
}
bool callGlTextureStorage3DEXT(Stack* stack, bool pushReturn) {
int32_t depth = stack->pop<int32_t>();
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
int32_t levels = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
uint32_t texture = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glTextureStorage3DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ", %" PRId32
", %" PRId32 ")\n",
texture, target, levels, format, width, height, depth);
if (glTextureStorage3DEXT != nullptr) {
glTextureStorage3DEXT(texture, target, levels, format, width, height, depth);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glTextureStorage3DEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glTextureStorage3DEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glTextureStorage3DEXT\n");
return false;
}
}
bool callGlGenVertexArraysOES(Stack* stack, bool pushReturn) {
uint32_t* arrays = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glGenVertexArraysOES(%" PRId32 ", %p)\n", count, arrays);
if (glGenVertexArraysOES != nullptr) {
glGenVertexArraysOES(count, arrays);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGenVertexArraysOES returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGenVertexArraysOES\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGenVertexArraysOES\n");
return false;
}
}
bool callGlBindVertexArrayOES(Stack* stack, bool pushReturn) {
uint32_t array = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glBindVertexArrayOES(%" PRIu32 ")\n", array);
if (glBindVertexArrayOES != nullptr) {
glBindVertexArrayOES(array);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBindVertexArrayOES returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBindVertexArrayOES\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBindVertexArrayOES\n");
return false;
}
}
bool callGlDeleteVertexArraysOES(Stack* stack, bool pushReturn) {
uint32_t* arrays = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteVertexArraysOES(%" PRId32 ", %p)\n", count, arrays);
if (glDeleteVertexArraysOES != nullptr) {
glDeleteVertexArraysOES(count, arrays);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteVertexArraysOES returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteVertexArraysOES\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteVertexArraysOES\n");
return false;
}
}
bool callGlIsVertexArrayOES(Stack* stack, bool pushReturn) {
uint32_t array = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glIsVertexArrayOES(%" PRIu32 ")\n", array);
if (glIsVertexArrayOES != nullptr) {
bool return_value = glIsVertexArrayOES(array);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<bool>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glIsVertexArrayOES returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glIsVertexArrayOES\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glIsVertexArrayOES\n");
return false;
}
}
bool callGlEGLImageTargetTexture2DOES(Stack* stack, bool pushReturn) {
void* image = stack->pop<void*>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glEGLImageTargetTexture2DOES(%u, %p)\n", target, image);
if (glEGLImageTargetTexture2DOES != nullptr) {
glEGLImageTargetTexture2DOES(target, image);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glEGLImageTargetTexture2DOES returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glEGLImageTargetTexture2DOES\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glEGLImageTargetTexture2DOES\n");
return false;
}
}
bool callGlEGLImageTargetRenderbufferStorageOES(Stack* stack, bool pushReturn) {
void* image = stack->pop<void*>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glEGLImageTargetRenderbufferStorageOES(%u, %p)\n", target, image);
if (glEGLImageTargetRenderbufferStorageOES != nullptr) {
glEGLImageTargetRenderbufferStorageOES(target, image);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glEGLImageTargetRenderbufferStorageOES returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING(
"Attempted to call unsupported function "
"glEGLImageTargetRenderbufferStorageOES\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glEGLImageTargetRenderbufferStorageOES\n");
return false;
}
}
bool callGlGetGraphicsResetStatusEXT(Stack* stack, bool pushReturn) {
if (stack->isValid()) {
GAPID_INFO("glGetGraphicsResetStatusEXT()\n");
if (glGetGraphicsResetStatusEXT != nullptr) {
GLenum return_value = glGetGraphicsResetStatusEXT();
GAPID_INFO("Returned: %u\n", return_value);
if (pushReturn) {
stack->push<GLenum>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetGraphicsResetStatusEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetGraphicsResetStatusEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetGraphicsResetStatusEXT\n");
return false;
}
}
bool callGlBindAttribLocation(Stack* stack, bool pushReturn) {
char* name = stack->pop<char*>();
int32_t location = stack->pop<int32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glBindAttribLocation(%" PRIu32 ", %" PRId32 ", %s)\n", program, location, name);
if (glBindAttribLocation != nullptr) {
glBindAttribLocation(program, location, name);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBindAttribLocation returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBindAttribLocation\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBindAttribLocation\n");
return false;
}
}
bool callGlBlendFunc(Stack* stack, bool pushReturn) {
GLenum dst_factor = stack->pop<GLenum>();
GLenum src_factor = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBlendFunc(%u, %u)\n", src_factor, dst_factor);
if (glBlendFunc != nullptr) {
glBlendFunc(src_factor, dst_factor);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBlendFunc returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBlendFunc\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBlendFunc\n");
return false;
}
}
bool callGlBlendFuncSeparate(Stack* stack, bool pushReturn) {
GLenum dst_factor_alpha = stack->pop<GLenum>();
GLenum src_factor_alpha = stack->pop<GLenum>();
GLenum dst_factor_rgb = stack->pop<GLenum>();
GLenum src_factor_rgb = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBlendFuncSeparate(%u, %u, %u, %u)\n", src_factor_rgb, dst_factor_rgb,
src_factor_alpha, dst_factor_alpha);
if (glBlendFuncSeparate != nullptr) {
glBlendFuncSeparate(src_factor_rgb, dst_factor_rgb, src_factor_alpha, dst_factor_alpha);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBlendFuncSeparate returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBlendFuncSeparate\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBlendFuncSeparate\n");
return false;
}
}
bool callGlBlendEquation(Stack* stack, bool pushReturn) {
GLenum equation = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBlendEquation(%u)\n", equation);
if (glBlendEquation != nullptr) {
glBlendEquation(equation);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBlendEquation returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBlendEquation\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBlendEquation\n");
return false;
}
}
bool callGlBlendEquationSeparate(Stack* stack, bool pushReturn) {
GLenum alpha = stack->pop<GLenum>();
GLenum rgb = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBlendEquationSeparate(%u, %u)\n", rgb, alpha);
if (glBlendEquationSeparate != nullptr) {
glBlendEquationSeparate(rgb, alpha);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBlendEquationSeparate returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBlendEquationSeparate\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBlendEquationSeparate\n");
return false;
}
}
bool callGlBlendColor(Stack* stack, bool pushReturn) {
float alpha = stack->pop<float>();
float blue = stack->pop<float>();
float green = stack->pop<float>();
float red = stack->pop<float>();
if (stack->isValid()) {
GAPID_INFO("glBlendColor(%f, %f, %f, %f)\n", red, green, blue, alpha);
if (glBlendColor != nullptr) {
glBlendColor(red, green, blue, alpha);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBlendColor returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBlendColor\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBlendColor\n");
return false;
}
}
bool callGlEnableVertexAttribArray(Stack* stack, bool pushReturn) {
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glEnableVertexAttribArray(%" PRId32 ")\n", location);
if (glEnableVertexAttribArray != nullptr) {
glEnableVertexAttribArray(location);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glEnableVertexAttribArray returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glEnableVertexAttribArray\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glEnableVertexAttribArray\n");
return false;
}
}
bool callGlDisableVertexAttribArray(Stack* stack, bool pushReturn) {
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glDisableVertexAttribArray(%" PRId32 ")\n", location);
if (glDisableVertexAttribArray != nullptr) {
glDisableVertexAttribArray(location);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDisableVertexAttribArray returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDisableVertexAttribArray\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDisableVertexAttribArray\n");
return false;
}
}
bool callGlVertexAttribPointer(Stack* stack, bool pushReturn) {
void* data = stack->pop<void*>();
int32_t stride = stack->pop<int32_t>();
bool normalized = stack->pop<bool>();
GLenum type = stack->pop<GLenum>();
int32_t size = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glVertexAttribPointer(%" PRId32 ", %" PRId32 ", %u, %d, %" PRId32 ", %p)\n",
location, size, type, normalized, stride, data);
if (glVertexAttribPointer != nullptr) {
glVertexAttribPointer(location, size, type, normalized, stride, data);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glVertexAttribPointer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glVertexAttribPointer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glVertexAttribPointer\n");
return false;
}
}
bool callGlGetActiveAttrib(Stack* stack, bool pushReturn) {
char* name = stack->pop<char*>();
GLenum* type = stack->pop<GLenum*>();
int32_t* vector_count = stack->pop<int32_t*>();
int32_t* buffer_bytes_written = stack->pop<int32_t*>();
int32_t buffer_size = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetActiveAttrib(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p, %p, %p, %p)\n",
program, location, buffer_size, buffer_bytes_written, vector_count, type, name);
if (glGetActiveAttrib != nullptr) {
glGetActiveAttrib(program, location, buffer_size, buffer_bytes_written, vector_count,
type, name);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetActiveAttrib returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetActiveAttrib\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetActiveAttrib\n");
return false;
}
}
bool callGlGetActiveUniform(Stack* stack, bool pushReturn) {
char* name = stack->pop<char*>();
GLenum* type = stack->pop<GLenum*>();
int32_t* vector_count = stack->pop<int32_t*>();
int32_t* buffer_bytes_written = stack->pop<int32_t*>();
int32_t buffer_size = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetActiveUniform(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p, %p, %p, %p)\n",
program, location, buffer_size, buffer_bytes_written, vector_count, type, name);
if (glGetActiveUniform != nullptr) {
glGetActiveUniform(program, location, buffer_size, buffer_bytes_written, vector_count,
type, name);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetActiveUniform returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetActiveUniform\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetActiveUniform\n");
return false;
}
}
bool callGlGetError(Stack* stack, bool pushReturn) {
if (stack->isValid()) {
GAPID_INFO("glGetError()\n");
if (glGetError != nullptr) {
GLenum return_value = glGetError();
GAPID_INFO("Returned: %u\n", return_value);
if (pushReturn) {
stack->push<GLenum>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetError returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetError\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetError\n");
return false;
}
}
bool callGlGetProgramiv(Stack* stack, bool pushReturn) {
int32_t* value = stack->pop<int32_t*>();
GLenum parameter = stack->pop<GLenum>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetProgramiv(%" PRIu32 ", %u, %p)\n", program, parameter, value);
if (glGetProgramiv != nullptr) {
glGetProgramiv(program, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetProgramiv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetProgramiv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetProgramiv\n");
return false;
}
}
bool callGlGetShaderiv(Stack* stack, bool pushReturn) {
int32_t* value = stack->pop<int32_t*>();
GLenum parameter = stack->pop<GLenum>();
uint32_t shader = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetShaderiv(%" PRIu32 ", %u, %p)\n", shader, parameter, value);
if (glGetShaderiv != nullptr) {
glGetShaderiv(shader, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetShaderiv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetShaderiv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetShaderiv\n");
return false;
}
}
bool callGlGetUniformLocation(Stack* stack, bool pushReturn) {
char* name = stack->pop<char*>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetUniformLocation(%" PRIu32 ", %s)\n", program, name);
if (glGetUniformLocation != nullptr) {
int32_t return_value = glGetUniformLocation(program, name);
GAPID_INFO("Returned: %" PRId32 "\n", return_value);
if (pushReturn) {
stack->push<int32_t>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetUniformLocation returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetUniformLocation\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetUniformLocation\n");
return false;
}
}
bool callGlGetAttribLocation(Stack* stack, bool pushReturn) {
char* name = stack->pop<char*>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetAttribLocation(%" PRIu32 ", %s)\n", program, name);
if (glGetAttribLocation != nullptr) {
int32_t return_value = glGetAttribLocation(program, name);
GAPID_INFO("Returned: %" PRId32 "\n", return_value);
if (pushReturn) {
stack->push<int32_t>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetAttribLocation returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetAttribLocation\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetAttribLocation\n");
return false;
}
}
bool callGlPixelStorei(Stack* stack, bool pushReturn) {
int32_t value = stack->pop<int32_t>();
GLenum parameter = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glPixelStorei(%u, %" PRId32 ")\n", parameter, value);
if (glPixelStorei != nullptr) {
glPixelStorei(parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glPixelStorei returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glPixelStorei\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glPixelStorei\n");
return false;
}
}
bool callGlTexParameteri(Stack* stack, bool pushReturn) {
int32_t value = stack->pop<int32_t>();
GLenum parameter = stack->pop<GLenum>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glTexParameteri(%u, %u, %" PRId32 ")\n", target, parameter, value);
if (glTexParameteri != nullptr) {
glTexParameteri(target, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glTexParameteri returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glTexParameteri\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glTexParameteri\n");
return false;
}
}
bool callGlTexParameterf(Stack* stack, bool pushReturn) {
float value = stack->pop<float>();
GLenum parameter = stack->pop<GLenum>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glTexParameterf(%u, %u, %f)\n", target, parameter, value);
if (glTexParameterf != nullptr) {
glTexParameterf(target, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glTexParameterf returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glTexParameterf\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glTexParameterf\n");
return false;
}
}
bool callGlGetTexParameteriv(Stack* stack, bool pushReturn) {
int32_t* values = stack->pop<int32_t*>();
GLenum parameter = stack->pop<GLenum>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetTexParameteriv(%u, %u, %p)\n", target, parameter, values);
if (glGetTexParameteriv != nullptr) {
glGetTexParameteriv(target, parameter, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetTexParameteriv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetTexParameteriv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetTexParameteriv\n");
return false;
}
}
bool callGlGetTexParameterfv(Stack* stack, bool pushReturn) {
float* values = stack->pop<float*>();
GLenum parameter = stack->pop<GLenum>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetTexParameterfv(%u, %u, %p)\n", target, parameter, values);
if (glGetTexParameterfv != nullptr) {
glGetTexParameterfv(target, parameter, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetTexParameterfv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetTexParameterfv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetTexParameterfv\n");
return false;
}
}
bool callGlUniform1i(Stack* stack, bool pushReturn) {
int32_t value = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform1i(%" PRId32 ", %" PRId32 ")\n", location, value);
if (glUniform1i != nullptr) {
glUniform1i(location, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform1i returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform1i\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform1i\n");
return false;
}
}
bool callGlUniform2i(Stack* stack, bool pushReturn) {
int32_t value1 = stack->pop<int32_t>();
int32_t value0 = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform2i(%" PRId32 ", %" PRId32 ", %" PRId32 ")\n", location, value0,
value1);
if (glUniform2i != nullptr) {
glUniform2i(location, value0, value1);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform2i returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform2i\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform2i\n");
return false;
}
}
bool callGlUniform3i(Stack* stack, bool pushReturn) {
int32_t value2 = stack->pop<int32_t>();
int32_t value1 = stack->pop<int32_t>();
int32_t value0 = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform3i(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n", location,
value0, value1, value2);
if (glUniform3i != nullptr) {
glUniform3i(location, value0, value1, value2);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform3i returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform3i\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform3i\n");
return false;
}
}
bool callGlUniform4i(Stack* stack, bool pushReturn) {
int32_t value3 = stack->pop<int32_t>();
int32_t value2 = stack->pop<int32_t>();
int32_t value1 = stack->pop<int32_t>();
int32_t value0 = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform4i(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n",
location, value0, value1, value2, value3);
if (glUniform4i != nullptr) {
glUniform4i(location, value0, value1, value2, value3);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform4i returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform4i\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform4i\n");
return false;
}
}
bool callGlUniform1iv(Stack* stack, bool pushReturn) {
int32_t* values = stack->pop<int32_t*>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform1iv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
if (glUniform1iv != nullptr) {
glUniform1iv(location, count, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform1iv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform1iv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform1iv\n");
return false;
}
}
bool callGlUniform2iv(Stack* stack, bool pushReturn) {
int32_t* values = stack->pop<int32_t*>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform2iv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
if (glUniform2iv != nullptr) {
glUniform2iv(location, count, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform2iv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform2iv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform2iv\n");
return false;
}
}
bool callGlUniform3iv(Stack* stack, bool pushReturn) {
int32_t* values = stack->pop<int32_t*>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform3iv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
if (glUniform3iv != nullptr) {
glUniform3iv(location, count, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform3iv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform3iv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform3iv\n");
return false;
}
}
bool callGlUniform4iv(Stack* stack, bool pushReturn) {
int32_t* values = stack->pop<int32_t*>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform4iv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
if (glUniform4iv != nullptr) {
glUniform4iv(location, count, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform4iv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform4iv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform4iv\n");
return false;
}
}
bool callGlUniform1f(Stack* stack, bool pushReturn) {
float value = stack->pop<float>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform1f(%" PRId32 ", %f)\n", location, value);
if (glUniform1f != nullptr) {
glUniform1f(location, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform1f returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform1f\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform1f\n");
return false;
}
}
bool callGlUniform2f(Stack* stack, bool pushReturn) {
float value1 = stack->pop<float>();
float value0 = stack->pop<float>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform2f(%" PRId32 ", %f, %f)\n", location, value0, value1);
if (glUniform2f != nullptr) {
glUniform2f(location, value0, value1);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform2f returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform2f\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform2f\n");
return false;
}
}
bool callGlUniform3f(Stack* stack, bool pushReturn) {
float value2 = stack->pop<float>();
float value1 = stack->pop<float>();
float value0 = stack->pop<float>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform3f(%" PRId32 ", %f, %f, %f)\n", location, value0, value1, value2);
if (glUniform3f != nullptr) {
glUniform3f(location, value0, value1, value2);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform3f returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform3f\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform3f\n");
return false;
}
}
bool callGlUniform4f(Stack* stack, bool pushReturn) {
float value3 = stack->pop<float>();
float value2 = stack->pop<float>();
float value1 = stack->pop<float>();
float value0 = stack->pop<float>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform4f(%" PRId32 ", %f, %f, %f, %f)\n", location, value0, value1, value2,
value3);
if (glUniform4f != nullptr) {
glUniform4f(location, value0, value1, value2, value3);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform4f returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform4f\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform4f\n");
return false;
}
}
bool callGlUniform1fv(Stack* stack, bool pushReturn) {
float* values = stack->pop<float*>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform1fv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
if (glUniform1fv != nullptr) {
glUniform1fv(location, count, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform1fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform1fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform1fv\n");
return false;
}
}
bool callGlUniform2fv(Stack* stack, bool pushReturn) {
float* values = stack->pop<float*>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform2fv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
if (glUniform2fv != nullptr) {
glUniform2fv(location, count, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform2fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform2fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform2fv\n");
return false;
}
}
bool callGlUniform3fv(Stack* stack, bool pushReturn) {
float* values = stack->pop<float*>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform3fv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
if (glUniform3fv != nullptr) {
glUniform3fv(location, count, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform3fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform3fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform3fv\n");
return false;
}
}
bool callGlUniform4fv(Stack* stack, bool pushReturn) {
float* values = stack->pop<float*>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniform4fv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
if (glUniform4fv != nullptr) {
glUniform4fv(location, count, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniform4fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniform4fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniform4fv\n");
return false;
}
}
bool callGlUniformMatrix2fv(Stack* stack, bool pushReturn) {
float* values = stack->pop<float*>();
bool transpose = stack->pop<bool>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniformMatrix2fv(%" PRId32 ", %" PRId32 ", %d, %p)\n", location, count,
transpose, values);
if (glUniformMatrix2fv != nullptr) {
glUniformMatrix2fv(location, count, transpose, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniformMatrix2fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniformMatrix2fv\n");
return false;
}
}
bool callGlUniformMatrix3fv(Stack* stack, bool pushReturn) {
float* values = stack->pop<float*>();
bool transpose = stack->pop<bool>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniformMatrix3fv(%" PRId32 ", %" PRId32 ", %d, %p)\n", location, count,
transpose, values);
if (glUniformMatrix3fv != nullptr) {
glUniformMatrix3fv(location, count, transpose, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniformMatrix3fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniformMatrix3fv\n");
return false;
}
}
bool callGlUniformMatrix4fv(Stack* stack, bool pushReturn) {
float* values = stack->pop<float*>();
bool transpose = stack->pop<bool>();
int32_t count = stack->pop<int32_t>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniformMatrix4fv(%" PRId32 ", %" PRId32 ", %d, %p)\n", location, count,
transpose, values);
if (glUniformMatrix4fv != nullptr) {
glUniformMatrix4fv(location, count, transpose, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniformMatrix4fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniformMatrix4fv\n");
return false;
}
}
bool callGlGetUniformfv(Stack* stack, bool pushReturn) {
float* values = stack->pop<float*>();
int32_t location = stack->pop<int32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetUniformfv(%" PRIu32 ", %" PRId32 ", %p)\n", program, location, values);
if (glGetUniformfv != nullptr) {
glGetUniformfv(program, location, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetUniformfv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetUniformfv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetUniformfv\n");
return false;
}
}
bool callGlGetUniformiv(Stack* stack, bool pushReturn) {
int32_t* values = stack->pop<int32_t*>();
int32_t location = stack->pop<int32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetUniformiv(%" PRIu32 ", %" PRId32 ", %p)\n", program, location, values);
if (glGetUniformiv != nullptr) {
glGetUniformiv(program, location, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetUniformiv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetUniformiv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetUniformiv\n");
return false;
}
}
bool callGlVertexAttrib1f(Stack* stack, bool pushReturn) {
float value0 = stack->pop<float>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glVertexAttrib1f(%" PRId32 ", %f)\n", location, value0);
if (glVertexAttrib1f != nullptr) {
glVertexAttrib1f(location, value0);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glVertexAttrib1f returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glVertexAttrib1f\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glVertexAttrib1f\n");
return false;
}
}
bool callGlVertexAttrib2f(Stack* stack, bool pushReturn) {
float value1 = stack->pop<float>();
float value0 = stack->pop<float>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glVertexAttrib2f(%" PRId32 ", %f, %f)\n", location, value0, value1);
if (glVertexAttrib2f != nullptr) {
glVertexAttrib2f(location, value0, value1);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glVertexAttrib2f returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glVertexAttrib2f\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glVertexAttrib2f\n");
return false;
}
}
bool callGlVertexAttrib3f(Stack* stack, bool pushReturn) {
float value2 = stack->pop<float>();
float value1 = stack->pop<float>();
float value0 = stack->pop<float>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glVertexAttrib3f(%" PRId32 ", %f, %f, %f)\n", location, value0, value1, value2);
if (glVertexAttrib3f != nullptr) {
glVertexAttrib3f(location, value0, value1, value2);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glVertexAttrib3f returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glVertexAttrib3f\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glVertexAttrib3f\n");
return false;
}
}
bool callGlVertexAttrib4f(Stack* stack, bool pushReturn) {
float value3 = stack->pop<float>();
float value2 = stack->pop<float>();
float value1 = stack->pop<float>();
float value0 = stack->pop<float>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glVertexAttrib4f(%" PRId32 ", %f, %f, %f, %f)\n", location, value0, value1,
value2, value3);
if (glVertexAttrib4f != nullptr) {
glVertexAttrib4f(location, value0, value1, value2, value3);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glVertexAttrib4f returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glVertexAttrib4f\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glVertexAttrib4f\n");
return false;
}
}
bool callGlVertexAttrib1fv(Stack* stack, bool pushReturn) {
float* value = stack->pop<float*>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glVertexAttrib1fv(%" PRId32 ", %p)\n", location, value);
if (glVertexAttrib1fv != nullptr) {
glVertexAttrib1fv(location, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glVertexAttrib1fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glVertexAttrib1fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glVertexAttrib1fv\n");
return false;
}
}
bool callGlVertexAttrib2fv(Stack* stack, bool pushReturn) {
float* value = stack->pop<float*>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glVertexAttrib2fv(%" PRId32 ", %p)\n", location, value);
if (glVertexAttrib2fv != nullptr) {
glVertexAttrib2fv(location, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glVertexAttrib2fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glVertexAttrib2fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glVertexAttrib2fv\n");
return false;
}
}
bool callGlVertexAttrib3fv(Stack* stack, bool pushReturn) {
float* value = stack->pop<float*>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glVertexAttrib3fv(%" PRId32 ", %p)\n", location, value);
if (glVertexAttrib3fv != nullptr) {
glVertexAttrib3fv(location, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glVertexAttrib3fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glVertexAttrib3fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glVertexAttrib3fv\n");
return false;
}
}
bool callGlVertexAttrib4fv(Stack* stack, bool pushReturn) {
float* value = stack->pop<float*>();
int32_t location = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glVertexAttrib4fv(%" PRId32 ", %p)\n", location, value);
if (glVertexAttrib4fv != nullptr) {
glVertexAttrib4fv(location, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glVertexAttrib4fv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glVertexAttrib4fv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glVertexAttrib4fv\n");
return false;
}
}
bool callGlGetShaderPrecisionFormat(Stack* stack, bool pushReturn) {
int32_t* precision = stack->pop<int32_t*>();
int32_t* range = stack->pop<int32_t*>();
GLenum precision_type = stack->pop<GLenum>();
GLenum shader_type = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetShaderPrecisionFormat(%u, %u, %p, %p)\n", shader_type, precision_type,
range, precision);
if (glGetShaderPrecisionFormat != nullptr) {
glGetShaderPrecisionFormat(shader_type, precision_type, range, precision);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetShaderPrecisionFormat returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetShaderPrecisionFormat\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetShaderPrecisionFormat\n");
return false;
}
}
bool callGlDepthMask(Stack* stack, bool pushReturn) {
bool enabled = stack->pop<bool>();
if (stack->isValid()) {
GAPID_INFO("glDepthMask(%d)\n", enabled);
if (glDepthMask != nullptr) {
glDepthMask(enabled);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDepthMask returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDepthMask\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDepthMask\n");
return false;
}
}
bool callGlDepthFunc(Stack* stack, bool pushReturn) {
GLenum function = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glDepthFunc(%u)\n", function);
if (glDepthFunc != nullptr) {
glDepthFunc(function);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDepthFunc returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDepthFunc\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDepthFunc\n");
return false;
}
}
bool callGlDepthRangef(Stack* stack, bool pushReturn) {
float far = stack->pop<float>();
float near = stack->pop<float>();
if (stack->isValid()) {
GAPID_INFO("glDepthRangef(%f, %f)\n", near, far);
if (glDepthRangef != nullptr) {
glDepthRangef(near, far);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDepthRangef returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDepthRangef\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDepthRangef\n");
return false;
}
}
bool callGlColorMask(Stack* stack, bool pushReturn) {
bool alpha = stack->pop<bool>();
bool blue = stack->pop<bool>();
bool green = stack->pop<bool>();
bool red = stack->pop<bool>();
if (stack->isValid()) {
GAPID_INFO("glColorMask(%d, %d, %d, %d)\n", red, green, blue, alpha);
if (glColorMask != nullptr) {
glColorMask(red, green, blue, alpha);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glColorMask returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glColorMask\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glColorMask\n");
return false;
}
}
bool callGlStencilMask(Stack* stack, bool pushReturn) {
uint32_t mask = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glStencilMask(%" PRIu32 ")\n", mask);
if (glStencilMask != nullptr) {
glStencilMask(mask);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glStencilMask returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glStencilMask\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glStencilMask\n");
return false;
}
}
bool callGlStencilMaskSeparate(Stack* stack, bool pushReturn) {
uint32_t mask = stack->pop<uint32_t>();
GLenum face = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glStencilMaskSeparate(%u, %" PRIu32 ")\n", face, mask);
if (glStencilMaskSeparate != nullptr) {
glStencilMaskSeparate(face, mask);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glStencilMaskSeparate returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glStencilMaskSeparate\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glStencilMaskSeparate\n");
return false;
}
}
bool callGlStencilFuncSeparate(Stack* stack, bool pushReturn) {
int32_t mask = stack->pop<int32_t>();
int32_t reference_value = stack->pop<int32_t>();
GLenum function = stack->pop<GLenum>();
GLenum face = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glStencilFuncSeparate(%u, %u, %" PRId32 ", %" PRId32 ")\n", face, function,
reference_value, mask);
if (glStencilFuncSeparate != nullptr) {
glStencilFuncSeparate(face, function, reference_value, mask);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glStencilFuncSeparate returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glStencilFuncSeparate\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glStencilFuncSeparate\n");
return false;
}
}
bool callGlStencilOpSeparate(Stack* stack, bool pushReturn) {
GLenum stencil_pass_depth_pass = stack->pop<GLenum>();
GLenum stencil_pass_depth_fail = stack->pop<GLenum>();
GLenum stencil_fail = stack->pop<GLenum>();
GLenum face = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glStencilOpSeparate(%u, %u, %u, %u)\n", face, stencil_fail,
stencil_pass_depth_fail, stencil_pass_depth_pass);
if (glStencilOpSeparate != nullptr) {
glStencilOpSeparate(face, stencil_fail, stencil_pass_depth_fail,
stencil_pass_depth_pass);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glStencilOpSeparate returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glStencilOpSeparate\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glStencilOpSeparate\n");
return false;
}
}
bool callGlFrontFace(Stack* stack, bool pushReturn) {
GLenum orientation = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glFrontFace(%u)\n", orientation);
if (glFrontFace != nullptr) {
glFrontFace(orientation);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glFrontFace returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glFrontFace\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glFrontFace\n");
return false;
}
}
bool callGlViewport(Stack* stack, bool pushReturn) {
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
int32_t y = stack->pop<int32_t>();
int32_t x = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glViewport(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n", x, y, width,
height);
if (glViewport != nullptr) {
glViewport(x, y, width, height);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glViewport returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glViewport\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glViewport\n");
return false;
}
}
bool callGlScissor(Stack* stack, bool pushReturn) {
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
int32_t y = stack->pop<int32_t>();
int32_t x = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glScissor(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n", x, y, width,
height);
if (glScissor != nullptr) {
glScissor(x, y, width, height);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glScissor returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glScissor\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glScissor\n");
return false;
}
}
bool callGlActiveTexture(Stack* stack, bool pushReturn) {
GLenum unit = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glActiveTexture(%u)\n", unit);
if (glActiveTexture != nullptr) {
glActiveTexture(unit);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glActiveTexture returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glActiveTexture\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glActiveTexture\n");
return false;
}
}
bool callGlGenTextures(Stack* stack, bool pushReturn) {
uint32_t* textures = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glGenTextures(%" PRId32 ", %p)\n", count, textures);
if (glGenTextures != nullptr) {
glGenTextures(count, textures);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGenTextures returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGenTextures\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGenTextures\n");
return false;
}
}
bool callGlDeleteTextures(Stack* stack, bool pushReturn) {
uint32_t* textures = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteTextures(%" PRId32 ", %p)\n", count, textures);
if (glDeleteTextures != nullptr) {
glDeleteTextures(count, textures);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteTextures returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteTextures\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteTextures\n");
return false;
}
}
bool callGlIsTexture(Stack* stack, bool pushReturn) {
uint32_t texture = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glIsTexture(%" PRIu32 ")\n", texture);
if (glIsTexture != nullptr) {
bool return_value = glIsTexture(texture);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<bool>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glIsTexture returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glIsTexture\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glIsTexture\n");
return false;
}
}
bool callGlBindTexture(Stack* stack, bool pushReturn) {
uint32_t texture = stack->pop<uint32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBindTexture(%u, %" PRIu32 ")\n", target, texture);
if (glBindTexture != nullptr) {
glBindTexture(target, texture);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBindTexture returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBindTexture\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBindTexture\n");
return false;
}
}
bool callGlTexImage2D(Stack* stack, bool pushReturn) {
void* data = stack->pop<void*>();
GLenum type = stack->pop<GLenum>();
GLenum format = stack->pop<GLenum>();
int32_t border = stack->pop<int32_t>();
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
GLenum internal_format = stack->pop<GLenum>();
int32_t level = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glTexImage2D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32
", %u, %u, %p)\n",
target, level, internal_format, width, height, border, format, type, data);
if (glTexImage2D != nullptr) {
glTexImage2D(target, level, internal_format, width, height, border, format, type, data);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glTexImage2D returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glTexImage2D\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glTexImage2D\n");
return false;
}
}
bool callGlTexSubImage2D(Stack* stack, bool pushReturn) {
void* data = stack->pop<void*>();
GLenum type = stack->pop<GLenum>();
GLenum format = stack->pop<GLenum>();
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
int32_t yoffset = stack->pop<int32_t>();
int32_t xoffset = stack->pop<int32_t>();
int32_t level = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glTexSubImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
", %" PRId32 ", %u, %u, %p)\n",
target, level, xoffset, yoffset, width, height, format, type, data);
if (glTexSubImage2D != nullptr) {
glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glTexSubImage2D returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glTexSubImage2D\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glTexSubImage2D\n");
return false;
}
}
bool callGlCopyTexImage2D(Stack* stack, bool pushReturn) {
int32_t border = stack->pop<int32_t>();
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
int32_t y = stack->pop<int32_t>();
int32_t x = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
int32_t level = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glCopyTexImage2D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32
", %" PRId32 ", %" PRId32 ")\n",
target, level, format, x, y, width, height, border);
if (glCopyTexImage2D != nullptr) {
glCopyTexImage2D(target, level, format, x, y, width, height, border);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glCopyTexImage2D returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glCopyTexImage2D\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glCopyTexImage2D\n");
return false;
}
}
bool callGlCopyTexSubImage2D(Stack* stack, bool pushReturn) {
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
int32_t y = stack->pop<int32_t>();
int32_t x = stack->pop<int32_t>();
int32_t yoffset = stack->pop<int32_t>();
int32_t xoffset = stack->pop<int32_t>();
int32_t level = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glCopyTexSubImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n",
target, level, xoffset, yoffset, x, y, width, height);
if (glCopyTexSubImage2D != nullptr) {
glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glCopyTexSubImage2D returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glCopyTexSubImage2D\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glCopyTexSubImage2D\n");
return false;
}
}
bool callGlCompressedTexImage2D(Stack* stack, bool pushReturn) {
void* data = stack->pop<void*>();
int32_t image_size = stack->pop<int32_t>();
int32_t border = stack->pop<int32_t>();
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
int32_t level = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glCompressedTexImage2D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32
", %" PRId32 ", %p)\n",
target, level, format, width, height, border, image_size, data);
if (glCompressedTexImage2D != nullptr) {
glCompressedTexImage2D(target, level, format, width, height, border, image_size, data);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glCompressedTexImage2D returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glCompressedTexImage2D\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glCompressedTexImage2D\n");
return false;
}
}
bool callGlCompressedTexSubImage2D(Stack* stack, bool pushReturn) {
void* data = stack->pop<void*>();
int32_t image_size = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
int32_t yoffset = stack->pop<int32_t>();
int32_t xoffset = stack->pop<int32_t>();
int32_t level = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glCompressedTexSubImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
", %" PRId32 ", %u, %" PRId32 ", %p)\n",
target, level, xoffset, yoffset, width, height, format, image_size, data);
if (glCompressedTexSubImage2D != nullptr) {
glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format,
image_size, data);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glCompressedTexSubImage2D returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glCompressedTexSubImage2D\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glCompressedTexSubImage2D\n");
return false;
}
}
bool callGlGenerateMipmap(Stack* stack, bool pushReturn) {
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGenerateMipmap(%u)\n", target);
if (glGenerateMipmap != nullptr) {
glGenerateMipmap(target);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGenerateMipmap returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGenerateMipmap\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGenerateMipmap\n");
return false;
}
}
bool callGlReadPixels(Stack* stack, bool pushReturn) {
void* data = stack->pop<void*>();
GLenum type = stack->pop<GLenum>();
GLenum format = stack->pop<GLenum>();
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
int32_t y = stack->pop<int32_t>();
int32_t x = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glReadPixels(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)\n",
x, y, width, height, format, type, data);
if (glReadPixels != nullptr) {
glReadPixels(x, y, width, height, format, type, data);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glReadPixels returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glReadPixels\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glReadPixels\n");
return false;
}
}
bool callGlGenFramebuffers(Stack* stack, bool pushReturn) {
uint32_t* framebuffers = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glGenFramebuffers(%" PRId32 ", %p)\n", count, framebuffers);
if (glGenFramebuffers != nullptr) {
glGenFramebuffers(count, framebuffers);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGenFramebuffers returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGenFramebuffers\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGenFramebuffers\n");
return false;
}
}
bool callGlBindFramebuffer(Stack* stack, bool pushReturn) {
uint32_t framebuffer = stack->pop<uint32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBindFramebuffer(%u, %" PRIu32 ")\n", target, framebuffer);
if (glBindFramebuffer != nullptr) {
glBindFramebuffer(target, framebuffer);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBindFramebuffer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBindFramebuffer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBindFramebuffer\n");
return false;
}
}
bool callGlCheckFramebufferStatus(Stack* stack, bool pushReturn) {
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glCheckFramebufferStatus(%u)\n", target);
if (glCheckFramebufferStatus != nullptr) {
GLenum return_value = glCheckFramebufferStatus(target);
GAPID_INFO("Returned: %u\n", return_value);
if (pushReturn) {
stack->push<GLenum>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glCheckFramebufferStatus returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glCheckFramebufferStatus\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glCheckFramebufferStatus\n");
return false;
}
}
bool callGlDeleteFramebuffers(Stack* stack, bool pushReturn) {
uint32_t* framebuffers = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteFramebuffers(%" PRId32 ", %p)\n", count, framebuffers);
if (glDeleteFramebuffers != nullptr) {
glDeleteFramebuffers(count, framebuffers);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteFramebuffers returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteFramebuffers\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteFramebuffers\n");
return false;
}
}
bool callGlIsFramebuffer(Stack* stack, bool pushReturn) {
uint32_t framebuffer = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glIsFramebuffer(%" PRIu32 ")\n", framebuffer);
if (glIsFramebuffer != nullptr) {
bool return_value = glIsFramebuffer(framebuffer);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<bool>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glIsFramebuffer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glIsFramebuffer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glIsFramebuffer\n");
return false;
}
}
bool callGlGenRenderbuffers(Stack* stack, bool pushReturn) {
uint32_t* renderbuffers = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glGenRenderbuffers(%" PRId32 ", %p)\n", count, renderbuffers);
if (glGenRenderbuffers != nullptr) {
glGenRenderbuffers(count, renderbuffers);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGenRenderbuffers returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGenRenderbuffers\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGenRenderbuffers\n");
return false;
}
}
bool callGlBindRenderbuffer(Stack* stack, bool pushReturn) {
uint32_t renderbuffer = stack->pop<uint32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBindRenderbuffer(%u, %" PRIu32 ")\n", target, renderbuffer);
if (glBindRenderbuffer != nullptr) {
glBindRenderbuffer(target, renderbuffer);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBindRenderbuffer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBindRenderbuffer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBindRenderbuffer\n");
return false;
}
}
bool callGlRenderbufferStorage(Stack* stack, bool pushReturn) {
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glRenderbufferStorage(%u, %u, %" PRId32 ", %" PRId32 ")\n", target, format,
width, height);
if (glRenderbufferStorage != nullptr) {
glRenderbufferStorage(target, format, width, height);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glRenderbufferStorage returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glRenderbufferStorage\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glRenderbufferStorage\n");
return false;
}
}
bool callGlDeleteRenderbuffers(Stack* stack, bool pushReturn) {
uint32_t* renderbuffers = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteRenderbuffers(%" PRId32 ", %p)\n", count, renderbuffers);
if (glDeleteRenderbuffers != nullptr) {
glDeleteRenderbuffers(count, renderbuffers);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteRenderbuffers returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteRenderbuffers\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteRenderbuffers\n");
return false;
}
}
bool callGlIsRenderbuffer(Stack* stack, bool pushReturn) {
uint32_t renderbuffer = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glIsRenderbuffer(%" PRIu32 ")\n", renderbuffer);
if (glIsRenderbuffer != nullptr) {
bool return_value = glIsRenderbuffer(renderbuffer);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<bool>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glIsRenderbuffer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glIsRenderbuffer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glIsRenderbuffer\n");
return false;
}
}
bool callGlGetRenderbufferParameteriv(Stack* stack, bool pushReturn) {
int32_t* values = stack->pop<int32_t*>();
GLenum parameter = stack->pop<GLenum>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetRenderbufferParameteriv(%u, %u, %p)\n", target, parameter, values);
if (glGetRenderbufferParameteriv != nullptr) {
glGetRenderbufferParameteriv(target, parameter, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetRenderbufferParameteriv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetRenderbufferParameteriv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetRenderbufferParameteriv\n");
return false;
}
}
bool callGlGenBuffers(Stack* stack, bool pushReturn) {
uint32_t* buffers = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glGenBuffers(%" PRId32 ", %p)\n", count, buffers);
if (glGenBuffers != nullptr) {
glGenBuffers(count, buffers);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGenBuffers returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGenBuffers\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGenBuffers\n");
return false;
}
}
bool callGlBindBuffer(Stack* stack, bool pushReturn) {
uint32_t buffer = stack->pop<uint32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBindBuffer(%u, %" PRIu32 ")\n", target, buffer);
if (glBindBuffer != nullptr) {
glBindBuffer(target, buffer);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBindBuffer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBindBuffer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBindBuffer\n");
return false;
}
}
bool callGlBufferData(Stack* stack, bool pushReturn) {
GLenum usage = stack->pop<GLenum>();
void* data = stack->pop<void*>();
int32_t size = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBufferData(%u, %" PRId32 ", %p, %u)\n", target, size, data, usage);
if (glBufferData != nullptr) {
glBufferData(target, size, data, usage);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBufferData returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBufferData\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBufferData\n");
return false;
}
}
bool callGlBufferSubData(Stack* stack, bool pushReturn) {
void* data = stack->pop<void*>();
int32_t size = stack->pop<int32_t>();
int32_t offset = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBufferSubData(%u, %" PRId32 ", %" PRId32 ", %p)\n", target, offset, size,
data);
if (glBufferSubData != nullptr) {
glBufferSubData(target, offset, size, data);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBufferSubData returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBufferSubData\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBufferSubData\n");
return false;
}
}
bool callGlDeleteBuffers(Stack* stack, bool pushReturn) {
uint32_t* buffers = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteBuffers(%" PRId32 ", %p)\n", count, buffers);
if (glDeleteBuffers != nullptr) {
glDeleteBuffers(count, buffers);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteBuffers returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteBuffers\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteBuffers\n");
return false;
}
}
bool callGlIsBuffer(Stack* stack, bool pushReturn) {
uint32_t buffer = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glIsBuffer(%" PRIu32 ")\n", buffer);
if (glIsBuffer != nullptr) {
bool return_value = glIsBuffer(buffer);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<bool>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glIsBuffer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glIsBuffer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glIsBuffer\n");
return false;
}
}
bool callGlGetBufferParameteriv(Stack* stack, bool pushReturn) {
int32_t* value = stack->pop<int32_t*>();
GLenum parameter = stack->pop<GLenum>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetBufferParameteriv(%u, %u, %p)\n", target, parameter, value);
if (glGetBufferParameteriv != nullptr) {
glGetBufferParameteriv(target, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetBufferParameteriv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetBufferParameteriv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetBufferParameteriv\n");
return false;
}
}
bool callGlCreateShader(Stack* stack, bool pushReturn) {
GLenum type = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glCreateShader(%u)\n", type);
if (glCreateShader != nullptr) {
uint32_t return_value = glCreateShader(type);
GAPID_INFO("Returned: %" PRIu32 "\n", return_value);
if (pushReturn) {
stack->push<uint32_t>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glCreateShader returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glCreateShader\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glCreateShader\n");
return false;
}
}
bool callGlDeleteShader(Stack* stack, bool pushReturn) {
uint32_t shader = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteShader(%" PRIu32 ")\n", shader);
if (glDeleteShader != nullptr) {
glDeleteShader(shader);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteShader returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteShader\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteShader\n");
return false;
}
}
bool callGlShaderSource(Stack* stack, bool pushReturn) {
int32_t* length = stack->pop<int32_t*>();
char** source = stack->pop<char**>();
int32_t count = stack->pop<int32_t>();
uint32_t shader = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glShaderSource(%" PRIu32 ", %" PRId32 ", %p, %p)\n", shader, count, source,
length);
if (glShaderSource != nullptr) {
glShaderSource(shader, count, source, length);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glShaderSource returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glShaderSource\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glShaderSource\n");
return false;
}
}
bool callGlShaderBinary(Stack* stack, bool pushReturn) {
int32_t binary_size = stack->pop<int32_t>();
void* binary = stack->pop<void*>();
uint32_t binary_format = stack->pop<uint32_t>();
uint32_t* shaders = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glShaderBinary(%" PRId32 ", %p, %" PRIu32 ", %p, %" PRId32 ")\n", count,
shaders, binary_format, binary, binary_size);
if (glShaderBinary != nullptr) {
glShaderBinary(count, shaders, binary_format, binary, binary_size);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glShaderBinary returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glShaderBinary\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glShaderBinary\n");
return false;
}
}
bool callGlGetShaderInfoLog(Stack* stack, bool pushReturn) {
char* info = stack->pop<char*>();
int32_t* string_length_written = stack->pop<int32_t*>();
int32_t buffer_length = stack->pop<int32_t>();
uint32_t shader = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetShaderInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)\n", shader, buffer_length,
string_length_written, info);
if (glGetShaderInfoLog != nullptr) {
glGetShaderInfoLog(shader, buffer_length, string_length_written, info);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetShaderInfoLog returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetShaderInfoLog\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetShaderInfoLog\n");
return false;
}
}
bool callGlGetShaderSource(Stack* stack, bool pushReturn) {
char* source = stack->pop<char*>();
int32_t* string_length_written = stack->pop<int32_t*>();
int32_t buffer_length = stack->pop<int32_t>();
uint32_t shader = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetShaderSource(%" PRIu32 ", %" PRId32 ", %p, %p)\n", shader, buffer_length,
string_length_written, source);
if (glGetShaderSource != nullptr) {
glGetShaderSource(shader, buffer_length, string_length_written, source);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetShaderSource returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetShaderSource\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetShaderSource\n");
return false;
}
}
bool callGlReleaseShaderCompiler(Stack* stack, bool pushReturn) {
if (stack->isValid()) {
GAPID_INFO("glReleaseShaderCompiler()\n");
if (glReleaseShaderCompiler != nullptr) {
glReleaseShaderCompiler();
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glReleaseShaderCompiler returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glReleaseShaderCompiler\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glReleaseShaderCompiler\n");
return false;
}
}
bool callGlCompileShader(Stack* stack, bool pushReturn) {
uint32_t shader = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glCompileShader(%" PRIu32 ")\n", shader);
if (glCompileShader != nullptr) {
glCompileShader(shader);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glCompileShader returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glCompileShader\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glCompileShader\n");
return false;
}
}
bool callGlIsShader(Stack* stack, bool pushReturn) {
uint32_t shader = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glIsShader(%" PRIu32 ")\n", shader);
if (glIsShader != nullptr) {
bool return_value = glIsShader(shader);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<bool>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glIsShader returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glIsShader\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glIsShader\n");
return false;
}
}
bool callGlCreateProgram(Stack* stack, bool pushReturn) {
if (stack->isValid()) {
GAPID_INFO("glCreateProgram()\n");
if (glCreateProgram != nullptr) {
uint32_t return_value = glCreateProgram();
GAPID_INFO("Returned: %" PRIu32 "\n", return_value);
if (pushReturn) {
stack->push<uint32_t>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glCreateProgram returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glCreateProgram\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glCreateProgram\n");
return false;
}
}
bool callGlDeleteProgram(Stack* stack, bool pushReturn) {
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteProgram(%" PRIu32 ")\n", program);
if (glDeleteProgram != nullptr) {
glDeleteProgram(program);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteProgram returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteProgram\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteProgram\n");
return false;
}
}
bool callGlAttachShader(Stack* stack, bool pushReturn) {
uint32_t shader = stack->pop<uint32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glAttachShader(%" PRIu32 ", %" PRIu32 ")\n", program, shader);
if (glAttachShader != nullptr) {
glAttachShader(program, shader);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glAttachShader returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glAttachShader\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glAttachShader\n");
return false;
}
}
bool callGlDetachShader(Stack* stack, bool pushReturn) {
uint32_t shader = stack->pop<uint32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glDetachShader(%" PRIu32 ", %" PRIu32 ")\n", program, shader);
if (glDetachShader != nullptr) {
glDetachShader(program, shader);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDetachShader returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDetachShader\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDetachShader\n");
return false;
}
}
bool callGlGetAttachedShaders(Stack* stack, bool pushReturn) {
uint32_t* shaders = stack->pop<uint32_t*>();
int32_t* shaders_length_written = stack->pop<int32_t*>();
int32_t buffer_length = stack->pop<int32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetAttachedShaders(%" PRIu32 ", %" PRId32 ", %p, %p)\n", program,
buffer_length, shaders_length_written, shaders);
if (glGetAttachedShaders != nullptr) {
glGetAttachedShaders(program, buffer_length, shaders_length_written, shaders);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetAttachedShaders returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetAttachedShaders\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetAttachedShaders\n");
return false;
}
}
bool callGlLinkProgram(Stack* stack, bool pushReturn) {
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glLinkProgram(%" PRIu32 ")\n", program);
if (glLinkProgram != nullptr) {
glLinkProgram(program);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glLinkProgram returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glLinkProgram\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glLinkProgram\n");
return false;
}
}
bool callGlGetProgramInfoLog(Stack* stack, bool pushReturn) {
char* info = stack->pop<char*>();
int32_t* string_length_written = stack->pop<int32_t*>();
int32_t buffer_length = stack->pop<int32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetProgramInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)\n", program,
buffer_length, string_length_written, info);
if (glGetProgramInfoLog != nullptr) {
glGetProgramInfoLog(program, buffer_length, string_length_written, info);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetProgramInfoLog returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetProgramInfoLog\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetProgramInfoLog\n");
return false;
}
}
bool callGlUseProgram(Stack* stack, bool pushReturn) {
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glUseProgram(%" PRIu32 ")\n", program);
if (glUseProgram != nullptr) {
glUseProgram(program);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUseProgram returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUseProgram\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUseProgram\n");
return false;
}
}
bool callGlIsProgram(Stack* stack, bool pushReturn) {
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glIsProgram(%" PRIu32 ")\n", program);
if (glIsProgram != nullptr) {
bool return_value = glIsProgram(program);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<bool>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glIsProgram returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glIsProgram\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glIsProgram\n");
return false;
}
}
bool callGlValidateProgram(Stack* stack, bool pushReturn) {
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glValidateProgram(%" PRIu32 ")\n", program);
if (glValidateProgram != nullptr) {
glValidateProgram(program);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glValidateProgram returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glValidateProgram\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glValidateProgram\n");
return false;
}
}
bool callGlClearColor(Stack* stack, bool pushReturn) {
float a = stack->pop<float>();
float b = stack->pop<float>();
float g = stack->pop<float>();
float r = stack->pop<float>();
if (stack->isValid()) {
GAPID_INFO("glClearColor(%f, %f, %f, %f)\n", r, g, b, a);
if (glClearColor != nullptr) {
glClearColor(r, g, b, a);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glClearColor returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glClearColor\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glClearColor\n");
return false;
}
}
bool callGlClearDepthf(Stack* stack, bool pushReturn) {
float depth = stack->pop<float>();
if (stack->isValid()) {
GAPID_INFO("glClearDepthf(%f)\n", depth);
if (glClearDepthf != nullptr) {
glClearDepthf(depth);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glClearDepthf returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glClearDepthf\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glClearDepthf\n");
return false;
}
}
bool callGlClearStencil(Stack* stack, bool pushReturn) {
int32_t stencil = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glClearStencil(%" PRId32 ")\n", stencil);
if (glClearStencil != nullptr) {
glClearStencil(stencil);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glClearStencil returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glClearStencil\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glClearStencil\n");
return false;
}
}
bool callGlClear(Stack* stack, bool pushReturn) {
GLbitfield mask = stack->pop<GLbitfield>();
if (stack->isValid()) {
GAPID_INFO("glClear(%u)\n", mask);
if (glClear != nullptr) {
glClear(mask);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glClear returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glClear\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glClear\n");
return false;
}
}
bool callGlCullFace(Stack* stack, bool pushReturn) {
GLenum mode = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glCullFace(%u)\n", mode);
if (glCullFace != nullptr) {
glCullFace(mode);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glCullFace returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glCullFace\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glCullFace\n");
return false;
}
}
bool callGlPolygonOffset(Stack* stack, bool pushReturn) {
float units = stack->pop<float>();
float scale_factor = stack->pop<float>();
if (stack->isValid()) {
GAPID_INFO("glPolygonOffset(%f, %f)\n", scale_factor, units);
if (glPolygonOffset != nullptr) {
glPolygonOffset(scale_factor, units);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glPolygonOffset returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glPolygonOffset\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glPolygonOffset\n");
return false;
}
}
bool callGlLineWidth(Stack* stack, bool pushReturn) {
float width = stack->pop<float>();
if (stack->isValid()) {
GAPID_INFO("glLineWidth(%f)\n", width);
if (glLineWidth != nullptr) {
glLineWidth(width);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glLineWidth returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glLineWidth\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glLineWidth\n");
return false;
}
}
bool callGlSampleCoverage(Stack* stack, bool pushReturn) {
bool invert = stack->pop<bool>();
float value = stack->pop<float>();
if (stack->isValid()) {
GAPID_INFO("glSampleCoverage(%f, %d)\n", value, invert);
if (glSampleCoverage != nullptr) {
glSampleCoverage(value, invert);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glSampleCoverage returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glSampleCoverage\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glSampleCoverage\n");
return false;
}
}
bool callGlHint(Stack* stack, bool pushReturn) {
GLenum mode = stack->pop<GLenum>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glHint(%u, %u)\n", target, mode);
if (glHint != nullptr) {
glHint(target, mode);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glHint returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glHint\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glHint\n");
return false;
}
}
bool callGlFramebufferRenderbuffer(Stack* stack, bool pushReturn) {
uint32_t renderbuffer = stack->pop<uint32_t>();
GLenum renderbuffer_target = stack->pop<GLenum>();
GLenum framebuffer_attachment = stack->pop<GLenum>();
GLenum framebuffer_target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glFramebufferRenderbuffer(%u, %u, %u, %" PRIu32 ")\n", framebuffer_target,
framebuffer_attachment, renderbuffer_target, renderbuffer);
if (glFramebufferRenderbuffer != nullptr) {
glFramebufferRenderbuffer(framebuffer_target, framebuffer_attachment,
renderbuffer_target, renderbuffer);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glFramebufferRenderbuffer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glFramebufferRenderbuffer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glFramebufferRenderbuffer\n");
return false;
}
}
bool callGlFramebufferTexture2D(Stack* stack, bool pushReturn) {
int32_t level = stack->pop<int32_t>();
uint32_t texture = stack->pop<uint32_t>();
GLenum texture_target = stack->pop<GLenum>();
GLenum framebuffer_attachment = stack->pop<GLenum>();
GLenum framebuffer_target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glFramebufferTexture2D(%u, %u, %u, %" PRIu32 ", %" PRId32 ")\n",
framebuffer_target, framebuffer_attachment, texture_target, texture, level);
if (glFramebufferTexture2D != nullptr) {
glFramebufferTexture2D(framebuffer_target, framebuffer_attachment, texture_target,
texture, level);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glFramebufferTexture2D returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glFramebufferTexture2D\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glFramebufferTexture2D\n");
return false;
}
}
bool callGlGetFramebufferAttachmentParameteriv(Stack* stack, bool pushReturn) {
int32_t* value = stack->pop<int32_t*>();
GLenum parameter = stack->pop<GLenum>();
GLenum attachment = stack->pop<GLenum>();
GLenum framebuffer_target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetFramebufferAttachmentParameteriv(%u, %u, %u, %p)\n", framebuffer_target,
attachment, parameter, value);
if (glGetFramebufferAttachmentParameteriv != nullptr) {
glGetFramebufferAttachmentParameteriv(framebuffer_target, attachment, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetFramebufferAttachmentParameteriv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING(
"Attempted to call unsupported function "
"glGetFramebufferAttachmentParameteriv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetFramebufferAttachmentParameteriv\n");
return false;
}
}
bool callGlDrawElements(Stack* stack, bool pushReturn) {
void* indices = stack->pop<void*>();
GLenum indices_type = stack->pop<GLenum>();
int32_t element_count = stack->pop<int32_t>();
GLenum draw_mode = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glDrawElements(%u, %" PRId32 ", %u, %p)\n", draw_mode, element_count,
indices_type, indices);
if (glDrawElements != nullptr) {
glDrawElements(draw_mode, element_count, indices_type, indices);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDrawElements returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDrawElements\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDrawElements\n");
return false;
}
}
bool callGlDrawArrays(Stack* stack, bool pushReturn) {
int32_t index_count = stack->pop<int32_t>();
int32_t first_index = stack->pop<int32_t>();
GLenum draw_mode = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glDrawArrays(%u, %" PRId32 ", %" PRId32 ")\n", draw_mode, first_index,
index_count);
if (glDrawArrays != nullptr) {
glDrawArrays(draw_mode, first_index, index_count);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDrawArrays returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDrawArrays\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDrawArrays\n");
return false;
}
}
bool callGlFlush(Stack* stack, bool pushReturn) {
if (stack->isValid()) {
GAPID_INFO("glFlush()\n");
if (glFlush != nullptr) {
glFlush();
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glFlush returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glFlush\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glFlush\n");
return false;
}
}
bool callGlFinish(Stack* stack, bool pushReturn) {
if (stack->isValid()) {
GAPID_INFO("glFinish()\n");
if (glFinish != nullptr) {
glFinish();
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glFinish returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glFinish\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glFinish\n");
return false;
}
}
bool callGlGetBooleanv(Stack* stack, bool pushReturn) {
bool* values = stack->pop<bool*>();
GLenum param = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetBooleanv(%u, %p)\n", param, values);
if (glGetBooleanv != nullptr) {
glGetBooleanv(param, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetBooleanv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetBooleanv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetBooleanv\n");
return false;
}
}
bool callGlGetFloatv(Stack* stack, bool pushReturn) {
float* values = stack->pop<float*>();
GLenum param = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetFloatv(%u, %p)\n", param, values);
if (glGetFloatv != nullptr) {
glGetFloatv(param, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetFloatv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetFloatv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetFloatv\n");
return false;
}
}
bool callGlGetIntegerv(Stack* stack, bool pushReturn) {
int32_t* values = stack->pop<int32_t*>();
GLenum param = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetIntegerv(%u, %p)\n", param, values);
if (glGetIntegerv != nullptr) {
glGetIntegerv(param, values);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetIntegerv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetIntegerv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetIntegerv\n");
return false;
}
}
bool callGlGetString(Stack* stack, bool pushReturn) {
GLenum param = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetString(%u)\n", param);
if (glGetString != nullptr) {
char* return_value = glGetString(param);
GAPID_INFO("Returned: %p\n", return_value);
if (pushReturn) {
stack->push<char*>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetString returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetString\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetString\n");
return false;
}
}
bool callGlEnable(Stack* stack, bool pushReturn) {
GLenum capability = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glEnable(%u)\n", capability);
if (glEnable != nullptr) {
glEnable(capability);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glEnable returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glEnable\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glEnable\n");
return false;
}
}
bool callGlDisable(Stack* stack, bool pushReturn) {
GLenum capability = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glDisable(%u)\n", capability);
if (glDisable != nullptr) {
glDisable(capability);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDisable returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDisable\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDisable\n");
return false;
}
}
bool callGlIsEnabled(Stack* stack, bool pushReturn) {
GLenum capability = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glIsEnabled(%u)\n", capability);
if (glIsEnabled != nullptr) {
bool return_value = glIsEnabled(capability);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<bool>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glIsEnabled returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glIsEnabled\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glIsEnabled\n");
return false;
}
}
bool callGlFenceSync(Stack* stack, bool pushReturn) {
SyncFlags syncFlags = stack->pop<SyncFlags>();
SyncCondition condition = stack->pop<SyncCondition>();
if (stack->isValid()) {
GAPID_INFO("glFenceSync(%u, %u)\n", condition, syncFlags);
if (glFenceSync != nullptr) {
uint64_t return_value = glFenceSync(condition, syncFlags);
GAPID_INFO("Returned: %" PRIu64 "\n", return_value);
if (pushReturn) {
stack->push<uint64_t>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glFenceSync returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glFenceSync\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glFenceSync\n");
return false;
}
}
bool callGlDeleteSync(Stack* stack, bool pushReturn) {
uint64_t sync = stack->pop<uint64_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteSync(%" PRIu64 ")\n", sync);
if (glDeleteSync != nullptr) {
glDeleteSync(sync);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteSync returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteSync\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteSync\n");
return false;
}
}
bool callGlWaitSync(Stack* stack, bool pushReturn) {
uint64_t timeout = stack->pop<uint64_t>();
SyncFlags syncFlags = stack->pop<SyncFlags>();
uint64_t sync = stack->pop<uint64_t>();
if (stack->isValid()) {
GAPID_INFO("glWaitSync(%" PRIu64 ", %u, %" PRIu64 ")\n", sync, syncFlags, timeout);
if (glWaitSync != nullptr) {
glWaitSync(sync, syncFlags, timeout);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glWaitSync returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glWaitSync\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glWaitSync\n");
return false;
}
}
bool callGlClientWaitSync(Stack* stack, bool pushReturn) {
uint64_t timeout = stack->pop<uint64_t>();
SyncFlags syncFlags = stack->pop<SyncFlags>();
uint64_t sync = stack->pop<uint64_t>();
if (stack->isValid()) {
GAPID_INFO("glClientWaitSync(%" PRIu64 ", %u, %" PRIu64 ")\n", sync, syncFlags, timeout);
if (glClientWaitSync != nullptr) {
ClientWaitSyncSignal return_value = glClientWaitSync(sync, syncFlags, timeout);
GAPID_INFO("Returned: %u\n", return_value);
if (pushReturn) {
stack->push<ClientWaitSyncSignal>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glClientWaitSync returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glClientWaitSync\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glClientWaitSync\n");
return false;
}
}
bool callGlMapBufferRange(Stack* stack, bool pushReturn) {
GLbitfield access = stack->pop<GLbitfield>();
int32_t length = stack->pop<int32_t>();
int32_t offset = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glMapBufferRange(%u, %" PRId32 ", %" PRId32 ", %u)\n", target, offset, length,
access);
if (glMapBufferRange != nullptr) {
void* return_value = glMapBufferRange(target, offset, length, access);
GAPID_INFO("Returned: %p\n", return_value);
if (pushReturn) {
stack->push<void*>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glMapBufferRange returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glMapBufferRange\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glMapBufferRange\n");
return false;
}
}
bool callGlUnmapBuffer(Stack* stack, bool pushReturn) {
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glUnmapBuffer(%u)\n", target);
if (glUnmapBuffer != nullptr) {
glUnmapBuffer(target);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUnmapBuffer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUnmapBuffer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUnmapBuffer\n");
return false;
}
}
bool callGlInvalidateFramebuffer(Stack* stack, bool pushReturn) {
GLenum* attachments = stack->pop<GLenum*>();
int32_t count = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glInvalidateFramebuffer(%u, %" PRId32 ", %p)\n", target, count, attachments);
if (glInvalidateFramebuffer != nullptr) {
glInvalidateFramebuffer(target, count, attachments);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glInvalidateFramebuffer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glInvalidateFramebuffer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glInvalidateFramebuffer\n");
return false;
}
}
bool callGlRenderbufferStorageMultisample(Stack* stack, bool pushReturn) {
int32_t height = stack->pop<int32_t>();
int32_t width = stack->pop<int32_t>();
GLenum format = stack->pop<GLenum>();
int32_t samples = stack->pop<int32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glRenderbufferStorageMultisample(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32
")\n",
target, samples, format, width, height);
if (glRenderbufferStorageMultisample != nullptr) {
glRenderbufferStorageMultisample(target, samples, format, width, height);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glRenderbufferStorageMultisample returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING(
"Attempted to call unsupported function glRenderbufferStorageMultisample\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glRenderbufferStorageMultisample\n");
return false;
}
}
bool callGlBlitFramebuffer(Stack* stack, bool pushReturn) {
GLenum filter = stack->pop<GLenum>();
GLbitfield mask = stack->pop<GLbitfield>();
int32_t dstY1 = stack->pop<int32_t>();
int32_t dstX1 = stack->pop<int32_t>();
int32_t dstY0 = stack->pop<int32_t>();
int32_t dstX0 = stack->pop<int32_t>();
int32_t srcY1 = stack->pop<int32_t>();
int32_t srcX1 = stack->pop<int32_t>();
int32_t srcY0 = stack->pop<int32_t>();
int32_t srcX0 = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glBlitFramebuffer(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u)\n",
srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
if (glBlitFramebuffer != nullptr) {
glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBlitFramebuffer returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBlitFramebuffer\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBlitFramebuffer\n");
return false;
}
}
bool callGlGenQueries(Stack* stack, bool pushReturn) {
uint32_t* queries = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glGenQueries(%" PRId32 ", %p)\n", count, queries);
if (glGenQueries != nullptr) {
glGenQueries(count, queries);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGenQueries returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGenQueries\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGenQueries\n");
return false;
}
}
bool callGlBeginQuery(Stack* stack, bool pushReturn) {
uint32_t query = stack->pop<uint32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBeginQuery(%u, %" PRIu32 ")\n", target, query);
if (glBeginQuery != nullptr) {
glBeginQuery(target, query);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBeginQuery returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBeginQuery\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBeginQuery\n");
return false;
}
}
bool callGlEndQuery(Stack* stack, bool pushReturn) {
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glEndQuery(%u)\n", target);
if (glEndQuery != nullptr) {
glEndQuery(target);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glEndQuery returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glEndQuery\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glEndQuery\n");
return false;
}
}
bool callGlDeleteQueries(Stack* stack, bool pushReturn) {
uint32_t* queries = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteQueries(%" PRId32 ", %p)\n", count, queries);
if (glDeleteQueries != nullptr) {
glDeleteQueries(count, queries);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteQueries returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteQueries\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteQueries\n");
return false;
}
}
bool callGlIsQuery(Stack* stack, bool pushReturn) {
uint32_t query = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glIsQuery(%" PRIu32 ")\n", query);
if (glIsQuery != nullptr) {
bool return_value = glIsQuery(query);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<bool>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glIsQuery returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glIsQuery\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glIsQuery\n");
return false;
}
}
bool callGlGetQueryiv(Stack* stack, bool pushReturn) {
int32_t* value = stack->pop<int32_t*>();
GLenum parameter = stack->pop<GLenum>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetQueryiv(%u, %u, %p)\n", target, parameter, value);
if (glGetQueryiv != nullptr) {
glGetQueryiv(target, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetQueryiv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetQueryiv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetQueryiv\n");
return false;
}
}
bool callGlGetQueryObjectuiv(Stack* stack, bool pushReturn) {
uint32_t* value = stack->pop<uint32_t*>();
GLenum parameter = stack->pop<GLenum>();
uint32_t query = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetQueryObjectuiv(%" PRIu32 ", %u, %p)\n", query, parameter, value);
if (glGetQueryObjectuiv != nullptr) {
glGetQueryObjectuiv(query, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetQueryObjectuiv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectuiv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetQueryObjectuiv\n");
return false;
}
}
bool callGlGetActiveUniformBlockName(Stack* stack, bool pushReturn) {
char* name = stack->pop<char*>();
int32_t* buffer_bytes_written = stack->pop<int32_t*>();
int32_t buffer_size = stack->pop<int32_t>();
uint32_t uniform_block_index = stack->pop<uint32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetActiveUniformBlockName(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p)\n",
program, uniform_block_index, buffer_size, buffer_bytes_written, name);
if (glGetActiveUniformBlockName != nullptr) {
glGetActiveUniformBlockName(program, uniform_block_index, buffer_size,
buffer_bytes_written, name);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetActiveUniformBlockName returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetActiveUniformBlockName\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetActiveUniformBlockName\n");
return false;
}
}
bool callGlGetActiveUniformBlockiv(Stack* stack, bool pushReturn) {
int32_t* parameters = stack->pop<int32_t*>();
GLenum parameter_name = stack->pop<GLenum>();
uint32_t uniform_block_index = stack->pop<uint32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetActiveUniformBlockiv(%" PRIu32 ", %" PRIu32 ", %u, %p)\n", program,
uniform_block_index, parameter_name, parameters);
if (glGetActiveUniformBlockiv != nullptr) {
glGetActiveUniformBlockiv(program, uniform_block_index, parameter_name, parameters);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetActiveUniformBlockiv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetActiveUniformBlockiv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetActiveUniformBlockiv\n");
return false;
}
}
bool callGlUniformBlockBinding(Stack* stack, bool pushReturn) {
uint32_t uniform_block_binding = stack->pop<uint32_t>();
uint32_t uniform_block_index = stack->pop<uint32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glUniformBlockBinding(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")\n", program,
uniform_block_index, uniform_block_binding);
if (glUniformBlockBinding != nullptr) {
glUniformBlockBinding(program, uniform_block_index, uniform_block_binding);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glUniformBlockBinding returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glUniformBlockBinding\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glUniformBlockBinding\n");
return false;
}
}
bool callGlGetActiveUniformsiv(Stack* stack, bool pushReturn) {
int32_t* parameters = stack->pop<int32_t*>();
GLenum parameter_name = stack->pop<GLenum>();
uint32_t* uniform_indices = stack->pop<uint32_t*>();
uint32_t uniform_count = stack->pop<uint32_t>();
uint32_t program = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetActiveUniformsiv(%" PRIu32 ", %" PRIu32 ", %p, %u, %p)\n", program,
uniform_count, uniform_indices, parameter_name, parameters);
if (glGetActiveUniformsiv != nullptr) {
glGetActiveUniformsiv(program, uniform_count, uniform_indices, parameter_name,
parameters);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetActiveUniformsiv returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetActiveUniformsiv\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetActiveUniformsiv\n");
return false;
}
}
bool callGlBindBufferBase(Stack* stack, bool pushReturn) {
uint32_t buffer = stack->pop<uint32_t>();
uint32_t index = stack->pop<uint32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBindBufferBase(%u, %" PRIu32 ", %" PRIu32 ")\n", target, index, buffer);
if (glBindBufferBase != nullptr) {
glBindBufferBase(target, index, buffer);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBindBufferBase returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBindBufferBase\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBindBufferBase\n");
return false;
}
}
bool callGlGenVertexArrays(Stack* stack, bool pushReturn) {
uint32_t* arrays = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glGenVertexArrays(%" PRId32 ", %p)\n", count, arrays);
if (glGenVertexArrays != nullptr) {
glGenVertexArrays(count, arrays);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGenVertexArrays returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGenVertexArrays\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGenVertexArrays\n");
return false;
}
}
bool callGlBindVertexArray(Stack* stack, bool pushReturn) {
uint32_t array = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glBindVertexArray(%" PRIu32 ")\n", array);
if (glBindVertexArray != nullptr) {
glBindVertexArray(array);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBindVertexArray returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBindVertexArray\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBindVertexArray\n");
return false;
}
}
bool callGlDeleteVertexArrays(Stack* stack, bool pushReturn) {
uint32_t* arrays = stack->pop<uint32_t*>();
uint32_t count = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteVertexArrays(%" PRIu32 ", %p)\n", count, arrays);
if (glDeleteVertexArrays != nullptr) {
glDeleteVertexArrays(count, arrays);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteVertexArrays returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteVertexArrays\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteVertexArrays\n");
return false;
}
}
bool callGlGetQueryObjecti64v(Stack* stack, bool pushReturn) {
int64_t* value = stack->pop<int64_t*>();
GLenum parameter = stack->pop<GLenum>();
uint32_t query = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetQueryObjecti64v(%" PRIu32 ", %u, %p)\n", query, parameter, value);
if (glGetQueryObjecti64v != nullptr) {
glGetQueryObjecti64v(query, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetQueryObjecti64v returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetQueryObjecti64v\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetQueryObjecti64v\n");
return false;
}
}
bool callGlGetQueryObjectui64v(Stack* stack, bool pushReturn) {
uint64_t* value = stack->pop<uint64_t*>();
GLenum parameter = stack->pop<GLenum>();
uint32_t query = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetQueryObjectui64v(%" PRIu32 ", %u, %p)\n", query, parameter, value);
if (glGetQueryObjectui64v != nullptr) {
glGetQueryObjectui64v(query, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetQueryObjectui64v returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectui64v\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetQueryObjectui64v\n");
return false;
}
}
bool callGlGenQueriesEXT(Stack* stack, bool pushReturn) {
uint32_t* queries = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glGenQueriesEXT(%" PRId32 ", %p)\n", count, queries);
if (glGenQueriesEXT != nullptr) {
glGenQueriesEXT(count, queries);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGenQueriesEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGenQueriesEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGenQueriesEXT\n");
return false;
}
}
bool callGlBeginQueryEXT(Stack* stack, bool pushReturn) {
uint32_t query = stack->pop<uint32_t>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glBeginQueryEXT(%u, %" PRIu32 ")\n", target, query);
if (glBeginQueryEXT != nullptr) {
glBeginQueryEXT(target, query);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glBeginQueryEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glBeginQueryEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glBeginQueryEXT\n");
return false;
}
}
bool callGlEndQueryEXT(Stack* stack, bool pushReturn) {
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glEndQueryEXT(%u)\n", target);
if (glEndQueryEXT != nullptr) {
glEndQueryEXT(target);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glEndQueryEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glEndQueryEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glEndQueryEXT\n");
return false;
}
}
bool callGlDeleteQueriesEXT(Stack* stack, bool pushReturn) {
uint32_t* queries = stack->pop<uint32_t*>();
int32_t count = stack->pop<int32_t>();
if (stack->isValid()) {
GAPID_INFO("glDeleteQueriesEXT(%" PRId32 ", %p)\n", count, queries);
if (glDeleteQueriesEXT != nullptr) {
glDeleteQueriesEXT(count, queries);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glDeleteQueriesEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glDeleteQueriesEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glDeleteQueriesEXT\n");
return false;
}
}
bool callGlIsQueryEXT(Stack* stack, bool pushReturn) {
uint32_t query = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glIsQueryEXT(%" PRIu32 ")\n", query);
if (glIsQueryEXT != nullptr) {
bool return_value = glIsQueryEXT(query);
GAPID_INFO("Returned: %d\n", return_value);
if (pushReturn) {
stack->push<bool>(return_value);
}
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glIsQueryEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glIsQueryEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glIsQueryEXT\n");
return false;
}
}
bool callGlQueryCounterEXT(Stack* stack, bool pushReturn) {
GLenum target = stack->pop<GLenum>();
uint32_t query = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glQueryCounterEXT(%" PRIu32 ", %u)\n", query, target);
if (glQueryCounterEXT != nullptr) {
glQueryCounterEXT(query, target);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glQueryCounterEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glQueryCounterEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glQueryCounterEXT\n");
return false;
}
}
bool callGlGetQueryivEXT(Stack* stack, bool pushReturn) {
int32_t* value = stack->pop<int32_t*>();
GLenum parameter = stack->pop<GLenum>();
GLenum target = stack->pop<GLenum>();
if (stack->isValid()) {
GAPID_INFO("glGetQueryivEXT(%u, %u, %p)\n", target, parameter, value);
if (glGetQueryivEXT != nullptr) {
glGetQueryivEXT(target, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetQueryivEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetQueryivEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetQueryivEXT\n");
return false;
}
}
bool callGlGetQueryObjectivEXT(Stack* stack, bool pushReturn) {
int32_t* value = stack->pop<int32_t*>();
GLenum parameter = stack->pop<GLenum>();
uint32_t query = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetQueryObjectivEXT(%" PRIu32 ", %u, %p)\n", query, parameter, value);
if (glGetQueryObjectivEXT != nullptr) {
glGetQueryObjectivEXT(query, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetQueryObjectivEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectivEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetQueryObjectivEXT\n");
return false;
}
}
bool callGlGetQueryObjectuivEXT(Stack* stack, bool pushReturn) {
uint32_t* value = stack->pop<uint32_t*>();
GLenum parameter = stack->pop<GLenum>();
uint32_t query = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetQueryObjectuivEXT(%" PRIu32 ", %u, %p)\n", query, parameter, value);
if (glGetQueryObjectuivEXT != nullptr) {
glGetQueryObjectuivEXT(query, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetQueryObjectuivEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectuivEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetQueryObjectuivEXT\n");
return false;
}
}
bool callGlGetQueryObjecti64vEXT(Stack* stack, bool pushReturn) {
int64_t* value = stack->pop<int64_t*>();
GLenum parameter = stack->pop<GLenum>();
uint32_t query = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetQueryObjecti64vEXT(%" PRIu32 ", %u, %p)\n", query, parameter, value);
if (glGetQueryObjecti64vEXT != nullptr) {
glGetQueryObjecti64vEXT(query, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetQueryObjecti64vEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetQueryObjecti64vEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetQueryObjecti64vEXT\n");
return false;
}
}
bool callGlGetQueryObjectui64vEXT(Stack* stack, bool pushReturn) {
uint64_t* value = stack->pop<uint64_t*>();
GLenum parameter = stack->pop<GLenum>();
uint32_t query = stack->pop<uint32_t>();
if (stack->isValid()) {
GAPID_INFO("glGetQueryObjectui64vEXT(%" PRIu32 ", %u, %p)\n", query, parameter, value);
if (glGetQueryObjectui64vEXT != nullptr) {
glGetQueryObjectui64vEXT(query, parameter, value);
const GLenum err = glGetError();
if (err != GLenum::GL_NO_ERROR) {
GAPID_WARNING("glGetQueryObjectui64vEXT returned error: 0x%x\n", err);
}
} else {
GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectui64vEXT\n");
}
return true;
} else {
GAPID_WARNING("Error during calling function glGetQueryObjectui64vEXT\n");
return false;
}
}
} // end of anonymous namespace
PFNEGLINITIALIZE eglInitialize = nullptr;
PFNEGLCREATECONTEXT eglCreateContext = nullptr;
PFNEGLMAKECURRENT eglMakeCurrent = nullptr;
PFNEGLSWAPBUFFERS eglSwapBuffers = nullptr;
PFNEGLQUERYSURFACE eglQuerySurface = nullptr;
PFNGLXCREATECONTEXT glXCreateContext = nullptr;
PFNGLXCREATENEWCONTEXT glXCreateNewContext = nullptr;
PFNGLXMAKECONTEXTCURRENT glXMakeContextCurrent = nullptr;
PFNGLXMAKECURRENT glXMakeCurrent = nullptr;
PFNGLXSWAPBUFFERS glXSwapBuffers = nullptr;
PFNGLXQUERYDRAWABLE glXQueryDrawable = nullptr;
PFNWGLCREATECONTEXT wglCreateContext = nullptr;
PFNWGLCREATECONTEXTATTRIBSARB wglCreateContextAttribsARB = nullptr;
PFNWGLMAKECURRENT wglMakeCurrent = nullptr;
PFNWGLSWAPBUFFERS wglSwapBuffers = nullptr;
PFNCGLCREATECONTEXT CGLCreateContext = nullptr;
PFNCGLSETCURRENTCONTEXT CGLSetCurrentContext = nullptr;
PFNCGLGETSURFACE CGLGetSurface = nullptr;
PFNCGSGETSURFACEBOUNDS CGSGetSurfaceBounds = nullptr;
PFNCGLFLUSHDRAWABLE CGLFlushDrawable = nullptr;
PFNGLENABLECLIENTSTATE glEnableClientState = nullptr;
PFNGLDISABLECLIENTSTATE glDisableClientState = nullptr;
PFNGLGETPROGRAMBINARYOES glGetProgramBinaryOES = nullptr;
PFNGLPROGRAMBINARYOES glProgramBinaryOES = nullptr;
PFNGLSTARTTILINGQCOM glStartTilingQCOM = nullptr;
PFNGLENDTILINGQCOM glEndTilingQCOM = nullptr;
PFNGLDISCARDFRAMEBUFFEREXT glDiscardFramebufferEXT = nullptr;
PFNGLINSERTEVENTMARKEREXT glInsertEventMarkerEXT = nullptr;
PFNGLPUSHGROUPMARKEREXT glPushGroupMarkerEXT = nullptr;
PFNGLPOPGROUPMARKEREXT glPopGroupMarkerEXT = nullptr;
PFNGLTEXSTORAGE1DEXT glTexStorage1DEXT = nullptr;
PFNGLTEXSTORAGE2DEXT glTexStorage2DEXT = nullptr;
PFNGLTEXSTORAGE3DEXT glTexStorage3DEXT = nullptr;
PFNGLTEXTURESTORAGE1DEXT glTextureStorage1DEXT = nullptr;
PFNGLTEXTURESTORAGE2DEXT glTextureStorage2DEXT = nullptr;
PFNGLTEXTURESTORAGE3DEXT glTextureStorage3DEXT = nullptr;
PFNGLGENVERTEXARRAYSOES glGenVertexArraysOES = nullptr;
PFNGLBINDVERTEXARRAYOES glBindVertexArrayOES = nullptr;
PFNGLDELETEVERTEXARRAYSOES glDeleteVertexArraysOES = nullptr;
PFNGLISVERTEXARRAYOES glIsVertexArrayOES = nullptr;
PFNGLEGLIMAGETARGETTEXTURE2DOES glEGLImageTargetTexture2DOES = nullptr;
PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOES glEGLImageTargetRenderbufferStorageOES = nullptr;
PFNGLGETGRAPHICSRESETSTATUSEXT glGetGraphicsResetStatusEXT = nullptr;
PFNGLBINDATTRIBLOCATION glBindAttribLocation = nullptr;
PFNGLBLENDFUNC glBlendFunc = nullptr;
PFNGLBLENDFUNCSEPARATE glBlendFuncSeparate = nullptr;
PFNGLBLENDEQUATION glBlendEquation = nullptr;
PFNGLBLENDEQUATIONSEPARATE glBlendEquationSeparate = nullptr;
PFNGLBLENDCOLOR glBlendColor = nullptr;
PFNGLENABLEVERTEXATTRIBARRAY glEnableVertexAttribArray = nullptr;
PFNGLDISABLEVERTEXATTRIBARRAY glDisableVertexAttribArray = nullptr;
PFNGLVERTEXATTRIBPOINTER glVertexAttribPointer = nullptr;
PFNGLGETACTIVEATTRIB glGetActiveAttrib = nullptr;
PFNGLGETACTIVEUNIFORM glGetActiveUniform = nullptr;
PFNGLGETERROR glGetError = nullptr;
PFNGLGETPROGRAMIV glGetProgramiv = nullptr;
PFNGLGETSHADERIV glGetShaderiv = nullptr;
PFNGLGETUNIFORMLOCATION glGetUniformLocation = nullptr;
PFNGLGETATTRIBLOCATION glGetAttribLocation = nullptr;
PFNGLPIXELSTOREI glPixelStorei = nullptr;
PFNGLTEXPARAMETERI glTexParameteri = nullptr;
PFNGLTEXPARAMETERF glTexParameterf = nullptr;
PFNGLGETTEXPARAMETERIV glGetTexParameteriv = nullptr;
PFNGLGETTEXPARAMETERFV glGetTexParameterfv = nullptr;
PFNGLUNIFORM1I glUniform1i = nullptr;
PFNGLUNIFORM2I glUniform2i = nullptr;
PFNGLUNIFORM3I glUniform3i = nullptr;
PFNGLUNIFORM4I glUniform4i = nullptr;
PFNGLUNIFORM1IV glUniform1iv = nullptr;
PFNGLUNIFORM2IV glUniform2iv = nullptr;
PFNGLUNIFORM3IV glUniform3iv = nullptr;
PFNGLUNIFORM4IV glUniform4iv = nullptr;
PFNGLUNIFORM1F glUniform1f = nullptr;
PFNGLUNIFORM2F glUniform2f = nullptr;
PFNGLUNIFORM3F glUniform3f = nullptr;
PFNGLUNIFORM4F glUniform4f = nullptr;
PFNGLUNIFORM1FV glUniform1fv = nullptr;
PFNGLUNIFORM2FV glUniform2fv = nullptr;
PFNGLUNIFORM3FV glUniform3fv = nullptr;
PFNGLUNIFORM4FV glUniform4fv = nullptr;
PFNGLUNIFORMMATRIX2FV glUniformMatrix2fv = nullptr;
PFNGLUNIFORMMATRIX3FV glUniformMatrix3fv = nullptr;
PFNGLUNIFORMMATRIX4FV glUniformMatrix4fv = nullptr;
PFNGLGETUNIFORMFV glGetUniformfv = nullptr;
PFNGLGETUNIFORMIV glGetUniformiv = nullptr;
PFNGLVERTEXATTRIB1F glVertexAttrib1f = nullptr;
PFNGLVERTEXATTRIB2F glVertexAttrib2f = nullptr;
PFNGLVERTEXATTRIB3F glVertexAttrib3f = nullptr;
PFNGLVERTEXATTRIB4F glVertexAttrib4f = nullptr;
PFNGLVERTEXATTRIB1FV glVertexAttrib1fv = nullptr;
PFNGLVERTEXATTRIB2FV glVertexAttrib2fv = nullptr;
PFNGLVERTEXATTRIB3FV glVertexAttrib3fv = nullptr;
PFNGLVERTEXATTRIB4FV glVertexAttrib4fv = nullptr;
PFNGLGETSHADERPRECISIONFORMAT glGetShaderPrecisionFormat = nullptr;
PFNGLDEPTHMASK glDepthMask = nullptr;
PFNGLDEPTHFUNC glDepthFunc = nullptr;
PFNGLDEPTHRANGEF glDepthRangef = nullptr;
PFNGLCOLORMASK glColorMask = nullptr;
PFNGLSTENCILMASK glStencilMask = nullptr;
PFNGLSTENCILMASKSEPARATE glStencilMaskSeparate = nullptr;
PFNGLSTENCILFUNCSEPARATE glStencilFuncSeparate = nullptr;
PFNGLSTENCILOPSEPARATE glStencilOpSeparate = nullptr;
PFNGLFRONTFACE glFrontFace = nullptr;
PFNGLVIEWPORT glViewport = nullptr;
PFNGLSCISSOR glScissor = nullptr;
PFNGLACTIVETEXTURE glActiveTexture = nullptr;
PFNGLGENTEXTURES glGenTextures = nullptr;
PFNGLDELETETEXTURES glDeleteTextures = nullptr;
PFNGLISTEXTURE glIsTexture = nullptr;
PFNGLBINDTEXTURE glBindTexture = nullptr;
PFNGLTEXIMAGE2D glTexImage2D = nullptr;
PFNGLTEXSUBIMAGE2D glTexSubImage2D = nullptr;
PFNGLCOPYTEXIMAGE2D glCopyTexImage2D = nullptr;
PFNGLCOPYTEXSUBIMAGE2D glCopyTexSubImage2D = nullptr;
PFNGLCOMPRESSEDTEXIMAGE2D glCompressedTexImage2D = nullptr;
PFNGLCOMPRESSEDTEXSUBIMAGE2D glCompressedTexSubImage2D = nullptr;
PFNGLGENERATEMIPMAP glGenerateMipmap = nullptr;
PFNGLREADPIXELS glReadPixels = nullptr;
PFNGLGENFRAMEBUFFERS glGenFramebuffers = nullptr;
PFNGLBINDFRAMEBUFFER glBindFramebuffer = nullptr;
PFNGLCHECKFRAMEBUFFERSTATUS glCheckFramebufferStatus = nullptr;
PFNGLDELETEFRAMEBUFFERS glDeleteFramebuffers = nullptr;
PFNGLISFRAMEBUFFER glIsFramebuffer = nullptr;
PFNGLGENRENDERBUFFERS glGenRenderbuffers = nullptr;
PFNGLBINDRENDERBUFFER glBindRenderbuffer = nullptr;
PFNGLRENDERBUFFERSTORAGE glRenderbufferStorage = nullptr;
PFNGLDELETERENDERBUFFERS glDeleteRenderbuffers = nullptr;
PFNGLISRENDERBUFFER glIsRenderbuffer = nullptr;
PFNGLGETRENDERBUFFERPARAMETERIV glGetRenderbufferParameteriv = nullptr;
PFNGLGENBUFFERS glGenBuffers = nullptr;
PFNGLBINDBUFFER glBindBuffer = nullptr;
PFNGLBUFFERDATA glBufferData = nullptr;
PFNGLBUFFERSUBDATA glBufferSubData = nullptr;
PFNGLDELETEBUFFERS glDeleteBuffers = nullptr;
PFNGLISBUFFER glIsBuffer = nullptr;
PFNGLGETBUFFERPARAMETERIV glGetBufferParameteriv = nullptr;
PFNGLCREATESHADER glCreateShader = nullptr;
PFNGLDELETESHADER glDeleteShader = nullptr;
PFNGLSHADERSOURCE glShaderSource = nullptr;
PFNGLSHADERBINARY glShaderBinary = nullptr;
PFNGLGETSHADERINFOLOG glGetShaderInfoLog = nullptr;
PFNGLGETSHADERSOURCE glGetShaderSource = nullptr;
PFNGLRELEASESHADERCOMPILER glReleaseShaderCompiler = nullptr;
PFNGLCOMPILESHADER glCompileShader = nullptr;
PFNGLISSHADER glIsShader = nullptr;
PFNGLCREATEPROGRAM glCreateProgram = nullptr;
PFNGLDELETEPROGRAM glDeleteProgram = nullptr;
PFNGLATTACHSHADER glAttachShader = nullptr;
PFNGLDETACHSHADER glDetachShader = nullptr;
PFNGLGETATTACHEDSHADERS glGetAttachedShaders = nullptr;
PFNGLLINKPROGRAM glLinkProgram = nullptr;
PFNGLGETPROGRAMINFOLOG glGetProgramInfoLog = nullptr;
PFNGLUSEPROGRAM glUseProgram = nullptr;
PFNGLISPROGRAM glIsProgram = nullptr;
PFNGLVALIDATEPROGRAM glValidateProgram = nullptr;
PFNGLCLEARCOLOR glClearColor = nullptr;
PFNGLCLEARDEPTHF glClearDepthf = nullptr;
PFNGLCLEARSTENCIL glClearStencil = nullptr;
PFNGLCLEAR glClear = nullptr;
PFNGLCULLFACE glCullFace = nullptr;
PFNGLPOLYGONOFFSET glPolygonOffset = nullptr;
PFNGLLINEWIDTH glLineWidth = nullptr;
PFNGLSAMPLECOVERAGE glSampleCoverage = nullptr;
PFNGLHINT glHint = nullptr;
PFNGLFRAMEBUFFERRENDERBUFFER glFramebufferRenderbuffer = nullptr;
PFNGLFRAMEBUFFERTEXTURE2D glFramebufferTexture2D = nullptr;
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV glGetFramebufferAttachmentParameteriv = nullptr;
PFNGLDRAWELEMENTS glDrawElements = nullptr;
PFNGLDRAWARRAYS glDrawArrays = nullptr;
PFNGLFLUSH glFlush = nullptr;
PFNGLFINISH glFinish = nullptr;
PFNGLGETBOOLEANV glGetBooleanv = nullptr;
PFNGLGETFLOATV glGetFloatv = nullptr;
PFNGLGETINTEGERV glGetIntegerv = nullptr;
PFNGLGETSTRING glGetString = nullptr;
PFNGLENABLE glEnable = nullptr;
PFNGLDISABLE glDisable = nullptr;
PFNGLISENABLED glIsEnabled = nullptr;
PFNGLFENCESYNC glFenceSync = nullptr;
PFNGLDELETESYNC glDeleteSync = nullptr;
PFNGLWAITSYNC glWaitSync = nullptr;
PFNGLCLIENTWAITSYNC glClientWaitSync = nullptr;
PFNGLMAPBUFFERRANGE glMapBufferRange = nullptr;
PFNGLUNMAPBUFFER glUnmapBuffer = nullptr;
PFNGLINVALIDATEFRAMEBUFFER glInvalidateFramebuffer = nullptr;
PFNGLRENDERBUFFERSTORAGEMULTISAMPLE glRenderbufferStorageMultisample = nullptr;
PFNGLBLITFRAMEBUFFER glBlitFramebuffer = nullptr;
PFNGLGENQUERIES glGenQueries = nullptr;
PFNGLBEGINQUERY glBeginQuery = nullptr;
PFNGLENDQUERY glEndQuery = nullptr;
PFNGLDELETEQUERIES glDeleteQueries = nullptr;
PFNGLISQUERY glIsQuery = nullptr;
PFNGLGETQUERYIV glGetQueryiv = nullptr;
PFNGLGETQUERYOBJECTUIV glGetQueryObjectuiv = nullptr;
PFNGLGETACTIVEUNIFORMBLOCKNAME glGetActiveUniformBlockName = nullptr;
PFNGLGETACTIVEUNIFORMBLOCKIV glGetActiveUniformBlockiv = nullptr;
PFNGLUNIFORMBLOCKBINDING glUniformBlockBinding = nullptr;
PFNGLGETACTIVEUNIFORMSIV glGetActiveUniformsiv = nullptr;
PFNGLBINDBUFFERBASE glBindBufferBase = nullptr;
PFNGLGENVERTEXARRAYS glGenVertexArrays = nullptr;
PFNGLBINDVERTEXARRAY glBindVertexArray = nullptr;
PFNGLDELETEVERTEXARRAYS glDeleteVertexArrays = nullptr;
PFNGLGETQUERYOBJECTI64V glGetQueryObjecti64v = nullptr;
PFNGLGETQUERYOBJECTUI64V glGetQueryObjectui64v = nullptr;
PFNGLGENQUERIESEXT glGenQueriesEXT = nullptr;
PFNGLBEGINQUERYEXT glBeginQueryEXT = nullptr;
PFNGLENDQUERYEXT glEndQueryEXT = nullptr;
PFNGLDELETEQUERIESEXT glDeleteQueriesEXT = nullptr;
PFNGLISQUERYEXT glIsQueryEXT = nullptr;
PFNGLQUERYCOUNTEREXT glQueryCounterEXT = nullptr;
PFNGLGETQUERYIVEXT glGetQueryivEXT = nullptr;
PFNGLGETQUERYOBJECTIVEXT glGetQueryObjectivEXT = nullptr;
PFNGLGETQUERYOBJECTUIVEXT glGetQueryObjectuivEXT = nullptr;
PFNGLGETQUERYOBJECTI64VEXT glGetQueryObjecti64vEXT = nullptr;
PFNGLGETQUERYOBJECTUI64VEXT glGetQueryObjectui64vEXT = nullptr;
void Register(Interpreter* interpreter) {
interpreter->registerFunction(Ids::EglInitialize, callEglInitialize);
interpreter->registerFunction(Ids::EglCreateContext, callEglCreateContext);
interpreter->registerFunction(Ids::EglMakeCurrent, callEglMakeCurrent);
interpreter->registerFunction(Ids::EglSwapBuffers, callEglSwapBuffers);
interpreter->registerFunction(Ids::EglQuerySurface, callEglQuerySurface);
interpreter->registerFunction(Ids::GlXCreateContext, callGlXCreateContext);
interpreter->registerFunction(Ids::GlXCreateNewContext, callGlXCreateNewContext);
interpreter->registerFunction(Ids::GlXMakeContextCurrent, callGlXMakeContextCurrent);
interpreter->registerFunction(Ids::GlXMakeCurrent, callGlXMakeCurrent);
interpreter->registerFunction(Ids::GlXSwapBuffers, callGlXSwapBuffers);
interpreter->registerFunction(Ids::GlXQueryDrawable, callGlXQueryDrawable);
interpreter->registerFunction(Ids::WglCreateContext, callWglCreateContext);
interpreter->registerFunction(Ids::WglCreateContextAttribsARB, callWglCreateContextAttribsARB);
interpreter->registerFunction(Ids::WglMakeCurrent, callWglMakeCurrent);
interpreter->registerFunction(Ids::WglSwapBuffers, callWglSwapBuffers);
interpreter->registerFunction(Ids::CGLCreateContext, callCGLCreateContext);
interpreter->registerFunction(Ids::CGLSetCurrentContext, callCGLSetCurrentContext);
interpreter->registerFunction(Ids::CGLGetSurface, callCGLGetSurface);
interpreter->registerFunction(Ids::CGSGetSurfaceBounds, callCGSGetSurfaceBounds);
interpreter->registerFunction(Ids::CGLFlushDrawable, callCGLFlushDrawable);
interpreter->registerFunction(Ids::GlEnableClientState, callGlEnableClientState);
interpreter->registerFunction(Ids::GlDisableClientState, callGlDisableClientState);
interpreter->registerFunction(Ids::GlGetProgramBinaryOES, callGlGetProgramBinaryOES);
interpreter->registerFunction(Ids::GlProgramBinaryOES, callGlProgramBinaryOES);
interpreter->registerFunction(Ids::GlStartTilingQCOM, callGlStartTilingQCOM);
interpreter->registerFunction(Ids::GlEndTilingQCOM, callGlEndTilingQCOM);
interpreter->registerFunction(Ids::GlDiscardFramebufferEXT, callGlDiscardFramebufferEXT);
interpreter->registerFunction(Ids::GlInsertEventMarkerEXT, callGlInsertEventMarkerEXT);
interpreter->registerFunction(Ids::GlPushGroupMarkerEXT, callGlPushGroupMarkerEXT);
interpreter->registerFunction(Ids::GlPopGroupMarkerEXT, callGlPopGroupMarkerEXT);
interpreter->registerFunction(Ids::GlTexStorage1DEXT, callGlTexStorage1DEXT);
interpreter->registerFunction(Ids::GlTexStorage2DEXT, callGlTexStorage2DEXT);
interpreter->registerFunction(Ids::GlTexStorage3DEXT, callGlTexStorage3DEXT);
interpreter->registerFunction(Ids::GlTextureStorage1DEXT, callGlTextureStorage1DEXT);
interpreter->registerFunction(Ids::GlTextureStorage2DEXT, callGlTextureStorage2DEXT);
interpreter->registerFunction(Ids::GlTextureStorage3DEXT, callGlTextureStorage3DEXT);
interpreter->registerFunction(Ids::GlGenVertexArraysOES, callGlGenVertexArraysOES);
interpreter->registerFunction(Ids::GlBindVertexArrayOES, callGlBindVertexArrayOES);
interpreter->registerFunction(Ids::GlDeleteVertexArraysOES, callGlDeleteVertexArraysOES);
interpreter->registerFunction(Ids::GlIsVertexArrayOES, callGlIsVertexArrayOES);
interpreter->registerFunction(Ids::GlEGLImageTargetTexture2DOES,
callGlEGLImageTargetTexture2DOES);
interpreter->registerFunction(Ids::GlEGLImageTargetRenderbufferStorageOES,
callGlEGLImageTargetRenderbufferStorageOES);
interpreter->registerFunction(Ids::GlGetGraphicsResetStatusEXT,
callGlGetGraphicsResetStatusEXT);
interpreter->registerFunction(Ids::GlBindAttribLocation, callGlBindAttribLocation);
interpreter->registerFunction(Ids::GlBlendFunc, callGlBlendFunc);
interpreter->registerFunction(Ids::GlBlendFuncSeparate, callGlBlendFuncSeparate);
interpreter->registerFunction(Ids::GlBlendEquation, callGlBlendEquation);
interpreter->registerFunction(Ids::GlBlendEquationSeparate, callGlBlendEquationSeparate);
interpreter->registerFunction(Ids::GlBlendColor, callGlBlendColor);
interpreter->registerFunction(Ids::GlEnableVertexAttribArray, callGlEnableVertexAttribArray);
interpreter->registerFunction(Ids::GlDisableVertexAttribArray, callGlDisableVertexAttribArray);
interpreter->registerFunction(Ids::GlVertexAttribPointer, callGlVertexAttribPointer);
interpreter->registerFunction(Ids::GlGetActiveAttrib, callGlGetActiveAttrib);
interpreter->registerFunction(Ids::GlGetActiveUniform, callGlGetActiveUniform);
interpreter->registerFunction(Ids::GlGetError, callGlGetError);
interpreter->registerFunction(Ids::GlGetProgramiv, callGlGetProgramiv);
interpreter->registerFunction(Ids::GlGetShaderiv, callGlGetShaderiv);
interpreter->registerFunction(Ids::GlGetUniformLocation, callGlGetUniformLocation);
interpreter->registerFunction(Ids::GlGetAttribLocation, callGlGetAttribLocation);
interpreter->registerFunction(Ids::GlPixelStorei, callGlPixelStorei);
interpreter->registerFunction(Ids::GlTexParameteri, callGlTexParameteri);
interpreter->registerFunction(Ids::GlTexParameterf, callGlTexParameterf);
interpreter->registerFunction(Ids::GlGetTexParameteriv, callGlGetTexParameteriv);
interpreter->registerFunction(Ids::GlGetTexParameterfv, callGlGetTexParameterfv);
interpreter->registerFunction(Ids::GlUniform1i, callGlUniform1i);
interpreter->registerFunction(Ids::GlUniform2i, callGlUniform2i);
interpreter->registerFunction(Ids::GlUniform3i, callGlUniform3i);
interpreter->registerFunction(Ids::GlUniform4i, callGlUniform4i);
interpreter->registerFunction(Ids::GlUniform1iv, callGlUniform1iv);
interpreter->registerFunction(Ids::GlUniform2iv, callGlUniform2iv);
interpreter->registerFunction(Ids::GlUniform3iv, callGlUniform3iv);
interpreter->registerFunction(Ids::GlUniform4iv, callGlUniform4iv);
interpreter->registerFunction(Ids::GlUniform1f, callGlUniform1f);
interpreter->registerFunction(Ids::GlUniform2f, callGlUniform2f);
interpreter->registerFunction(Ids::GlUniform3f, callGlUniform3f);
interpreter->registerFunction(Ids::GlUniform4f, callGlUniform4f);
interpreter->registerFunction(Ids::GlUniform1fv, callGlUniform1fv);
interpreter->registerFunction(Ids::GlUniform2fv, callGlUniform2fv);
interpreter->registerFunction(Ids::GlUniform3fv, callGlUniform3fv);
interpreter->registerFunction(Ids::GlUniform4fv, callGlUniform4fv);
interpreter->registerFunction(Ids::GlUniformMatrix2fv, callGlUniformMatrix2fv);
interpreter->registerFunction(Ids::GlUniformMatrix3fv, callGlUniformMatrix3fv);
interpreter->registerFunction(Ids::GlUniformMatrix4fv, callGlUniformMatrix4fv);
interpreter->registerFunction(Ids::GlGetUniformfv, callGlGetUniformfv);
interpreter->registerFunction(Ids::GlGetUniformiv, callGlGetUniformiv);
interpreter->registerFunction(Ids::GlVertexAttrib1f, callGlVertexAttrib1f);
interpreter->registerFunction(Ids::GlVertexAttrib2f, callGlVertexAttrib2f);
interpreter->registerFunction(Ids::GlVertexAttrib3f, callGlVertexAttrib3f);
interpreter->registerFunction(Ids::GlVertexAttrib4f, callGlVertexAttrib4f);
interpreter->registerFunction(Ids::GlVertexAttrib1fv, callGlVertexAttrib1fv);
interpreter->registerFunction(Ids::GlVertexAttrib2fv, callGlVertexAttrib2fv);
interpreter->registerFunction(Ids::GlVertexAttrib3fv, callGlVertexAttrib3fv);
interpreter->registerFunction(Ids::GlVertexAttrib4fv, callGlVertexAttrib4fv);
interpreter->registerFunction(Ids::GlGetShaderPrecisionFormat, callGlGetShaderPrecisionFormat);
interpreter->registerFunction(Ids::GlDepthMask, callGlDepthMask);
interpreter->registerFunction(Ids::GlDepthFunc, callGlDepthFunc);
interpreter->registerFunction(Ids::GlDepthRangef, callGlDepthRangef);
interpreter->registerFunction(Ids::GlColorMask, callGlColorMask);
interpreter->registerFunction(Ids::GlStencilMask, callGlStencilMask);
interpreter->registerFunction(Ids::GlStencilMaskSeparate, callGlStencilMaskSeparate);
interpreter->registerFunction(Ids::GlStencilFuncSeparate, callGlStencilFuncSeparate);
interpreter->registerFunction(Ids::GlStencilOpSeparate, callGlStencilOpSeparate);
interpreter->registerFunction(Ids::GlFrontFace, callGlFrontFace);
interpreter->registerFunction(Ids::GlViewport, callGlViewport);
interpreter->registerFunction(Ids::GlScissor, callGlScissor);
interpreter->registerFunction(Ids::GlActiveTexture, callGlActiveTexture);
interpreter->registerFunction(Ids::GlGenTextures, callGlGenTextures);
interpreter->registerFunction(Ids::GlDeleteTextures, callGlDeleteTextures);
interpreter->registerFunction(Ids::GlIsTexture, callGlIsTexture);
interpreter->registerFunction(Ids::GlBindTexture, callGlBindTexture);
interpreter->registerFunction(Ids::GlTexImage2D, callGlTexImage2D);
interpreter->registerFunction(Ids::GlTexSubImage2D, callGlTexSubImage2D);
interpreter->registerFunction(Ids::GlCopyTexImage2D, callGlCopyTexImage2D);
interpreter->registerFunction(Ids::GlCopyTexSubImage2D, callGlCopyTexSubImage2D);
interpreter->registerFunction(Ids::GlCompressedTexImage2D, callGlCompressedTexImage2D);
interpreter->registerFunction(Ids::GlCompressedTexSubImage2D, callGlCompressedTexSubImage2D);
interpreter->registerFunction(Ids::GlGenerateMipmap, callGlGenerateMipmap);
interpreter->registerFunction(Ids::GlReadPixels, callGlReadPixels);
interpreter->registerFunction(Ids::GlGenFramebuffers, callGlGenFramebuffers);
interpreter->registerFunction(Ids::GlBindFramebuffer, callGlBindFramebuffer);
interpreter->registerFunction(Ids::GlCheckFramebufferStatus, callGlCheckFramebufferStatus);
interpreter->registerFunction(Ids::GlDeleteFramebuffers, callGlDeleteFramebuffers);
interpreter->registerFunction(Ids::GlIsFramebuffer, callGlIsFramebuffer);
interpreter->registerFunction(Ids::GlGenRenderbuffers, callGlGenRenderbuffers);
interpreter->registerFunction(Ids::GlBindRenderbuffer, callGlBindRenderbuffer);
interpreter->registerFunction(Ids::GlRenderbufferStorage, callGlRenderbufferStorage);
interpreter->registerFunction(Ids::GlDeleteRenderbuffers, callGlDeleteRenderbuffers);
interpreter->registerFunction(Ids::GlIsRenderbuffer, callGlIsRenderbuffer);
interpreter->registerFunction(Ids::GlGetRenderbufferParameteriv,
callGlGetRenderbufferParameteriv);
interpreter->registerFunction(Ids::GlGenBuffers, callGlGenBuffers);
interpreter->registerFunction(Ids::GlBindBuffer, callGlBindBuffer);
interpreter->registerFunction(Ids::GlBufferData, callGlBufferData);
interpreter->registerFunction(Ids::GlBufferSubData, callGlBufferSubData);
interpreter->registerFunction(Ids::GlDeleteBuffers, callGlDeleteBuffers);
interpreter->registerFunction(Ids::GlIsBuffer, callGlIsBuffer);
interpreter->registerFunction(Ids::GlGetBufferParameteriv, callGlGetBufferParameteriv);
interpreter->registerFunction(Ids::GlCreateShader, callGlCreateShader);
interpreter->registerFunction(Ids::GlDeleteShader, callGlDeleteShader);
interpreter->registerFunction(Ids::GlShaderSource, callGlShaderSource);
interpreter->registerFunction(Ids::GlShaderBinary, callGlShaderBinary);
interpreter->registerFunction(Ids::GlGetShaderInfoLog, callGlGetShaderInfoLog);
interpreter->registerFunction(Ids::GlGetShaderSource, callGlGetShaderSource);
interpreter->registerFunction(Ids::GlReleaseShaderCompiler, callGlReleaseShaderCompiler);
interpreter->registerFunction(Ids::GlCompileShader, callGlCompileShader);
interpreter->registerFunction(Ids::GlIsShader, callGlIsShader);
interpreter->registerFunction(Ids::GlCreateProgram, callGlCreateProgram);
interpreter->registerFunction(Ids::GlDeleteProgram, callGlDeleteProgram);
interpreter->registerFunction(Ids::GlAttachShader, callGlAttachShader);
interpreter->registerFunction(Ids::GlDetachShader, callGlDetachShader);
interpreter->registerFunction(Ids::GlGetAttachedShaders, callGlGetAttachedShaders);
interpreter->registerFunction(Ids::GlLinkProgram, callGlLinkProgram);
interpreter->registerFunction(Ids::GlGetProgramInfoLog, callGlGetProgramInfoLog);
interpreter->registerFunction(Ids::GlUseProgram, callGlUseProgram);
interpreter->registerFunction(Ids::GlIsProgram, callGlIsProgram);
interpreter->registerFunction(Ids::GlValidateProgram, callGlValidateProgram);
interpreter->registerFunction(Ids::GlClearColor, callGlClearColor);
interpreter->registerFunction(Ids::GlClearDepthf, callGlClearDepthf);
interpreter->registerFunction(Ids::GlClearStencil, callGlClearStencil);
interpreter->registerFunction(Ids::GlClear, callGlClear);
interpreter->registerFunction(Ids::GlCullFace, callGlCullFace);
interpreter->registerFunction(Ids::GlPolygonOffset, callGlPolygonOffset);
interpreter->registerFunction(Ids::GlLineWidth, callGlLineWidth);
interpreter->registerFunction(Ids::GlSampleCoverage, callGlSampleCoverage);
interpreter->registerFunction(Ids::GlHint, callGlHint);
interpreter->registerFunction(Ids::GlFramebufferRenderbuffer, callGlFramebufferRenderbuffer);
interpreter->registerFunction(Ids::GlFramebufferTexture2D, callGlFramebufferTexture2D);
interpreter->registerFunction(Ids::GlGetFramebufferAttachmentParameteriv,
callGlGetFramebufferAttachmentParameteriv);
interpreter->registerFunction(Ids::GlDrawElements, callGlDrawElements);
interpreter->registerFunction(Ids::GlDrawArrays, callGlDrawArrays);
interpreter->registerFunction(Ids::GlFlush, callGlFlush);
interpreter->registerFunction(Ids::GlFinish, callGlFinish);
interpreter->registerFunction(Ids::GlGetBooleanv, callGlGetBooleanv);
interpreter->registerFunction(Ids::GlGetFloatv, callGlGetFloatv);
interpreter->registerFunction(Ids::GlGetIntegerv, callGlGetIntegerv);
interpreter->registerFunction(Ids::GlGetString, callGlGetString);
interpreter->registerFunction(Ids::GlEnable, callGlEnable);
interpreter->registerFunction(Ids::GlDisable, callGlDisable);
interpreter->registerFunction(Ids::GlIsEnabled, callGlIsEnabled);
interpreter->registerFunction(Ids::GlFenceSync, callGlFenceSync);
interpreter->registerFunction(Ids::GlDeleteSync, callGlDeleteSync);
interpreter->registerFunction(Ids::GlWaitSync, callGlWaitSync);
interpreter->registerFunction(Ids::GlClientWaitSync, callGlClientWaitSync);
interpreter->registerFunction(Ids::GlMapBufferRange, callGlMapBufferRange);
interpreter->registerFunction(Ids::GlUnmapBuffer, callGlUnmapBuffer);
interpreter->registerFunction(Ids::GlInvalidateFramebuffer, callGlInvalidateFramebuffer);
interpreter->registerFunction(Ids::GlRenderbufferStorageMultisample,
callGlRenderbufferStorageMultisample);
interpreter->registerFunction(Ids::GlBlitFramebuffer, callGlBlitFramebuffer);
interpreter->registerFunction(Ids::GlGenQueries, callGlGenQueries);
interpreter->registerFunction(Ids::GlBeginQuery, callGlBeginQuery);
interpreter->registerFunction(Ids::GlEndQuery, callGlEndQuery);
interpreter->registerFunction(Ids::GlDeleteQueries, callGlDeleteQueries);
interpreter->registerFunction(Ids::GlIsQuery, callGlIsQuery);
interpreter->registerFunction(Ids::GlGetQueryiv, callGlGetQueryiv);
interpreter->registerFunction(Ids::GlGetQueryObjectuiv, callGlGetQueryObjectuiv);
interpreter->registerFunction(Ids::GlGetActiveUniformBlockName,
callGlGetActiveUniformBlockName);
interpreter->registerFunction(Ids::GlGetActiveUniformBlockiv, callGlGetActiveUniformBlockiv);
interpreter->registerFunction(Ids::GlUniformBlockBinding, callGlUniformBlockBinding);
interpreter->registerFunction(Ids::GlGetActiveUniformsiv, callGlGetActiveUniformsiv);
interpreter->registerFunction(Ids::GlBindBufferBase, callGlBindBufferBase);
interpreter->registerFunction(Ids::GlGenVertexArrays, callGlGenVertexArrays);
interpreter->registerFunction(Ids::GlBindVertexArray, callGlBindVertexArray);
interpreter->registerFunction(Ids::GlDeleteVertexArrays, callGlDeleteVertexArrays);
interpreter->registerFunction(Ids::GlGetQueryObjecti64v, callGlGetQueryObjecti64v);
interpreter->registerFunction(Ids::GlGetQueryObjectui64v, callGlGetQueryObjectui64v);
interpreter->registerFunction(Ids::GlGenQueriesEXT, callGlGenQueriesEXT);
interpreter->registerFunction(Ids::GlBeginQueryEXT, callGlBeginQueryEXT);
interpreter->registerFunction(Ids::GlEndQueryEXT, callGlEndQueryEXT);
interpreter->registerFunction(Ids::GlDeleteQueriesEXT, callGlDeleteQueriesEXT);
interpreter->registerFunction(Ids::GlIsQueryEXT, callGlIsQueryEXT);
interpreter->registerFunction(Ids::GlQueryCounterEXT, callGlQueryCounterEXT);
interpreter->registerFunction(Ids::GlGetQueryivEXT, callGlGetQueryivEXT);
interpreter->registerFunction(Ids::GlGetQueryObjectivEXT, callGlGetQueryObjectivEXT);
interpreter->registerFunction(Ids::GlGetQueryObjectuivEXT, callGlGetQueryObjectuivEXT);
interpreter->registerFunction(Ids::GlGetQueryObjecti64vEXT, callGlGetQueryObjecti64vEXT);
interpreter->registerFunction(Ids::GlGetQueryObjectui64vEXT, callGlGetQueryObjectui64vEXT);
}
void Initialize() {
eglInitialize =
reinterpret_cast<PFNEGLINITIALIZE>(gapic::GetGfxProcAddress("eglInitialize", false));
eglCreateContext = reinterpret_cast<PFNEGLCREATECONTEXT>(
gapic::GetGfxProcAddress("eglCreateContext", false));
eglMakeCurrent =
reinterpret_cast<PFNEGLMAKECURRENT>(gapic::GetGfxProcAddress("eglMakeCurrent", false));
eglSwapBuffers =
reinterpret_cast<PFNEGLSWAPBUFFERS>(gapic::GetGfxProcAddress("eglSwapBuffers", false));
eglQuerySurface = reinterpret_cast<PFNEGLQUERYSURFACE>(
gapic::GetGfxProcAddress("eglQuerySurface", false));
glXCreateContext = reinterpret_cast<PFNGLXCREATECONTEXT>(
gapic::GetGfxProcAddress("glXCreateContext", false));
glXCreateNewContext = reinterpret_cast<PFNGLXCREATENEWCONTEXT>(
gapic::GetGfxProcAddress("glXCreateNewContext", false));
glXMakeContextCurrent = reinterpret_cast<PFNGLXMAKECONTEXTCURRENT>(
gapic::GetGfxProcAddress("glXMakeContextCurrent", false));
glXMakeCurrent =
reinterpret_cast<PFNGLXMAKECURRENT>(gapic::GetGfxProcAddress("glXMakeCurrent", false));
glXSwapBuffers =
reinterpret_cast<PFNGLXSWAPBUFFERS>(gapic::GetGfxProcAddress("glXSwapBuffers", false));
glXQueryDrawable = reinterpret_cast<PFNGLXQUERYDRAWABLE>(
gapic::GetGfxProcAddress("glXQueryDrawable", false));
wglCreateContext = reinterpret_cast<PFNWGLCREATECONTEXT>(
gapic::GetGfxProcAddress("wglCreateContext", false));
wglCreateContextAttribsARB = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARB>(
gapic::GetGfxProcAddress("wglCreateContextAttribsARB", false));
wglMakeCurrent =
reinterpret_cast<PFNWGLMAKECURRENT>(gapic::GetGfxProcAddress("wglMakeCurrent", false));
wglSwapBuffers =
reinterpret_cast<PFNWGLSWAPBUFFERS>(gapic::GetGfxProcAddress("wglSwapBuffers", false));
CGLCreateContext = reinterpret_cast<PFNCGLCREATECONTEXT>(
gapic::GetGfxProcAddress("CGLCreateContext", false));
CGLSetCurrentContext = reinterpret_cast<PFNCGLSETCURRENTCONTEXT>(
gapic::GetGfxProcAddress("CGLSetCurrentContext", false));
CGLGetSurface =
reinterpret_cast<PFNCGLGETSURFACE>(gapic::GetGfxProcAddress("CGLGetSurface", false));
CGSGetSurfaceBounds = reinterpret_cast<PFNCGSGETSURFACEBOUNDS>(
gapic::GetGfxProcAddress("CGSGetSurfaceBounds", false));
CGLFlushDrawable = reinterpret_cast<PFNCGLFLUSHDRAWABLE>(
gapic::GetGfxProcAddress("CGLFlushDrawable", false));
glEnableClientState = reinterpret_cast<PFNGLENABLECLIENTSTATE>(
gapic::GetGfxProcAddress("glEnableClientState", false));
glDisableClientState = reinterpret_cast<PFNGLDISABLECLIENTSTATE>(
gapic::GetGfxProcAddress("glDisableClientState", false));
glGetProgramBinaryOES = reinterpret_cast<PFNGLGETPROGRAMBINARYOES>(
gapic::GetGfxProcAddress("glGetProgramBinaryOES", false));
glProgramBinaryOES = reinterpret_cast<PFNGLPROGRAMBINARYOES>(
gapic::GetGfxProcAddress("glProgramBinaryOES", false));
glStartTilingQCOM = reinterpret_cast<PFNGLSTARTTILINGQCOM>(
gapic::GetGfxProcAddress("glStartTilingQCOM", false));
glEndTilingQCOM = reinterpret_cast<PFNGLENDTILINGQCOM>(
gapic::GetGfxProcAddress("glEndTilingQCOM", false));
glDiscardFramebufferEXT = reinterpret_cast<PFNGLDISCARDFRAMEBUFFEREXT>(
gapic::GetGfxProcAddress("glDiscardFramebufferEXT", false));
glInsertEventMarkerEXT = reinterpret_cast<PFNGLINSERTEVENTMARKEREXT>(
gapic::GetGfxProcAddress("glInsertEventMarkerEXT", false));
glPushGroupMarkerEXT = reinterpret_cast<PFNGLPUSHGROUPMARKEREXT>(
gapic::GetGfxProcAddress("glPushGroupMarkerEXT", false));
glPopGroupMarkerEXT = reinterpret_cast<PFNGLPOPGROUPMARKEREXT>(
gapic::GetGfxProcAddress("glPopGroupMarkerEXT", false));
glTexStorage1DEXT = reinterpret_cast<PFNGLTEXSTORAGE1DEXT>(
gapic::GetGfxProcAddress("glTexStorage1DEXT", false));
glTexStorage2DEXT = reinterpret_cast<PFNGLTEXSTORAGE2DEXT>(
gapic::GetGfxProcAddress("glTexStorage2DEXT", false));
glTexStorage3DEXT = reinterpret_cast<PFNGLTEXSTORAGE3DEXT>(
gapic::GetGfxProcAddress("glTexStorage3DEXT", false));
glTextureStorage1DEXT = reinterpret_cast<PFNGLTEXTURESTORAGE1DEXT>(
gapic::GetGfxProcAddress("glTextureStorage1DEXT", false));
glTextureStorage2DEXT = reinterpret_cast<PFNGLTEXTURESTORAGE2DEXT>(
gapic::GetGfxProcAddress("glTextureStorage2DEXT", false));
glTextureStorage3DEXT = reinterpret_cast<PFNGLTEXTURESTORAGE3DEXT>(
gapic::GetGfxProcAddress("glTextureStorage3DEXT", false));
glGenVertexArraysOES = reinterpret_cast<PFNGLGENVERTEXARRAYSOES>(
gapic::GetGfxProcAddress("glGenVertexArraysOES", false));
glBindVertexArrayOES = reinterpret_cast<PFNGLBINDVERTEXARRAYOES>(
gapic::GetGfxProcAddress("glBindVertexArrayOES", false));
glDeleteVertexArraysOES = reinterpret_cast<PFNGLDELETEVERTEXARRAYSOES>(
gapic::GetGfxProcAddress("glDeleteVertexArraysOES", false));
glIsVertexArrayOES = reinterpret_cast<PFNGLISVERTEXARRAYOES>(
gapic::GetGfxProcAddress("glIsVertexArrayOES", false));
glEGLImageTargetTexture2DOES = reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOES>(
gapic::GetGfxProcAddress("glEGLImageTargetTexture2DOES", false));
glEGLImageTargetRenderbufferStorageOES =
reinterpret_cast<PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOES>(
gapic::GetGfxProcAddress("glEGLImageTargetRenderbufferStorageOES", false));
glGetGraphicsResetStatusEXT = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSEXT>(
gapic::GetGfxProcAddress("glGetGraphicsResetStatusEXT", false));
glBindAttribLocation = reinterpret_cast<PFNGLBINDATTRIBLOCATION>(
gapic::GetGfxProcAddress("glBindAttribLocation", false));
glBlendFunc = reinterpret_cast<PFNGLBLENDFUNC>(gapic::GetGfxProcAddress("glBlendFunc", false));
glBlendFuncSeparate = reinterpret_cast<PFNGLBLENDFUNCSEPARATE>(
gapic::GetGfxProcAddress("glBlendFuncSeparate", false));
glBlendEquation = reinterpret_cast<PFNGLBLENDEQUATION>(
gapic::GetGfxProcAddress("glBlendEquation", false));
glBlendEquationSeparate = reinterpret_cast<PFNGLBLENDEQUATIONSEPARATE>(
gapic::GetGfxProcAddress("glBlendEquationSeparate", false));
glBlendColor =
reinterpret_cast<PFNGLBLENDCOLOR>(gapic::GetGfxProcAddress("glBlendColor", false));
glEnableVertexAttribArray = reinterpret_cast<PFNGLENABLEVERTEXATTRIBARRAY>(
gapic::GetGfxProcAddress("glEnableVertexAttribArray", false));
glDisableVertexAttribArray = reinterpret_cast<PFNGLDISABLEVERTEXATTRIBARRAY>(
gapic::GetGfxProcAddress("glDisableVertexAttribArray", false));
glVertexAttribPointer = reinterpret_cast<PFNGLVERTEXATTRIBPOINTER>(
gapic::GetGfxProcAddress("glVertexAttribPointer", false));
glGetActiveAttrib = reinterpret_cast<PFNGLGETACTIVEATTRIB>(
gapic::GetGfxProcAddress("glGetActiveAttrib", false));
glGetActiveUniform = reinterpret_cast<PFNGLGETACTIVEUNIFORM>(
gapic::GetGfxProcAddress("glGetActiveUniform", false));
glGetError = reinterpret_cast<PFNGLGETERROR>(gapic::GetGfxProcAddress("glGetError", false));
glGetProgramiv =
reinterpret_cast<PFNGLGETPROGRAMIV>(gapic::GetGfxProcAddress("glGetProgramiv", false));
glGetShaderiv =
reinterpret_cast<PFNGLGETSHADERIV>(gapic::GetGfxProcAddress("glGetShaderiv", false));
glGetUniformLocation = reinterpret_cast<PFNGLGETUNIFORMLOCATION>(
gapic::GetGfxProcAddress("glGetUniformLocation", false));
glGetAttribLocation = reinterpret_cast<PFNGLGETATTRIBLOCATION>(
gapic::GetGfxProcAddress("glGetAttribLocation", false));
glPixelStorei =
reinterpret_cast<PFNGLPIXELSTOREI>(gapic::GetGfxProcAddress("glPixelStorei", false));
glTexParameteri = reinterpret_cast<PFNGLTEXPARAMETERI>(
gapic::GetGfxProcAddress("glTexParameteri", false));
glTexParameterf = reinterpret_cast<PFNGLTEXPARAMETERF>(
gapic::GetGfxProcAddress("glTexParameterf", false));
glGetTexParameteriv = reinterpret_cast<PFNGLGETTEXPARAMETERIV>(
gapic::GetGfxProcAddress("glGetTexParameteriv", false));
glGetTexParameterfv = reinterpret_cast<PFNGLGETTEXPARAMETERFV>(
gapic::GetGfxProcAddress("glGetTexParameterfv", false));
glUniform1i = reinterpret_cast<PFNGLUNIFORM1I>(gapic::GetGfxProcAddress("glUniform1i", false));
glUniform2i = reinterpret_cast<PFNGLUNIFORM2I>(gapic::GetGfxProcAddress("glUniform2i", false));
glUniform3i = reinterpret_cast<PFNGLUNIFORM3I>(gapic::GetGfxProcAddress("glUniform3i", false));
glUniform4i = reinterpret_cast<PFNGLUNIFORM4I>(gapic::GetGfxProcAddress("glUniform4i", false));
glUniform1iv =
reinterpret_cast<PFNGLUNIFORM1IV>(gapic::GetGfxProcAddress("glUniform1iv", false));
glUniform2iv =
reinterpret_cast<PFNGLUNIFORM2IV>(gapic::GetGfxProcAddress("glUniform2iv", false));
glUniform3iv =
reinterpret_cast<PFNGLUNIFORM3IV>(gapic::GetGfxProcAddress("glUniform3iv", false));
glUniform4iv =
reinterpret_cast<PFNGLUNIFORM4IV>(gapic::GetGfxProcAddress("glUniform4iv", false));
glUniform1f = reinterpret_cast<PFNGLUNIFORM1F>(gapic::GetGfxProcAddress("glUniform1f", false));
glUniform2f = reinterpret_cast<PFNGLUNIFORM2F>(gapic::GetGfxProcAddress("glUniform2f", false));
glUniform3f = reinterpret_cast<PFNGLUNIFORM3F>(gapic::GetGfxProcAddress("glUniform3f", false));
glUniform4f = reinterpret_cast<PFNGLUNIFORM4F>(gapic::GetGfxProcAddress("glUniform4f", false));
glUniform1fv =
reinterpret_cast<PFNGLUNIFORM1FV>(gapic::GetGfxProcAddress("glUniform1fv", false));
glUniform2fv =
reinterpret_cast<PFNGLUNIFORM2FV>(gapic::GetGfxProcAddress("glUniform2fv", false));
glUniform3fv =
reinterpret_cast<PFNGLUNIFORM3FV>(gapic::GetGfxProcAddress("glUniform3fv", false));
glUniform4fv =
reinterpret_cast<PFNGLUNIFORM4FV>(gapic::GetGfxProcAddress("glUniform4fv", false));
glUniformMatrix2fv = reinterpret_cast<PFNGLUNIFORMMATRIX2FV>(
gapic::GetGfxProcAddress("glUniformMatrix2fv", false));
glUniformMatrix3fv = reinterpret_cast<PFNGLUNIFORMMATRIX3FV>(
gapic::GetGfxProcAddress("glUniformMatrix3fv", false));
glUniformMatrix4fv = reinterpret_cast<PFNGLUNIFORMMATRIX4FV>(
gapic::GetGfxProcAddress("glUniformMatrix4fv", false));
glGetUniformfv =
reinterpret_cast<PFNGLGETUNIFORMFV>(gapic::GetGfxProcAddress("glGetUniformfv", false));
glGetUniformiv =
reinterpret_cast<PFNGLGETUNIFORMIV>(gapic::GetGfxProcAddress("glGetUniformiv", false));
glVertexAttrib1f = reinterpret_cast<PFNGLVERTEXATTRIB1F>(
gapic::GetGfxProcAddress("glVertexAttrib1f", false));
glVertexAttrib2f = reinterpret_cast<PFNGLVERTEXATTRIB2F>(
gapic::GetGfxProcAddress("glVertexAttrib2f", false));
glVertexAttrib3f = reinterpret_cast<PFNGLVERTEXATTRIB3F>(
gapic::GetGfxProcAddress("glVertexAttrib3f", false));
glVertexAttrib4f = reinterpret_cast<PFNGLVERTEXATTRIB4F>(
gapic::GetGfxProcAddress("glVertexAttrib4f", false));
glVertexAttrib1fv = reinterpret_cast<PFNGLVERTEXATTRIB1FV>(
gapic::GetGfxProcAddress("glVertexAttrib1fv", false));
glVertexAttrib2fv = reinterpret_cast<PFNGLVERTEXATTRIB2FV>(
gapic::GetGfxProcAddress("glVertexAttrib2fv", false));
glVertexAttrib3fv = reinterpret_cast<PFNGLVERTEXATTRIB3FV>(
gapic::GetGfxProcAddress("glVertexAttrib3fv", false));
glVertexAttrib4fv = reinterpret_cast<PFNGLVERTEXATTRIB4FV>(
gapic::GetGfxProcAddress("glVertexAttrib4fv", false));
glGetShaderPrecisionFormat = reinterpret_cast<PFNGLGETSHADERPRECISIONFORMAT>(
gapic::GetGfxProcAddress("glGetShaderPrecisionFormat", false));
glDepthMask = reinterpret_cast<PFNGLDEPTHMASK>(gapic::GetGfxProcAddress("glDepthMask", false));
glDepthFunc = reinterpret_cast<PFNGLDEPTHFUNC>(gapic::GetGfxProcAddress("glDepthFunc", false));
glDepthRangef =
reinterpret_cast<PFNGLDEPTHRANGEF>(gapic::GetGfxProcAddress("glDepthRangef", false));
glColorMask = reinterpret_cast<PFNGLCOLORMASK>(gapic::GetGfxProcAddress("glColorMask", false));
glStencilMask =
reinterpret_cast<PFNGLSTENCILMASK>(gapic::GetGfxProcAddress("glStencilMask", false));
glStencilMaskSeparate = reinterpret_cast<PFNGLSTENCILMASKSEPARATE>(
gapic::GetGfxProcAddress("glStencilMaskSeparate", false));
glStencilFuncSeparate = reinterpret_cast<PFNGLSTENCILFUNCSEPARATE>(
gapic::GetGfxProcAddress("glStencilFuncSeparate", false));
glStencilOpSeparate = reinterpret_cast<PFNGLSTENCILOPSEPARATE>(
gapic::GetGfxProcAddress("glStencilOpSeparate", false));
glFrontFace = reinterpret_cast<PFNGLFRONTFACE>(gapic::GetGfxProcAddress("glFrontFace", false));
glViewport = reinterpret_cast<PFNGLVIEWPORT>(gapic::GetGfxProcAddress("glViewport", false));
glScissor = reinterpret_cast<PFNGLSCISSOR>(gapic::GetGfxProcAddress("glScissor", false));
glActiveTexture = reinterpret_cast<PFNGLACTIVETEXTURE>(
gapic::GetGfxProcAddress("glActiveTexture", false));
glGenTextures =
reinterpret_cast<PFNGLGENTEXTURES>(gapic::GetGfxProcAddress("glGenTextures", false));
glDeleteTextures = reinterpret_cast<PFNGLDELETETEXTURES>(
gapic::GetGfxProcAddress("glDeleteTextures", false));
glIsTexture = reinterpret_cast<PFNGLISTEXTURE>(gapic::GetGfxProcAddress("glIsTexture", false));
glBindTexture =
reinterpret_cast<PFNGLBINDTEXTURE>(gapic::GetGfxProcAddress("glBindTexture", false));
glTexImage2D =
reinterpret_cast<PFNGLTEXIMAGE2D>(gapic::GetGfxProcAddress("glTexImage2D", false));
glTexSubImage2D = reinterpret_cast<PFNGLTEXSUBIMAGE2D>(
gapic::GetGfxProcAddress("glTexSubImage2D", false));
glCopyTexImage2D = reinterpret_cast<PFNGLCOPYTEXIMAGE2D>(
gapic::GetGfxProcAddress("glCopyTexImage2D", false));
glCopyTexSubImage2D = reinterpret_cast<PFNGLCOPYTEXSUBIMAGE2D>(
gapic::GetGfxProcAddress("glCopyTexSubImage2D", false));
glCompressedTexImage2D = reinterpret_cast<PFNGLCOMPRESSEDTEXIMAGE2D>(
gapic::GetGfxProcAddress("glCompressedTexImage2D", false));
glCompressedTexSubImage2D = reinterpret_cast<PFNGLCOMPRESSEDTEXSUBIMAGE2D>(
gapic::GetGfxProcAddress("glCompressedTexSubImage2D", false));
glGenerateMipmap = reinterpret_cast<PFNGLGENERATEMIPMAP>(
gapic::GetGfxProcAddress("glGenerateMipmap", false));
glReadPixels =
reinterpret_cast<PFNGLREADPIXELS>(gapic::GetGfxProcAddress("glReadPixels", false));
glGenFramebuffers = reinterpret_cast<PFNGLGENFRAMEBUFFERS>(
gapic::GetGfxProcAddress("glGenFramebuffers", false));
glBindFramebuffer = reinterpret_cast<PFNGLBINDFRAMEBUFFER>(
gapic::GetGfxProcAddress("glBindFramebuffer", false));
glCheckFramebufferStatus = reinterpret_cast<PFNGLCHECKFRAMEBUFFERSTATUS>(
gapic::GetGfxProcAddress("glCheckFramebufferStatus", false));
glDeleteFramebuffers = reinterpret_cast<PFNGLDELETEFRAMEBUFFERS>(
gapic::GetGfxProcAddress("glDeleteFramebuffers", false));
glIsFramebuffer = reinterpret_cast<PFNGLISFRAMEBUFFER>(
gapic::GetGfxProcAddress("glIsFramebuffer", false));
glGenRenderbuffers = reinterpret_cast<PFNGLGENRENDERBUFFERS>(
gapic::GetGfxProcAddress("glGenRenderbuffers", false));
glBindRenderbuffer = reinterpret_cast<PFNGLBINDRENDERBUFFER>(
gapic::GetGfxProcAddress("glBindRenderbuffer", false));
glRenderbufferStorage = reinterpret_cast<PFNGLRENDERBUFFERSTORAGE>(
gapic::GetGfxProcAddress("glRenderbufferStorage", false));
glDeleteRenderbuffers = reinterpret_cast<PFNGLDELETERENDERBUFFERS>(
gapic::GetGfxProcAddress("glDeleteRenderbuffers", false));
glIsRenderbuffer = reinterpret_cast<PFNGLISRENDERBUFFER>(
gapic::GetGfxProcAddress("glIsRenderbuffer", false));
glGetRenderbufferParameteriv = reinterpret_cast<PFNGLGETRENDERBUFFERPARAMETERIV>(
gapic::GetGfxProcAddress("glGetRenderbufferParameteriv", false));
glGenBuffers =
reinterpret_cast<PFNGLGENBUFFERS>(gapic::GetGfxProcAddress("glGenBuffers", false));
glBindBuffer =
reinterpret_cast<PFNGLBINDBUFFER>(gapic::GetGfxProcAddress("glBindBuffer", false));
glBufferData =
reinterpret_cast<PFNGLBUFFERDATA>(gapic::GetGfxProcAddress("glBufferData", false));
glBufferSubData = reinterpret_cast<PFNGLBUFFERSUBDATA>(
gapic::GetGfxProcAddress("glBufferSubData", false));
glDeleteBuffers = reinterpret_cast<PFNGLDELETEBUFFERS>(
gapic::GetGfxProcAddress("glDeleteBuffers", false));
glIsBuffer = reinterpret_cast<PFNGLISBUFFER>(gapic::GetGfxProcAddress("glIsBuffer", false));
glGetBufferParameteriv = reinterpret_cast<PFNGLGETBUFFERPARAMETERIV>(
gapic::GetGfxProcAddress("glGetBufferParameteriv", false));
glCreateShader =
reinterpret_cast<PFNGLCREATESHADER>(gapic::GetGfxProcAddress("glCreateShader", false));
glDeleteShader =
reinterpret_cast<PFNGLDELETESHADER>(gapic::GetGfxProcAddress("glDeleteShader", false));
glShaderSource =
reinterpret_cast<PFNGLSHADERSOURCE>(gapic::GetGfxProcAddress("glShaderSource", false));
glShaderBinary =
reinterpret_cast<PFNGLSHADERBINARY>(gapic::GetGfxProcAddress("glShaderBinary", false));
glGetShaderInfoLog = reinterpret_cast<PFNGLGETSHADERINFOLOG>(
gapic::GetGfxProcAddress("glGetShaderInfoLog", false));
glGetShaderSource = reinterpret_cast<PFNGLGETSHADERSOURCE>(
gapic::GetGfxProcAddress("glGetShaderSource", false));
glReleaseShaderCompiler = reinterpret_cast<PFNGLRELEASESHADERCOMPILER>(
gapic::GetGfxProcAddress("glReleaseShaderCompiler", false));
glCompileShader = reinterpret_cast<PFNGLCOMPILESHADER>(
gapic::GetGfxProcAddress("glCompileShader", false));
glIsShader = reinterpret_cast<PFNGLISSHADER>(gapic::GetGfxProcAddress("glIsShader", false));
glCreateProgram = reinterpret_cast<PFNGLCREATEPROGRAM>(
gapic::GetGfxProcAddress("glCreateProgram", false));
glDeleteProgram = reinterpret_cast<PFNGLDELETEPROGRAM>(
gapic::GetGfxProcAddress("glDeleteProgram", false));
glAttachShader =
reinterpret_cast<PFNGLATTACHSHADER>(gapic::GetGfxProcAddress("glAttachShader", false));
glDetachShader =
reinterpret_cast<PFNGLDETACHSHADER>(gapic::GetGfxProcAddress("glDetachShader", false));
glGetAttachedShaders = reinterpret_cast<PFNGLGETATTACHEDSHADERS>(
gapic::GetGfxProcAddress("glGetAttachedShaders", false));
glLinkProgram =
reinterpret_cast<PFNGLLINKPROGRAM>(gapic::GetGfxProcAddress("glLinkProgram", false));
glGetProgramInfoLog = reinterpret_cast<PFNGLGETPROGRAMINFOLOG>(
gapic::GetGfxProcAddress("glGetProgramInfoLog", false));
glUseProgram =
reinterpret_cast<PFNGLUSEPROGRAM>(gapic::GetGfxProcAddress("glUseProgram", false));
glIsProgram = reinterpret_cast<PFNGLISPROGRAM>(gapic::GetGfxProcAddress("glIsProgram", false));
glValidateProgram = reinterpret_cast<PFNGLVALIDATEPROGRAM>(
gapic::GetGfxProcAddress("glValidateProgram", false));
glClearColor =
reinterpret_cast<PFNGLCLEARCOLOR>(gapic::GetGfxProcAddress("glClearColor", false));
glClearDepthf =
reinterpret_cast<PFNGLCLEARDEPTHF>(gapic::GetGfxProcAddress("glClearDepthf", false));
glClearStencil =
reinterpret_cast<PFNGLCLEARSTENCIL>(gapic::GetGfxProcAddress("glClearStencil", false));
glClear = reinterpret_cast<PFNGLCLEAR>(gapic::GetGfxProcAddress("glClear", false));
glCullFace = reinterpret_cast<PFNGLCULLFACE>(gapic::GetGfxProcAddress("glCullFace", false));
glPolygonOffset = reinterpret_cast<PFNGLPOLYGONOFFSET>(
gapic::GetGfxProcAddress("glPolygonOffset", false));
glLineWidth = reinterpret_cast<PFNGLLINEWIDTH>(gapic::GetGfxProcAddress("glLineWidth", false));
glSampleCoverage = reinterpret_cast<PFNGLSAMPLECOVERAGE>(
gapic::GetGfxProcAddress("glSampleCoverage", false));
glHint = reinterpret_cast<PFNGLHINT>(gapic::GetGfxProcAddress("glHint", false));
glFramebufferRenderbuffer = reinterpret_cast<PFNGLFRAMEBUFFERRENDERBUFFER>(
gapic::GetGfxProcAddress("glFramebufferRenderbuffer", false));
glFramebufferTexture2D = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2D>(
gapic::GetGfxProcAddress("glFramebufferTexture2D", false));
glGetFramebufferAttachmentParameteriv =
reinterpret_cast<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV>(
gapic::GetGfxProcAddress("glGetFramebufferAttachmentParameteriv", false));
glDrawElements =
reinterpret_cast<PFNGLDRAWELEMENTS>(gapic::GetGfxProcAddress("glDrawElements", false));
glDrawArrays =
reinterpret_cast<PFNGLDRAWARRAYS>(gapic::GetGfxProcAddress("glDrawArrays", false));
glFlush = reinterpret_cast<PFNGLFLUSH>(gapic::GetGfxProcAddress("glFlush", false));
glFinish = reinterpret_cast<PFNGLFINISH>(gapic::GetGfxProcAddress("glFinish", false));
glGetBooleanv =
reinterpret_cast<PFNGLGETBOOLEANV>(gapic::GetGfxProcAddress("glGetBooleanv", false));
glGetFloatv = reinterpret_cast<PFNGLGETFLOATV>(gapic::GetGfxProcAddress("glGetFloatv", false));
glGetIntegerv =
reinterpret_cast<PFNGLGETINTEGERV>(gapic::GetGfxProcAddress("glGetIntegerv", false));
glGetString = reinterpret_cast<PFNGLGETSTRING>(gapic::GetGfxProcAddress("glGetString", false));
glEnable = reinterpret_cast<PFNGLENABLE>(gapic::GetGfxProcAddress("glEnable", false));
glDisable = reinterpret_cast<PFNGLDISABLE>(gapic::GetGfxProcAddress("glDisable", false));
glIsEnabled = reinterpret_cast<PFNGLISENABLED>(gapic::GetGfxProcAddress("glIsEnabled", false));
glFenceSync = reinterpret_cast<PFNGLFENCESYNC>(gapic::GetGfxProcAddress("glFenceSync", false));
glDeleteSync =
reinterpret_cast<PFNGLDELETESYNC>(gapic::GetGfxProcAddress("glDeleteSync", false));
glWaitSync = reinterpret_cast<PFNGLWAITSYNC>(gapic::GetGfxProcAddress("glWaitSync", false));
glClientWaitSync = reinterpret_cast<PFNGLCLIENTWAITSYNC>(
gapic::GetGfxProcAddress("glClientWaitSync", false));
glMapBufferRange = reinterpret_cast<PFNGLMAPBUFFERRANGE>(
gapic::GetGfxProcAddress("glMapBufferRange", false));
glUnmapBuffer =
reinterpret_cast<PFNGLUNMAPBUFFER>(gapic::GetGfxProcAddress("glUnmapBuffer", false));
glInvalidateFramebuffer = reinterpret_cast<PFNGLINVALIDATEFRAMEBUFFER>(
gapic::GetGfxProcAddress("glInvalidateFramebuffer", false));
glRenderbufferStorageMultisample = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLE>(
gapic::GetGfxProcAddress("glRenderbufferStorageMultisample", false));
glBlitFramebuffer = reinterpret_cast<PFNGLBLITFRAMEBUFFER>(
gapic::GetGfxProcAddress("glBlitFramebuffer", false));
glGenQueries =
reinterpret_cast<PFNGLGENQUERIES>(gapic::GetGfxProcAddress("glGenQueries", false));
glBeginQuery =
reinterpret_cast<PFNGLBEGINQUERY>(gapic::GetGfxProcAddress("glBeginQuery", false));
glEndQuery = reinterpret_cast<PFNGLENDQUERY>(gapic::GetGfxProcAddress("glEndQuery", false));
glDeleteQueries = reinterpret_cast<PFNGLDELETEQUERIES>(
gapic::GetGfxProcAddress("glDeleteQueries", false));
glIsQuery = reinterpret_cast<PFNGLISQUERY>(gapic::GetGfxProcAddress("glIsQuery", false));
glGetQueryiv =
reinterpret_cast<PFNGLGETQUERYIV>(gapic::GetGfxProcAddress("glGetQueryiv", false));
glGetQueryObjectuiv = reinterpret_cast<PFNGLGETQUERYOBJECTUIV>(
gapic::GetGfxProcAddress("glGetQueryObjectuiv", false));
glGetActiveUniformBlockName = reinterpret_cast<PFNGLGETACTIVEUNIFORMBLOCKNAME>(
gapic::GetGfxProcAddress("glGetActiveUniformBlockName", false));
glGetActiveUniformBlockiv = reinterpret_cast<PFNGLGETACTIVEUNIFORMBLOCKIV>(
gapic::GetGfxProcAddress("glGetActiveUniformBlockiv", false));
glUniformBlockBinding = reinterpret_cast<PFNGLUNIFORMBLOCKBINDING>(
gapic::GetGfxProcAddress("glUniformBlockBinding", false));
glGetActiveUniformsiv = reinterpret_cast<PFNGLGETACTIVEUNIFORMSIV>(
gapic::GetGfxProcAddress("glGetActiveUniformsiv", false));
glBindBufferBase = reinterpret_cast<PFNGLBINDBUFFERBASE>(
gapic::GetGfxProcAddress("glBindBufferBase", false));
glGenVertexArrays = reinterpret_cast<PFNGLGENVERTEXARRAYS>(
gapic::GetGfxProcAddress("glGenVertexArrays", false));
glBindVertexArray = reinterpret_cast<PFNGLBINDVERTEXARRAY>(
gapic::GetGfxProcAddress("glBindVertexArray", false));
glDeleteVertexArrays = reinterpret_cast<PFNGLDELETEVERTEXARRAYS>(
gapic::GetGfxProcAddress("glDeleteVertexArrays", false));
glGetQueryObjecti64v = reinterpret_cast<PFNGLGETQUERYOBJECTI64V>(
gapic::GetGfxProcAddress("glGetQueryObjecti64v", false));
glGetQueryObjectui64v = reinterpret_cast<PFNGLGETQUERYOBJECTUI64V>(
gapic::GetGfxProcAddress("glGetQueryObjectui64v", false));
glGenQueriesEXT = reinterpret_cast<PFNGLGENQUERIESEXT>(
gapic::GetGfxProcAddress("glGenQueriesEXT", false));
glBeginQueryEXT = reinterpret_cast<PFNGLBEGINQUERYEXT>(
gapic::GetGfxProcAddress("glBeginQueryEXT", false));
glEndQueryEXT =
reinterpret_cast<PFNGLENDQUERYEXT>(gapic::GetGfxProcAddress("glEndQueryEXT", false));
glDeleteQueriesEXT = reinterpret_cast<PFNGLDELETEQUERIESEXT>(
gapic::GetGfxProcAddress("glDeleteQueriesEXT", false));
glIsQueryEXT =
reinterpret_cast<PFNGLISQUERYEXT>(gapic::GetGfxProcAddress("glIsQueryEXT", false));
glQueryCounterEXT = reinterpret_cast<PFNGLQUERYCOUNTEREXT>(
gapic::GetGfxProcAddress("glQueryCounterEXT", false));
glGetQueryivEXT = reinterpret_cast<PFNGLGETQUERYIVEXT>(
gapic::GetGfxProcAddress("glGetQueryivEXT", false));
glGetQueryObjectivEXT = reinterpret_cast<PFNGLGETQUERYOBJECTIVEXT>(
gapic::GetGfxProcAddress("glGetQueryObjectivEXT", false));
glGetQueryObjectuivEXT = reinterpret_cast<PFNGLGETQUERYOBJECTUIVEXT>(
gapic::GetGfxProcAddress("glGetQueryObjectuivEXT", false));
glGetQueryObjecti64vEXT = reinterpret_cast<PFNGLGETQUERYOBJECTI64VEXT>(
gapic::GetGfxProcAddress("glGetQueryObjecti64vEXT", false));
glGetQueryObjectui64vEXT = reinterpret_cast<PFNGLGETQUERYOBJECTUI64VEXT>(
gapic::GetGfxProcAddress("glGetQueryObjectui64vEXT", false));
}
} // namespace gfxapi
} // namespace gapir