TheCloud/MobileGlues
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGlues.git synced 2025-09-22 02:32:29 -04:00
Code Issues Packages Projects Releases Wiki Activity

[Misc] (...): More funcs, exts for fpe.

Browse Source
This commit is contained in:
BZLZHH 2025-04-19 14:17:24 +08:00
parent 8604925410
commit 9a879d228a
12 changed files with 683 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/main/cpp/gl/buffer.cpp
View File

@ -572,14 +572,6 @@ void* glMapBuffer(GLenum target, GLenum access) {
#define BIN_FILE_PREFIX "/sdcard/MG/buf/"
#endif
extern "C" {
GLAPI GLAPIENTRY void *glMapBufferARB(GLenum target, GLenum access) __attribute__((alias("glMapBuffer")));
GLAPI GLAPIENTRY void *glBufferDataARB(GLenum target, GLenum access) __attribute__((alias("glBufferData")));
GLAPI GLAPIENTRY GLboolean glUnmapBufferARB(GLenum target) __attribute__((alias("glUnmapBuffer")));
GLAPI GLAPIENTRY void glBufferStorageARB(GLenum target, GLsizeiptr size, const void* data, GLbitfield flags) __attribute__((alias("glBufferStorage")));
GLAPI GLAPIENTRY void glBindBufferARB(GLenum target, GLuint buffer) __attribute__((alias("glBindBuffer")));
}
GLboolean glUnmapBuffer(GLenum target) {
LOG()
GET_GL4ES_FUNC(GLboolean, glUnmapBuffer, GLenum target)
@ -740,3 +732,19 @@ void glBindVertexArray(GLuint array) {
GLES.glBindVertexArray(real_array);
CHECK_GL_ERROR
}
extern "C" {
GLAPI GLAPIENTRY void *glMapBufferARB(GLenum target, GLenum access) __attribute__((alias("glMapBuffer")));
GLAPI GLAPIENTRY void *glBufferDataARB(GLenum target, GLenum access) __attribute__((alias("glBufferData")));
GLAPI GLAPIENTRY GLboolean glUnmapBufferARB(GLenum target) __attribute__((alias("glUnmapBuffer")));
GLAPI GLAPIENTRY void glBufferStorageARB(GLenum target, GLsizeiptr size, const void* data, GLbitfield flags) __attribute__((alias("glBufferStorage")));
GLAPI GLAPIENTRY void glBindBufferARB(GLenum target, GLuint buffer) __attribute__((alias("glBindBuffer")));
GLAPI GLAPIENTRY void glBindBufferRangeARB(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) __attribute__((alias("glBindBufferRange")));
GLAPI GLAPIENTRY void glBindBufferBaseARB(GLenum target, GLuint index, GLuint buffer) __attribute__((alias("glBindBufferBase")));
GLAPI GLAPIENTRY void glDeleteBuffersARB(GLsizei n, const GLuint *buffers) __attribute__((alias("glDeleteBuffers")));
GLAPI GLAPIENTRY void glGenBuffersARB(GLsizei n, GLuint *buffers) __attribute__((alias("glGenBuffers")));
GLAPI GLAPIENTRY GLboolean glIsBufferARB(GLuint buffer) __attribute__((alias("glIsBuffer")));
}

12
src/main/cpp/gl/drawing.cpp
View File

@ -332,12 +332,12 @@ void glMultiDrawElementsBaseVertex(GLenum mode, GLsizei* counts, GLenum type, co
CHECK_GL_ERROR
}
void glMultiDrawArrays(GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) {
for (GLsizei i = 0; i < drawcount; ++i) {
GLES.glDrawArrays(mode, first[i], count[i]);
}
CHECK_GL_ERROR
}
//void glMultiDrawArrays(GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) {
// for (GLsizei i = 0; i < drawcount; ++i) {
// GLES.glDrawArrays(mode, first[i], count[i]);
// }
// CHECK_GL_ERROR
//}
void glDrawArrays(GLenum mode, GLint first, GLsizei count) {
LOG()

4
src/main/cpp/gl/framebuffer.cpp
View File

@ -347,5 +347,9 @@ EXPORT void glFramebufferTexture3DARB(GLenum target, GLenum attachment,
GLint level, GLint layer) {
//glFramebufferTexture3D(target, attachment, textarget, texture, level, layer);
}
EXPORT void glDrawBuffersARB(GLsizei n, const GLenum *bufs) {
glDrawBuffers(n, bufs);
}
}

15
src/main/cpp/gl/getter.cpp
View File

@ -130,16 +130,30 @@ void InitGLESBaseExtensions() {
"OpenGL13 "
"OpenGL14 "
"OpenGL15 "
"OpenGL20 "
"OpenGL21 "
"OpenGL30 "
"OpenGL31 "
"OpenGL32 "
"OpenGL33 "
//"GL_ARB_multitexture "
"GL_ARB_texture_float "
"GL_EXT_texture_filter_anisotropic "
"GL_ARB_point_sprite "
"GL_ARB_pixel_buffer_object "
"GL_ARB_texture_non_power_of_two "
"GL_ARB_vertex_buffer_object "
"GL_EXT_framebuffer_object "
"GL_ARB_framebuffer_object "
"GL_EXT_framebuffer_multisample_blit_scaled "
"GL_EXT_framebuffer_blit_layers "
"GL_EXT_framebuffer_blit "
"GL_ARB_occlusion_query "
"GL_ARB_program_interface_query "
"GL_ARB_texture_rectangle "
"GL_ARB_multisample "
"GL_EXT_framebuffer_multisample "
"GL_ARB_uniform_buffer_object "
"GL_ARB_shader_objects "
"GL_ARB_vertex_shader "
"GL_ARB_fragment_shader "
@ -148,6 +162,7 @@ void InitGLESBaseExtensions() {
"GL_ARB_shader_image_load_store "
"GL_ARB_clear_texture "
"GL_ARB_get_program_binary "
"GL_EXT_separate_shader_objects "
"GL_ARB_separate_shader_objects ";
}

152
src/main/cpp/gl/gl4es/gl/buffers.c
View File

@ -26,20 +26,26 @@ static GLuint lastbuffer = 1;
// Utility function to bind / unbind a particular buffer
glbuffer_t** BUFF(GLenum target) {
switch(target) {
case GL_ARRAY_BUFFER:
return &glstate->vao->vertex;
break;
case GL_ELEMENT_ARRAY_BUFFER:
return &glstate->vao->elements;
break;
case GL_PIXEL_PACK_BUFFER:
return &glstate->vao->pack;
break;
case GL_PIXEL_UNPACK_BUFFER:
return &glstate->vao->unpack;
break;
default:
switch(target) {
case GL_ARRAY_BUFFER:
return &glstate->vao->vertex;
break;
case GL_ELEMENT_ARRAY_BUFFER:
return &glstate->vao->elements;
break;
case GL_PIXEL_PACK_BUFFER:
return &glstate->vao->pack;
break;
case GL_PIXEL_UNPACK_BUFFER:
return &glstate->vao->unpack;
break;
case GL_COPY_READ_BUFFER:
return &glstate->vao->read;
break;
case GL_COPY_WRITE_BUFFER:
return &glstate->vao->write;
break;
default:
LOGD("MobileGlues-gl4es: Warning, unknown buffer target 0x%04X\n", target);
}
return (glbuffer_t**)NULL;
@ -73,15 +79,19 @@ glbuffer_t* getbuffer_id(GLuint buffer) {
}
int buffer_target(GLenum target) {
if (target==GL_ARRAY_BUFFER)
return 1;
if (target==GL_ELEMENT_ARRAY_BUFFER)
return 1;
if (target==GL_PIXEL_PACK_BUFFER)
return 1;
if (target==GL_PIXEL_UNPACK_BUFFER)
return 1;
return 0;
if (target == GL_ARRAY_BUFFER)
return 1;
if (target == GL_ELEMENT_ARRAY_BUFFER)
return 1;
if (target == GL_PIXEL_PACK_BUFFER)
return 1;
if (target == GL_PIXEL_UNPACK_BUFFER)
return 1;
if (target == GL_COPY_READ_BUFFER)
return 1;
if (target == GL_COPY_WRITE_BUFFER)
return 1;
return 0;
}
void rebind_real_buff_arrays(int old_buffer, int new_buffer) {
@ -666,33 +676,63 @@ void APIENTRY_GL4ES gl4es_glFlushMappedBufferRange(GLenum target, GLintptr offse
}
if(buff->real_buffer && (buff->type==GL_ARRAY_BUFFER || buff->type==GL_ELEMENT_ARRAY_BUFFER) && (buff->access&GL_MAP_WRITE_BIT_EXT)) {
bindBuffer(buff->type, buff->real_buffer);
{} //STUB of gles_glBufferSubData(buff->type, buff->offset+offset, length, (void*)((uintptr_t)buff->data+buff->offset+offset));
}
if (buff->type == GL_COPY_READ_BUFFER) {
LOAD_GLES(glBufferSubData);
bindBuffer(buff->type, buff->real_buffer);
{} //STUB of gl4es_gles_glBufferSubData(buff->type, buff->offset+offset, length, (void*)((uintptr_t)buff->data+buff->offset+offset));
{} //STUB of gles_glBufferSubData(buff->type, buff->offset+offset, length, (void*)((uintptr_t)buff->data+buff->offset+offset));
}
}
void APIENTRY_GL4ES gl4es_glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
DBG(SHUT_LOGD("MobileGlues-gl4es: glCopyBufferSubData(%s, %s, %p, %p, %zd)\n", PrintEnum(readTarget), PrintEnum(writeTarget), (void*)readOffset, (void*)writeOffset, size);)
//TODO: Add GL_COPY_READ_BUFFER and GL_COPY_WRITE_BUFFER (and GL_QUERY_BUFFER?)
glbuffer_t *readbuff = getbuffer_buffer(readTarget);
glbuffer_t *writebuff = getbuffer_buffer(writeTarget);
if(!readbuff || !writebuff) {
DBG(printf("glCopyBufferSubData(%s, %s, %p, %p, %zd)\n", PrintEnum(readTarget), PrintEnum(writeTarget), (void*)readOffset, (void*)writeOffset, size);)
glbuffer_t *readbuff = getbuffer_buffer(readTarget);
glbuffer_t *writebuff = getbuffer_buffer(writeTarget);
if (!readbuff || !writebuff) {
errorShim(GL_INVALID_VALUE);
return;
}
if(writebuff->ranged && !(writebuff->access&GL_MAP_PERSISTENT_BIT)) {
if ((writebuff->ranged && !(writebuff->access & GL_MAP_PERSISTENT_BIT)) && readTarget != GL_COPY_READ_BUFFER) {
errorShim(GL_INVALID_OPERATION);
return;
}
// TODO: check memory overlap and overread/overwrite
memcpy((char*)writebuff->data+writeOffset, (char*)readbuff->data+readOffset, size);
if(writebuff->real_buffer && (writebuff->type==GL_ARRAY_BUFFER || writebuff->type==GL_ELEMENT_ARRAY_BUFFER) && writebuff->mapped && (writebuff->access==GL_WRITE_ONLY || writebuff->access==GL_READ_WRITE)) {
if ((char*)readbuff->data + readOffset >= (char*)readbuff->data + readbuff->size ||
(char*)writebuff->data + writeOffset >= (char*)writebuff->data + writebuff->size ||
(readOffset + size > readbuff->size) ||
(writeOffset + size > writebuff->size)) {
errorShim(GL_INVALID_OPERATION);
return;
}
if (readbuff == writebuff && readOffset + size > writeOffset) {
errorShim(GL_INVALID_OPERATION);
return;
}
memcpy((char*)writebuff->data + writeOffset, (char*)readbuff->data + readOffset, size);
if (writebuff->real_buffer && (writebuff->type == GL_ARRAY_BUFFER || writebuff->type == GL_ELEMENT_ARRAY_BUFFER) &&
writebuff->mapped && (writebuff->access == GL_WRITE_ONLY || writebuff->access == GL_READ_WRITE)) {
LOAD_GLES(glBufferSubData);
bindBuffer(writebuff->type, writebuff->real_buffer);
{} //STUB of gl4es_gles_glBufferSubData(writebuff->type, writeOffset, size, (char*)writebuff->data+writeOffset);
{} //STUB of gles_glBufferSubData(writebuff->type, writeOffset, size, (char*)writebuff->data + writeOffset);
}
if (readTarget == GL_COPY_READ_BUFFER) {
DBG(printf("GL_ARRAY_BUFFER data: %p\nGL_COPY_READ_BUFFER data: %p\n", getbuffer_buffer(GL_ARRAY_BUFFER)->data, readbuff->data);)
LOAD_GLES(glBufferSubData);
glstate->vao->write = writebuff;
bindBuffer(writebuff->type, writebuff->real_buffer);
{} //STUB of gles_glBufferSubData(writebuff->type, writeOffset, size, (char*)writebuff->data + writeOffset);
}
noerrorShim();
}
@ -713,6 +753,18 @@ void bindBuffer(GLenum target, GLuint buffer)
glstate->bind_buffer.index = buffer;
DBG(SHUT_LOGD("MobileGlues-gl4es: Bind buffer %d to GL_ELEMENT_ARRAY_BUFFER\n", buffer);)
{} //STUB of gl4es_gles_glBindBuffer(target, buffer);
} else if (target == GL_COPY_READ_BUFFER) {
if(glstate->bind_buffer.copy_read == buffer)
return;
glstate->bind_buffer.copy_read = buffer;
DBG(printf("Bind buffer %d to GL_COPY_READ_BUFFER\n", buffer);)
{} //STUB of gles_glBindBuffer(target, buffer);
} else if (target == GL_COPY_WRITE_BUFFER) {
if(glstate->bind_buffer.copy_write == buffer)
return;
glstate->bind_buffer.copy_write = buffer;
DBG(printf("Bind buffer %d to GL_COPY_WRITE_BUFFER\n", buffer);)
{} //STUB of gles_glBindBuffer(target, buffer);
} else {
LOGE("MobileGlues-gl4es: Warning, unhandled Buffer type %s in bindBuffer\n", PrintEnum(target));
return;
@ -737,6 +789,18 @@ void bindBuffer_real(GLenum target, GLuint buffer)
glstate->bind_buffer.index = buffer;
DBG(SHUT_LOGD("MobileGlues-gl4es: Really Bind buffer %d to GL_ELEMENT_ARRAY_BUFFER\n", buffer);)
gl4es_gles_glBindBuffer(target, buffer);
} else if (target == GL_COPY_READ_BUFFER) {
if(glstate->bind_buffer.copy_read == buffer)
return;
glstate->bind_buffer.copy_read = buffer;
DBG(printf("Bind buffer %d to GL_COPY_READ_BUFFER\n", buffer);)
gl4es_gles_glBindBuffer(target, buffer);
} else if (target == GL_COPY_WRITE_BUFFER) {
if(glstate->bind_buffer.copy_write == buffer)
return;
glstate->bind_buffer.copy_write = buffer;
DBG(printf("Bind buffer %d to GL_COPY_WRITE_BUFFER\n", buffer);)
gl4es_gles_glBindBuffer(target, buffer);
} else {
LOGE("MobileGlues-gl4es: (Really) Warning, unhandled Buffer type %s in bindBuffer\n", PrintEnum(target));
return;
@ -803,6 +867,16 @@ void unboundBuffers()
{} //STUB of gl4es_gles_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
DBG(SHUT_LOGD("MobileGlues-gl4es: Bind buffer %d to GL_ELEMENT_ARRAY_BUFFER\n", 0);)
}
if(glstate->bind_buffer.copy_read) {
glstate->bind_buffer.copy_read = 0;
{} //STUB of gles_glBindBuffer(GL_COPY_READ_BUFFER, 0);
DBG(printf("Bind buffer %d to GL_COPY_READ_BUFFER\n", 0);)
}
if(glstate->bind_buffer.copy_write) {
glstate->bind_buffer.copy_write = 0;
{} //STUB of gles_glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
DBG(printf("Bind buffer %d to GL_COPY_WRITE_BUFFER\n", 0);)
}
glstate->bind_buffer.used = 0;
}
@ -822,6 +896,16 @@ void unboundBuffers_real()
gl4es_gles_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
DBG(SHUT_LOGD("MobileGlues-gl4es: Really Bind buffer %d to GL_ELEMENT_ARRAY_BUFFER\n", 0);)
}
if(glstate->bind_buffer.copy_read) {
glstate->bind_buffer.copy_read = 0;
gl4es_gles_glBindBuffer(GL_COPY_READ_BUFFER, 0);
DBG(printf("Bind buffer %d to GL_COPY_READ_BUFFER\n", 0);)
}
if(glstate->bind_buffer.copy_write) {
glstate->bind_buffer.copy_write = 0;
gl4es_gles_glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
DBG(printf("Bind buffer %d to GL_COPY_WRITE_BUFFER\n", 0);)
}
glstate->bind_buffer.used = 0;
}

2
src/main/cpp/gl/gl4es/gl/buffers.h
View File

@ -221,6 +221,8 @@ typedef struct {
// Vertex Attrib
vertexattrib_t vertexattrib[MAX_VATTRIB];
// TODO: Cache VA also?
glbuffer_t *read;
glbuffer_t *write;
} glvao_t;
void VaoSharedClear(glvao_t *vao);

5
src/main/cpp/gl/gl4es/gl/drawing.c
View File

@ -891,11 +891,15 @@ void APIENTRY_GL4ES gl4es_glMultiDrawArrays(GLenum mode, const GLint *firsts, co
else
errorGL();
}
void glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) {
gl4es_glMultiDrawArrays(mode, first, count, primcount);
}
AliasExport(void,glMultiDrawArrays,,(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount));
void APIENTRY_GL4ES gl4es_glMultiDrawElements( GLenum mode, GLsizei *counts, GLenum type, const void * const *indices, GLsizei primcount)
{
DBG(SHUT_LOGD("MobileGlues-gl4es: glMultiDrawElements(%s, %p, %s, %p, %d), list=%p pending=%d\n", PrintEnum(mode), counts, PrintEnum(type), indices, primcount, glstate->list.active, glstate->list.pending);)
return;
if(!primcount) {
noerrorShim();
return;
@ -1017,6 +1021,7 @@ AliasExport(void,glMultiDrawElements,,( GLenum mode, GLsizei *count, GLenum type
void APIENTRY_GL4ES gl4es_glMultiDrawElementsBaseVertex( GLenum mode, GLsizei *counts, GLenum type, const void * const *indices, GLsizei primcount, const GLint * basevertex) {
DBG(SHUT_LOGD("MobileGlues-gl4es: glMultiDrawElementsBaseVertex(%s, %p, %s, @%p, %d, @%p), inlist=%i, pending=%d\n", PrintEnum(mode), counts, PrintEnum(type), indices, primcount, basevertex, (glstate->list.active)?1:0, glstate->list.pending);)
return;
// divide the call, should try something better one day...
bool compiling = (glstate->list.active);
bool intercept = should_intercept_render(mode);

2
src/main/cpp/gl/gl4es/gl/state.h
View File

@ -372,6 +372,8 @@ typedef struct {
GLuint index;
GLuint want_index;
int used;
GLuint copy_write;
GLuint copy_read;
} bind_buffers_t;

417
src/main/cpp/gl/gl_stub.cpp
View File

@ -469,36 +469,36 @@ STUB_FUNCTION_HEAD(void, glWindowPos3sv,const GLshort* v); STUB_FUNCTION_END_NO_
//STUB_FUNCTION_HEAD(void, glGetQueryObjectiv, GLuint id, GLenum pname, GLint* params); STUB_FUNCTION_END_NO_RETURN(void, glGetQueryObjectiv,id,pname,params)
STUB_FUNCTION_HEAD(void, glGetBufferSubData, GLenum target, GLintptr offset, GLsizeiptr size, void* data); STUB_FUNCTION_END_NO_RETURN(void, glGetBufferSubData,target,offset,size,data)
STUB_FUNCTION_HEAD(void, glGetVertexAttribdv, GLuint index, GLenum pname, GLdouble* params); STUB_FUNCTION_END_NO_RETURN(void, glGetVertexAttribdv,index,pname,params)
STUB_FUNCTION_HEAD(void, glVertexAttrib1d, GLuint index, GLdouble x); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1d,index,x)
STUB_FUNCTION_HEAD(void, glVertexAttrib1dv, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1dv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib1s, GLuint index, GLshort x); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1s,index,x)
STUB_FUNCTION_HEAD(void, glVertexAttrib1sv, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1sv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib2d, GLuint index, GLdouble x, GLdouble y); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2d,index,x,y)
STUB_FUNCTION_HEAD(void, glVertexAttrib2dv, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2dv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib2s, GLuint index, GLshort x, GLshort y); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2s,index,x,y)
STUB_FUNCTION_HEAD(void, glVertexAttrib2sv, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2sv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib3d, GLuint index, GLdouble x, GLdouble y, GLdouble z); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3d,index,x,y,z)
STUB_FUNCTION_HEAD(void, glVertexAttrib3dv, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3dv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib3s, GLuint index, GLshort x, GLshort y, GLshort z); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3s,index,x,y,z)
STUB_FUNCTION_HEAD(void, glVertexAttrib3sv, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3sv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4Nbv, GLuint index, const GLbyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nbv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4Niv, GLuint index, const GLint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Niv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4Nsv, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nsv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4Nub, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nub,index,x,y,z,w)
STUB_FUNCTION_HEAD(void, glVertexAttrib4Nubv, GLuint index, const GLubyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nubv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4Nuiv, GLuint index, const GLuint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nuiv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4Nusv, GLuint index, const GLushort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nusv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4bv, GLuint index, const GLbyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4bv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4d, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4d,index,x,y,z,w)
STUB_FUNCTION_HEAD(void, glVertexAttrib4dv, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4dv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4iv, GLuint index, const GLint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4iv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4s, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4s,index,x,y,z,w)
STUB_FUNCTION_HEAD(void, glVertexAttrib4sv, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4sv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4ubv, GLuint index, const GLubyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4ubv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4uiv, GLuint index, const GLuint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4uiv,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4usv, GLuint index, const GLushort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4usv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib1d, GLuint index, GLdouble x); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1d,index,x)
//STUB_FUNCTION_HEAD(void, glVertexAttrib1dv, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1dv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib1s, GLuint index, GLshort x); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1s,index,x)
//STUB_FUNCTION_HEAD(void, glVertexAttrib1sv, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1sv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib2d, GLuint index, GLdouble x, GLdouble y); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2d,index,x,y)
//STUB_FUNCTION_HEAD(void, glVertexAttrib2dv, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2dv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib2s, GLuint index, GLshort x, GLshort y); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2s,index,x,y)
//STUB_FUNCTION_HEAD(void, glVertexAttrib2sv, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2sv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib3d, GLuint index, GLdouble x, GLdouble y, GLdouble z); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3d,index,x,y,z)
//STUB_FUNCTION_HEAD(void, glVertexAttrib3dv, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3dv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib3s, GLuint index, GLshort x, GLshort y, GLshort z); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3s,index,x,y,z)
//STUB_FUNCTION_HEAD(void, glVertexAttrib3sv, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3sv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4Nbv, GLuint index, const GLbyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nbv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4Niv, GLuint index, const GLint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Niv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4Nsv, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nsv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4Nub, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nub,index,x,y,z,w)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4Nubv, GLuint index, const GLubyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nubv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4Nuiv, GLuint index, const GLuint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nuiv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4Nusv, GLuint index, const GLushort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4Nusv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4bv, GLuint index, const GLbyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4bv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4d, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4d,index,x,y,z,w)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4dv, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4dv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4iv, GLuint index, const GLint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4iv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4s, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4s,index,x,y,z,w)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4sv, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4sv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4ubv, GLuint index, const GLubyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4ubv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4uiv, GLuint index, const GLuint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4uiv,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4usv, GLuint index, const GLushort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4usv,index,v)
STUB_FUNCTION_HEAD(void, glPrimitiveRestartIndex, GLuint index); STUB_FUNCTION_END_NO_RETURN(void, glPrimitiveRestartIndex,index)
STUB_FUNCTION_HEAD(void, glGetActiveUniformName, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); STUB_FUNCTION_END_NO_RETURN(void, glGetActiveUniformName,program,uniformIndex,bufSize,length,uniformName)
//STUB_FUNCTION_HEAD(void, glGetActiveUniformName, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); STUB_FUNCTION_END_NO_RETURN(void, glGetActiveUniformName,program,uniformIndex,bufSize,length,uniformName)
//STUB_FUNCTION_HEAD(void, glMultiDrawElementsBaseVertex, GLenum mode, const GLsizei* count, GLenum type, const void* const*indices, GLsizei drawcount, const GLint* basevertex); STUB_FUNCTION_END_NO_RETURN(void, glMultiDrawElementsBaseVertex,mode,count,type,indices,drawcount,basevertex)
STUB_FUNCTION_HEAD(void, glProvokingVertex, GLenum mode); STUB_FUNCTION_END_NO_RETURN(void, glProvokingVertex,mode)
STUB_FUNCTION_HEAD(void, glTexImage2DMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); STUB_FUNCTION_END_NO_RETURN(void, glTexImage2DMultisample,target,samples,internalformat,width,height,fixedsamplelocations)
@ -632,7 +632,7 @@ STUB_FUNCTION_HEAD(void, glInvalidateBufferSubData, GLuint buffer, GLintptr offs
STUB_FUNCTION_HEAD(void, glInvalidateBufferData, GLuint buffer); STUB_FUNCTION_END_NO_RETURN(void, glInvalidateBufferData,buffer)
STUB_FUNCTION_HEAD(void, glMultiDrawArraysIndirect, GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride); STUB_FUNCTION_END_NO_RETURN(void, glMultiDrawArraysIndirect,mode,indirect,drawcount,stride)
STUB_FUNCTION_HEAD(void, glMultiDrawElementsIndirect, GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride); STUB_FUNCTION_END_NO_RETURN(void, glMultiDrawElementsIndirect,mode,type,indirect,drawcount,stride)
STUB_FUNCTION_HEAD(GLint, glGetProgramResourceLocationIndex, GLuint program, GLenum programInterface, const GLchar* name); STUB_FUNCTION_END_NO_RETURN(GLint, glGetProgramResourceLocationIndex,program,programInterface,name)
//STUB_FUNCTION_HEAD(GLint, glGetProgramResourceLocationIndex, GLuint program, GLenum programInterface, const GLchar* name); STUB_FUNCTION_END_NO_RETURN(GLint, glGetProgramResourceLocationIndex,program,programInterface,name)
STUB_FUNCTION_HEAD(void, glShaderStorageBlockBinding, GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding); STUB_FUNCTION_END_NO_RETURN(void, glShaderStorageBlockBinding,program,storageBlockIndex,storageBlockBinding)
STUB_FUNCTION_HEAD(void, glTextureView, GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers); STUB_FUNCTION_END_NO_RETURN(void, glTextureView,texture,target,origtexture,internalformat,minlevel,numlevels,minlayer,numlayers)
STUB_FUNCTION_HEAD(void, glVertexAttribLFormat, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttribLFormat,attribindex,size,type,relativeoffset)
@ -940,8 +940,8 @@ STUB_FUNCTION_HEAD(void, glEvaluateDepthValuesARB,void); STUB_FUNCTION_END_NO_RE
//STUB_FUNCTION_HEAD(GLhandleARB, glCreateProgramObjectARB,void); STUB_FUNCTION_END_NO_RETURN(GLhandleARB, glCreateProgramObjectARB,)
//STUB_FUNCTION_HEAD(void, glAttachObjectARB, GLhandleARB containerObj, GLhandleARB obj); STUB_FUNCTION_END_NO_RETURN(void, glAttachObjectARB,containerObj,obj)
//STUB_FUNCTION_HEAD(void, glUseProgramObjectARB, GLhandleARB programObj); STUB_FUNCTION_END_NO_RETURN(void, glUseProgramObjectARB,programObj)
STUB_FUNCTION_HEAD(void, glGetObjectParameterfvARB, GLhandleARB obj, GLenum pname, GLfloat* params); STUB_FUNCTION_END_NO_RETURN(void, glGetObjectParameterfvARB,obj,pname,params)
STUB_FUNCTION_HEAD(void, glGetObjectParameterivARB, GLhandleARB obj, GLenum pname, GLint* params); STUB_FUNCTION_END_NO_RETURN(void, glGetObjectParameterivARB,obj,pname,params)
//STUB_FUNCTION_HEAD(void, glGetObjectParameterfvARB, GLhandleARB obj, GLenum pname, GLfloat* params); STUB_FUNCTION_END_NO_RETURN(void, glGetObjectParameterfvARB,obj,pname,params)
//STUB_FUNCTION_HEAD(void, glGetObjectParameterivARB, GLhandleARB obj, GLenum pname, GLint* params); STUB_FUNCTION_END_NO_RETURN(void, glGetObjectParameterivARB,obj,pname,params)
STUB_FUNCTION_HEAD(void, glGetInfoLogARB, GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB* infoLog); STUB_FUNCTION_END_NO_RETURN(void, glGetInfoLogARB,obj,maxLength,length,infoLog)
STUB_FUNCTION_HEAD(void, glGetAttachedObjectsARB, GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB* obj); STUB_FUNCTION_END_NO_RETURN(void, glGetAttachedObjectsARB,containerObj,maxCount,count,obj)
STUB_FUNCTION_HEAD(void, glNamedStringARB, GLenum type, GLint namelen, const GLchar* name, GLint stringlen, const GLchar* string); STUB_FUNCTION_END_NO_RETURN(void, glNamedStringARB,type,namelen,name,stringlen,string)
@ -972,18 +972,18 @@ STUB_FUNCTION_HEAD(void, glWeightuivARB, GLint size, const GLuint* weights); STU
STUB_FUNCTION_HEAD(void, glWeightPointerARB, GLint size, GLenum type, GLsizei stride, const void* pointer); STUB_FUNCTION_END_NO_RETURN(void, glWeightPointerARB,size,type,stride,pointer)
STUB_FUNCTION_HEAD(void, glVertexBlendARB, GLint count); STUB_FUNCTION_END_NO_RETURN(void, glVertexBlendARB,count)
STUB_FUNCTION_HEAD(void, glGetBufferSubDataARB, GLenum target, GLintptrARB offset, GLsizeiptrARB size, void* data); STUB_FUNCTION_END_NO_RETURN(void, glGetBufferSubDataARB,target,offset,size,data)
STUB_FUNCTION_HEAD(void, glVertexAttrib1dARB, GLuint index, GLdouble x); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1dARB,index,x)
STUB_FUNCTION_HEAD(void, glVertexAttrib1dvARB, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1dvARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib1sARB, GLuint index, GLshort x); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1sARB,index,x)
STUB_FUNCTION_HEAD(void, glVertexAttrib1svARB, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1svARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib2dARB, GLuint index, GLdouble x, GLdouble y); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2dARB,index,x,y)
STUB_FUNCTION_HEAD(void, glVertexAttrib2dvARB, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2dvARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib2sARB, GLuint index, GLshort x, GLshort y); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2sARB,index,x,y)
STUB_FUNCTION_HEAD(void, glVertexAttrib2svARB, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2svARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib3dARB, GLuint index, GLdouble x, GLdouble y, GLdouble z); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3dARB,index,x,y,z)
STUB_FUNCTION_HEAD(void, glVertexAttrib3dvARB, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3dvARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib3sARB, GLuint index, GLshort x, GLshort y, GLshort z); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3sARB,index,x,y,z)
STUB_FUNCTION_HEAD(void, glVertexAttrib3svARB, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3svARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib1dARB, GLuint index, GLdouble x); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1dARB,index,x)
//STUB_FUNCTION_HEAD(void, glVertexAttrib1dvARB, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1dvARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib1sARB, GLuint index, GLshort x); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1sARB,index,x)
//STUB_FUNCTION_HEAD(void, glVertexAttrib1svARB, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib1svARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib2dARB, GLuint index, GLdouble x, GLdouble y); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2dARB,index,x,y)
//STUB_FUNCTION_HEAD(void, glVertexAttrib2dvARB, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2dvARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib2sARB, GLuint index, GLshort x, GLshort y); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2sARB,index,x,y)
//STUB_FUNCTION_HEAD(void, glVertexAttrib2svARB, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib2svARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib3dARB, GLuint index, GLdouble x, GLdouble y, GLdouble z); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3dARB,index,x,y,z)
//STUB_FUNCTION_HEAD(void, glVertexAttrib3dvARB, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3dvARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib3sARB, GLuint index, GLshort x, GLshort y, GLshort z); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3sARB,index,x,y,z)
//STUB_FUNCTION_HEAD(void, glVertexAttrib3svARB, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib3svARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4NbvARB, GLuint index, const GLbyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4NbvARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4NivARB, GLuint index, const GLint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4NivARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4NsvARB, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4NsvARB,index,v)
@ -991,16 +991,16 @@ STUB_FUNCTION_HEAD(void, glVertexAttrib4NubARB, GLuint index, GLubyte x, GLubyte
STUB_FUNCTION_HEAD(void, glVertexAttrib4NubvARB, GLuint index, const GLubyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4NubvARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4NuivARB, GLuint index, const GLuint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4NuivARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4NusvARB, GLuint index, const GLushort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4NusvARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4bvARB, GLuint index, const GLbyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4bvARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4dARB, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4dARB,index,x,y,z,w)
STUB_FUNCTION_HEAD(void, glVertexAttrib4dvARB, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4dvARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4ivARB, GLuint index, const GLint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4ivARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4sARB, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4sARB,index,x,y,z,w)
STUB_FUNCTION_HEAD(void, glVertexAttrib4svARB, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4svARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4ubvARB, GLuint index, const GLubyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4ubvARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4uivARB, GLuint index, const GLuint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4uivARB,index,v)
STUB_FUNCTION_HEAD(void, glVertexAttrib4usvARB, GLuint index, const GLushort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4usvARB,index,v)
STUB_FUNCTION_HEAD(void, glGetVertexAttribdvARB, GLuint index, GLenum pname, GLdouble* params); STUB_FUNCTION_END_NO_RETURN(void, glGetVertexAttribdvARB,index,pname,params)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4bvARB, GLuint index, const GLbyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4bvARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4dARB, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4dARB,index,x,y,z,w)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4dvARB, GLuint index, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4dvARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4ivARB, GLuint index, const GLint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4ivARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4sARB, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4sARB,index,x,y,z,w)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4svARB, GLuint index, const GLshort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4svARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4ubvARB, GLuint index, const GLubyte* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4ubvARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4uivARB, GLuint index, const GLuint* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4uivARB,index,v)
//STUB_FUNCTION_HEAD(void, glVertexAttrib4usvARB, GLuint index, const GLushort* v); STUB_FUNCTION_END_NO_RETURN(void, glVertexAttrib4usvARB,index,v)
//STUB_FUNCTION_HEAD(void, glGetVertexAttribdvARB, GLuint index, GLenum pname, GLdouble* params); STUB_FUNCTION_END_NO_RETURN(void, glGetVertexAttribdvARB,index,pname,params)
STUB_FUNCTION_HEAD(void, glDepthRangeArraydvNV, GLuint first, GLsizei count, const GLdouble* v); STUB_FUNCTION_END_NO_RETURN(void, glDepthRangeArraydvNV,first,count,v)
STUB_FUNCTION_HEAD(void, glDepthRangeIndexeddNV, GLuint index, GLdouble n, GLdouble f); STUB_FUNCTION_END_NO_RETURN(void, glDepthRangeIndexeddNV,index,n,f)
STUB_FUNCTION_HEAD(void, glWindowPos2dARB, GLdouble x, GLdouble y); STUB_FUNCTION_END_NO_RETURN(void, glWindowPos2dARB,x,y)
@ -2487,6 +2487,315 @@ STUB_FUNCTION_HEAD(void, glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN,const
STUB_FUNCTION_HEAD(void, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); STUB_FUNCTION_END_NO_RETURN(void, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN,rc,s,t,r,g,b,a,nx,ny,nz,x,y,z)
STUB_FUNCTION_HEAD(void, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN,const GLuint* rc, const GLfloat* tc, const GLfloat* c, const GLfloat* n, const GLfloat* v); STUB_FUNCTION_END_NO_RETURN(void, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN,rc,tc,c,n,v)
EXPORT void glVertexAttrib4sv(GLuint index, const GLshort *v) { LOG_W_FORCE("glVertexAttrib4sv") }
EXPORT void glCompressedTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) { LOG_W_FORCE("glCompressedTexImage2DEXT") }
EXPORT void glMultiTexCoord3ui(GLenum target, GLuint s, GLuint t, GLuint r) { LOG_W_FORCE("glMultiTexCoord3ui") }
EXPORT void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat near_val, GLfloat far_val) { LOG_W_FORCE("glOrthof") }
EXPORT void glVertex2bv(const GLbyte *v) { LOG_W_FORCE("glVertex2bv") }
EXPORT void glMultiTexCoord3ub(GLenum target, GLubyte s, GLubyte t, GLubyte r) { LOG_W_FORCE("glMultiTexCoord3ub") }
EXPORT void glMultiTexCoord4uiv(GLenum target, const GLuint *v) { LOG_W_FORCE("glMultiTexCoord4uiv") }
EXPORT void glRasterPos2uiv(const GLuint *v) { LOG_W_FORCE("glRasterPos2uiv") }
EXPORT void glMultiTexCoord2usv(GLenum target, const GLushort *v) { LOG_W_FORCE("glMultiTexCoord2usv") }
EXPORT void glTexCoord4b(GLbyte s, GLbyte t, GLbyte r, GLbyte q) { LOG_W_FORCE("glTexCoord4b") }
EXPORT void glDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) { LOG_W_FORCE("glDrawRangeElementsEXT") }
EXPORT void glProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) { LOG_W_FORCE("glProgramUniform3iEXT") }
EXPORT void glFogxv(GLenum pname, const GLfixed *param) { LOG_W_FORCE("glFogxv") }
EXPORT void glMultiTexCoord4bv(GLenum target, const GLbyte *v) { LOG_W_FORCE("glMultiTexCoord4bv") }
EXPORT void glMultiTexCoord1bARB(GLenum target, GLbyte s) { LOG_W_FORCE("glMultiTexCoord1bARB") }
EXPORT void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) { LOG_W_FORCE("glVertexAttrib3d") }
EXPORT void glTexCoord4bv(const GLbyte *v) { LOG_W_FORCE("glTexCoord4bv") }
EXPORT void glMultiTexCoord4ubARB(GLenum target, GLubyte s, GLubyte t, GLubyte r, GLubyte q) { LOG_W_FORCE("glMultiTexCoord4ubARB") }
EXPORT void glMultiTexCoord3b(GLenum target, GLbyte s, GLbyte t, GLbyte r) { LOG_W_FORCE("glMultiTexCoord3b") }
EXPORT void glMultiTexCoord3ubARB(GLenum target, GLubyte s, GLubyte t, GLubyte r) { LOG_W_FORCE("glMultiTexCoord3ubARB") }
EXPORT void glMultiTexCoord1usARB(GLenum target, GLushort s) { LOG_W_FORCE("glMultiTexCoord1usARB") }
EXPORT Bool glXReleaseBuffersMESA(Display *dpy, GLXDrawable drawable) { LOG_W_FORCE("glXReleaseBuffersMESA") }
EXPORT void glWindowPos2bv(const GLbyte *v) { LOG_W_FORCE("glWindowPos2bv") }
EXPORT void glVertexAttrib4ubv(GLuint index, const GLubyte *v) { LOG_W_FORCE("glVertexAttrib4ubv") }
EXPORT void glMultiTexCoord1ubARB(GLenum target, GLubyte s) { LOG_W_FORCE("glMultiTexCoord1ubARB") }
EXPORT void glWindowPos3us(GLushort x, GLushort y, GLushort z) { LOG_W_FORCE("glWindowPos3us") }
EXPORT void glFogx(GLenum pname, GLfixed param) { LOG_W_FORCE("glFogx") }
EXPORT void glMultiTexCoord4usv(GLenum target, const GLushort *v) { LOG_W_FORCE("glMultiTexCoord4usv") }
EXPORT void glRasterPos2bv(const GLbyte *v) { LOG_W_FORCE("glRasterPos2bv") }
EXPORT void glLightModelxv(GLenum pname, const GLfixed *param) { LOG_W_FORCE("glLightModelxv") }
EXPORT void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { LOG_W_FORCE("glColor4x") }
EXPORT void glDeleteBufferStorage(GLuint buffer) { LOG_W_FORCE("glDeleteBufferStorage") }
EXPORT void glRasterPos3b(GLbyte x, GLbyte y, GLbyte z) { LOG_W_FORCE("glRasterPos3b") }
EXPORT void glNamedFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, const GLenum *bufs) { LOG_W_FORCE("glNamedFramebufferDrawBuffersEXT") }
EXPORT void glMultiTexCoord4ui(GLenum target, GLuint s, GLuint t, GLuint r, GLuint q) { LOG_W_FORCE("glMultiTexCoord4ui") }
EXPORT void glWindowPos3usv(const GLushort *v) { LOG_W_FORCE("glWindowPos3usv") }
EXPORT void glFogfvEXT(GLenum pname, const GLfloat *params) { LOG_W_FORCE("glFogfvEXT") }
EXPORT void glVertex4ubv(const GLubyte *v) { LOG_W_FORCE("glVertex4ubv") }
EXPORT void glProgramUniform4fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { LOG_W_FORCE("glProgramUniform4fEXT") }
EXPORT void glMultiTexCoord2ui(GLenum target, GLuint s, GLuint t) { LOG_W_FORCE("glMultiTexCoord2ui") }
EXPORT void glRasterPos4bv(const GLbyte *v) { LOG_W_FORCE("glRasterPos4bv") }
EXPORT void glRasterPos3bv(const GLbyte *v) { LOG_W_FORCE("glRasterPos3bv") }
EXPORT void glRasterPos3ui(GLuint x, GLuint y, GLuint z) { LOG_W_FORCE("glRasterPos3ui") }
EXPORT void glTexCoord1usv(const GLushort *v) { LOG_W_FORCE("glTexCoord1usv") }
EXPORT void glRasterPos4b(GLbyte x, GLbyte y, GLbyte z, GLbyte w) { LOG_W_FORCE("glRasterPos4b") }
EXPORT int glXWaitX(void) { LOG_W_FORCE("glXWaitX") }
EXPORT void glMultiTexCoord3bvARB(GLenum target, const GLbyte *v) { LOG_W_FORCE("glMultiTexCoord3bvARB") }
EXPORT void glTexCoord3b(GLbyte s, GLbyte t, GLbyte r) { LOG_W_FORCE("glTexCoord3b") }
EXPORT void glMultiTexCoord4bARB(GLenum target, GLbyte s, GLbyte t, GLbyte r, GLbyte q) { LOG_W_FORCE("glMultiTexCoord4bARB") }
EXPORT void glMultiTexCoord2bv(GLenum target, const GLbyte *v) { LOG_W_FORCE("glMultiTexCoord2bv") }
EXPORT void glProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { LOG_W_FORCE("glProgramUniformMatrix4fvEXT") }
EXPORT void glVertexAttrib4Nuiv(GLuint index, const GLuint *v) { LOG_W_FORCE("glVertexAttrib4Nuiv") }
EXPORT void glVertexAttrib4iv(GLuint index, const GLint *v) { LOG_W_FORCE("glVertexAttrib4iv") }
EXPORT void glVertexAttrib2dv(GLuint index, const GLdouble *v) { LOG_W_FORCE("glVertexAttrib2dv") }
EXPORT void glRasterPos3us(GLushort x, GLushort y, GLushort z) { LOG_W_FORCE("glRasterPos3us") }
EXPORT void glMultiTexCoord2usvARB(GLenum target, const GLushort *v) { LOG_W_FORCE("glMultiTexCoord2usvARB") }
EXPORT void glMultiTexCoord1ub(GLenum target, GLubyte s) { LOG_W_FORCE("glMultiTexCoord1ub") }
EXPORT void glTexCoord1ui(GLuint s) { LOG_W_FORCE("glTexCoord1ui") }
EXPORT void glRasterPos4usv(const GLushort *v) { LOG_W_FORCE("glRasterPos4usv") }
EXPORT void glMultiTexCoord1ubv(GLenum target, const GLubyte *v) { LOG_W_FORCE("glMultiTexCoord1ubv") }
EXPORT void glVertex3uiv(const GLuint *v) { LOG_W_FORCE("glVertex3uiv") }
EXPORT void glNormal3us(GLushort nx, GLushort ny, GLushort nz) { LOG_W_FORCE("glNormal3us") }
EXPORT void glRasterPos4us(GLushort x, GLushort y, GLushort z, GLushort w) { LOG_W_FORCE("glRasterPos4us") }
EXPORT void glMultiTexCoord1uiARB(GLenum target, GLuint s) { LOG_W_FORCE("glMultiTexCoord1uiARB") }
EXPORT void glMultiTexCoord2usARB(GLenum target, GLushort s, GLushort t) { LOG_W_FORCE("glMultiTexCoord2usARB") }
EXPORT void glTexCoord4ubv(const GLubyte *v) { LOG_W_FORCE("glTexCoord4ubv") }
EXPORT void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) { LOG_W_FORCE("glVertexAttrib2d") }
EXPORT void glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { LOG_W_FORCE("glCopyTexSubImage3DEXT") }
EXPORT int glXSwapInterval(Display *dpy, GLXDrawable drawable, int interval) { LOG_W_FORCE("glXSwapInterval") }
EXPORT void glTexCoord2ui(GLuint s, GLuint t) { LOG_W_FORCE("glTexCoord2ui") }
EXPORT void glMultiTexCoord3uiv(GLenum target, const GLuint *v) { LOG_W_FORCE("glMultiTexCoord3uiv") }
EXPORT void glMultiTexCoord3bv(GLenum target, const GLbyte *v) { LOG_W_FORCE("glMultiTexCoord3bv") }
EXPORT void glFrustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f) { LOG_W_FORCE("glFrustumx") }
EXPORT const char* glXQueryExtensionsString(Display *dpy, int screen) { LOG_W_FORCE("glXQueryExtensionsString") }
EXPORT void glWindowPos3bv(const GLbyte *v) { LOG_W_FORCE("glWindowPos3bv") }
EXPORT void glMultiTexCoord2ubARB(GLenum target, GLubyte s, GLubyte t) { LOG_W_FORCE("glMultiTexCoord2ubARB") }
EXPORT void glMultiTexCoord3uiARB(GLenum target, GLuint s, GLuint t, GLuint r) { LOG_W_FORCE("glMultiTexCoord3uiARB") }
EXPORT void glMaterialx(GLenum face, GLenum pname, GLfixed param) { LOG_W_FORCE("glMaterialx") }
EXPORT void glRasterPos3uiv(const GLuint *v) { LOG_W_FORCE("glRasterPos3uiv") }
EXPORT Bool glXQueryExtension(Display *dpy, int *errorBase, int *eventBase) { LOG_W_FORCE("glXQueryExtension") }
EXPORT void glVertexAttrib1sv(GLuint index, const GLshort *v) { LOG_W_FORCE("glVertexAttrib1sv") }
EXPORT void glMultiTexCoord4ubvARB(GLenum target, const GLubyte *v) { LOG_W_FORCE("glMultiTexCoord4ubvARB") }
EXPORT void glClearNamedFramebufferivEXT(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value) { LOG_W_FORCE("glClearNamedFramebufferivEXT") }
EXPORT void glTexCoord4ub(GLubyte s, GLubyte t, GLubyte r, GLubyte q) { LOG_W_FORCE("glTexCoord4ub") }
EXPORT void glWindowPos2ubv(const GLubyte *v) { LOG_W_FORCE("glWindowPos2ubv") }
EXPORT void glCompressedTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) { LOG_W_FORCE("glCompressedTexImage3DEXT") }
EXPORT void glVertex3ubv(const GLubyte *v) { LOG_W_FORCE("glVertex3ubv") }
EXPORT void glPointSizex(GLfixed size) { LOG_W_FORCE("glPointSizex") }
EXPORT void glWindowPos3uiv(const GLuint *v) { LOG_W_FORCE("glWindowPos3uiv") }
EXPORT int glXWaitGL(void) { LOG_W_FORCE("glXWaitGL") }
EXPORT void glTexEnvx(GLenum target, GLenum pname, GLfixed param) { LOG_W_FORCE("glTexEnvx") }
EXPORT void glLightx(GLenum light, GLenum pname, GLfixed param) { LOG_W_FORCE("glLightx") }
EXPORT void glMultiTexCoord4us(GLenum target, GLushort s, GLushort t, GLushort r, GLushort q) { LOG_W_FORCE("glMultiTexCoord4us") }
EXPORT void glWindowPos2ui(GLuint x, GLuint y) { LOG_W_FORCE("glWindowPos2ui") }
EXPORT void glTexCoord3usv(const GLushort *v) { LOG_W_FORCE("glTexCoord3usv") }
EXPORT void glVertexAttrib1s(GLuint index, GLshort x) { LOG_W_FORCE("glVertexAttrib1s") }
EXPORT void glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeAlpha) { LOG_W_FORCE("glBlendEquationSeparateEXT") }
EXPORT void glVertex3ub(GLubyte x, GLubyte y, GLubyte z) { LOG_W_FORCE("glVertex3ub") }
EXPORT int glXSwapIntervalSGI(int interval) { LOG_W_FORCE("glXSwapIntervalSGI") }
EXPORT void glVertex2ui(GLuint x, GLuint y) { LOG_W_FORCE("glVertex2ui") }
EXPORT void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { LOG_W_FORCE("glMultiTexCoord4x") }
EXPORT void glGetTexEnvxv(GLenum target, GLenum pname, GLfixed *params) { LOG_W_FORCE("glGetTexEnvxv") }
EXPORT void glMultiTexCoord2bvARB(GLenum target, const GLbyte *v) { LOG_W_FORCE("glMultiTexCoord2bvARB") }
EXPORT void glClearNamedFramebufferfiEXT(GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) { LOG_W_FORCE("glClearNamedFramebufferfiEXT") }
EXPORT void glRasterPos4ui(GLuint x, GLuint y, GLuint z, GLuint w) { LOG_W_FORCE("glRasterPos4ui") }
EXPORT void glVertexAttrib2sv(GLuint index, const GLshort *v) { LOG_W_FORCE("glVertexAttrib2sv") }
EXPORT void glVertexAttrib1dv(GLuint index, const GLdouble *v) { LOG_W_FORCE("glVertexAttrib1dv") }
EXPORT void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) { LOG_W_FORCE("glRotatex") }
EXPORT void glPointParameterx(GLenum pname, GLfixed param) { LOG_W_FORCE("glPointParameterx") }
EXPORT void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { LOG_W_FORCE("glVertexAttrib4d") }
EXPORT void glMultiTexCoord3usvARB(GLenum target, const GLushort *v) { LOG_W_FORCE("glMultiTexCoord3usvARB") }
EXPORT void glTexCoord2b(GLbyte s, GLbyte t) { LOG_W_FORCE("glTexCoord2b") }
EXPORT void glMultiTexCoord1usv(GLenum target, const GLushort *v) { LOG_W_FORCE("glMultiTexCoord1usv") }
EXPORT void glTexCoord1ub(GLubyte s) { LOG_W_FORCE("glTexCoord1ub") }
EXPORT void glTexParameterx(GLenum target, GLenum pname, GLfixed param) { LOG_W_FORCE("glTexParameterx") }
EXPORT void glMultiTexCoord2uiARB(GLenum target, GLuint s, GLuint t) { LOG_W_FORCE("glMultiTexCoord2uiARB") }
EXPORT void glVertexAttrib3dv(GLuint index, const GLdouble *v) { LOG_W_FORCE("glVertexAttrib3dv") }
EXPORT void glLightxv(GLenum light, GLenum pname, const GLfixed *params) { LOG_W_FORCE("glLightxv") }
EXPORT void glVertex3us(GLushort x, GLushort y, GLushort z) { LOG_W_FORCE("glVertex3us") }
EXPORT void glTexCoord3ub(GLubyte s, GLubyte t, GLubyte r) { LOG_W_FORCE("glTexCoord3ub") }
EXPORT void glRasterPos2ubv(const GLubyte *v) { LOG_W_FORCE("glRasterPos2ubv") }
EXPORT Bool glXQueryVersion(Display *dpy, int *major, int *minor) { LOG_W_FORCE("glXQueryVersion") }
EXPORT void glRasterPos2ui(GLuint x, GLuint y) { LOG_W_FORCE("glRasterPos2ui") }
EXPORT void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) { LOG_W_FORCE("glVertexAttrib4s") }
EXPORT void glLightModelx(GLenum pname, GLfixed param) { LOG_W_FORCE("glLightModelx") }
EXPORT int glXSwapIntervalMESA(unsigned int interval) { LOG_W_FORCE("glXSwapIntervalMESA") }
EXPORT void glMultiTexCoord2ubvARB(GLenum target, const GLubyte *v) { LOG_W_FORCE("glMultiTexCoord2ubvARB") }
EXPORT void glTexCoord2us(GLushort s, GLushort t) { LOG_W_FORCE("glTexCoord2us") }
EXPORT void glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params) { LOG_W_FORCE("glGetMaterialxv") }
EXPORT void glVertex4usv(const GLushort *v) { LOG_W_FORCE("glVertex4usv") }
EXPORT void glMultiTexCoord4b(GLenum target, GLbyte s, GLbyte t, GLbyte r, GLbyte q) { LOG_W_FORCE("glMultiTexCoord4b") }
EXPORT void glVertex3usv(const GLushort *v) { LOG_W_FORCE("glVertex3usv") }
EXPORT void glProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) { LOG_W_FORCE("glProgramUniform4iEXT") }
EXPORT void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) { LOG_W_FORCE("glVertexAttrib3s") }
EXPORT void glProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { LOG_W_FORCE("glProgramUniformMatrix2fvEXT") }
EXPORT void glVertex4b(GLbyte x, GLbyte y, GLbyte z, GLbyte w) { LOG_W_FORCE("glVertex4b") }
EXPORT void glMultiTexCoord2uiv(GLenum target, const GLuint *v) { LOG_W_FORCE("glMultiTexCoord2uiv") }
EXPORT void glTexCoord3ui(GLuint s, GLuint t, GLuint r) { LOG_W_FORCE("glTexCoord3ui") }
EXPORT void* glMapNamedBuffer(GLuint buffer, GLenum access) { LOG_W_FORCE("glMapNamedBuffer") }
EXPORT void glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value) { LOG_W_FORCE("glProgramUniform3fvEXT") }
EXPORT void glVertex4uiv(const GLuint *v) { LOG_W_FORCE("glVertex4uiv") }
EXPORT void glGetClipPlanex(GLenum plane, GLfixed *equation) { LOG_W_FORCE("glGetClipPlanex") }
EXPORT void glMultiTexCoord4bvARB(GLenum target, const GLbyte *v) { LOG_W_FORCE("glMultiTexCoord4bvARB") }
EXPORT void glRasterPos4ub(GLubyte x, GLubyte y, GLubyte z, GLubyte w) { LOG_W_FORCE("glRasterPos4ub") }
EXPORT void glMultiTexCoord2ubv(GLenum target, const GLubyte *v) { LOG_W_FORCE("glMultiTexCoord2ubv") }
EXPORT void glMultiTexCoord2ub(GLenum target, GLubyte s, GLubyte t) { LOG_W_FORCE("glMultiTexCoord2ub") }
EXPORT void glProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { LOG_W_FORCE("glProgramUniformMatrix3fvEXT") }
EXPORT void glRasterPos3ubv(const GLubyte *v) { LOG_W_FORCE("glRasterPos3ubv") }
EXPORT void glMultiTexCoord1bvARB(GLenum target, const GLbyte *v) { LOG_W_FORCE("glMultiTexCoord1bvARB") }
EXPORT void glMultiTexCoord3us(GLenum target, GLushort s, GLushort t, GLushort r) { LOG_W_FORCE("glMultiTexCoord3us") }
EXPORT void glBlendColorEXT(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { LOG_W_FORCE("glBlendColorEXT") }
EXPORT void glNormal3usv(const GLushort *v) { LOG_W_FORCE("glNormal3usv") }
EXPORT void glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value) { LOG_W_FORCE("glProgramUniform3ivEXT") }
EXPORT void glMultiTexCoord1us(GLenum target, GLushort s) { LOG_W_FORCE("glMultiTexCoord1us") }
EXPORT void glRasterPos3usv(const GLushort *v) { LOG_W_FORCE("glRasterPos3usv") }
EXPORT void glMultiTexCoord2us(GLenum target, GLushort s, GLushort t) { LOG_W_FORCE("glMultiTexCoord2us") }
EXPORT void glMultiTexCoord1uiv(GLenum target, const GLuint *v) { LOG_W_FORCE("glMultiTexCoord1uiv") }
EXPORT void glMultiTexCoord4uiARB(GLenum target, GLuint s, GLuint t, GLuint r, GLuint q) { LOG_W_FORCE("glMultiTexCoord4uiARB") }
EXPORT void glCompressedTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data) { LOG_W_FORCE("glCompressedTexSubImage1DEXT") }
EXPORT void glMultiTexCoord2uivARB(GLenum target, const GLuint *v) { LOG_W_FORCE("glMultiTexCoord2uivARB") }
EXPORT void glMultiTexCoord2b(GLenum target, GLbyte s, GLbyte t) { LOG_W_FORCE("glMultiTexCoord2b") }
EXPORT void glMultiTexCoord1ubvARB(GLenum target, const GLubyte *v) { LOG_W_FORCE("glMultiTexCoord1ubvARB") }
EXPORT void glVertex4ui(GLuint x, GLuint y, GLuint z, GLuint w) { LOG_W_FORCE("glVertex4ui") }
EXPORT void glMultiTexCoord1uivARB(GLenum target, const GLuint *v) { LOG_W_FORCE("glMultiTexCoord1uivARB") }
EXPORT void glTexCoord4usv(const GLushort *v) { LOG_W_FORCE("glTexCoord4usv") }
EXPORT void glPolygonOffsetx(GLfixed factor, GLfixed units) { LOG_W_FORCE("glPolygonOffsetx") }
EXPORT void glClipPlanef(GLenum plane, const GLfloat *equation) { LOG_W_FORCE("glClipPlanef") }
EXPORT void glVertex3b(GLbyte x, GLbyte y, GLbyte z) { LOG_W_FORCE("glVertex3b") }
EXPORT void glMultMatrixx(const GLfixed *m) { LOG_W_FORCE("glMultMatrixx") }
EXPORT void glMultiTexCoord2bARB(GLenum target, GLbyte s, GLbyte t) { LOG_W_FORCE("glMultiTexCoord2bARB") }
EXPORT void glVertexAttrib4bv(GLuint index, const GLbyte *v) { LOG_W_FORCE("glVertexAttrib4bv") }
EXPORT void glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) { LOG_W_FORCE("glTexSubImage3DEXT") }
EXPORT void glClearNamedFramebufferuivEXT(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value) { LOG_W_FORCE("glClearNamedFramebufferuivEXT") }
EXPORT void glRasterPos2usv(const GLushort *v) { LOG_W_FORCE("glRasterPos2usv") }
EXPORT void glVertex3bv(const GLbyte *v) { LOG_W_FORCE("glVertex3bv") }
EXPORT void glFramebufferTextureLayerEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) { LOG_W_FORCE("glFramebufferTextureLayerEXT") }
EXPORT void glQueryCounterARB(GLuint id, GLenum target) { LOG_W_FORCE("glQueryCounterARB") }
EXPORT void glVertexAttrib2s(GLuint index, GLshort x, GLshort y) { LOG_W_FORCE("glVertexAttrib2s") }
EXPORT void glWindowPos2b(GLbyte x, GLbyte y) { LOG_W_FORCE("glWindowPos2b") }
EXPORT void glTexCoord2usv(const GLushort *v) { LOG_W_FORCE("glTexCoord2usv") }
EXPORT void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) { LOG_W_FORCE("glVertexAttrib4Nub") }
EXPORT void glWindowPos2us(GLushort x, GLushort y) { LOG_W_FORCE("glWindowPos2us") }
EXPORT void glProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0) { LOG_W_FORCE("glProgramUniform1fEXT") }
EXPORT void glMultiTexCoord3usARB(GLenum target, GLushort s, GLushort t, GLushort r) { LOG_W_FORCE("glMultiTexCoord3usARB") }
EXPORT void glRasterPos3ub(GLubyte x, GLubyte y, GLubyte z) { LOG_W_FORCE("glRasterPos3ub") }
EXPORT void glVertex2us(GLushort x, GLushort y) { LOG_W_FORCE("glVertex2us") }
EXPORT void glVertexAttrib4dv(GLuint index, const GLdouble *v) { LOG_W_FORCE("glVertexAttrib4dv") }
EXPORT void glMultiDrawElementsBaseVertexARB(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex) { LOG_W_FORCE("glMultiDrawElementsBaseVertexARB") }
EXPORT void glDepthRangex(GLfixed n, GLfixed f) { LOG_W_FORCE("glDepthRangex") }
EXPORT void glClearNamedFramebufferfvEXT(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value) { LOG_W_FORCE("glClearNamedFramebufferfvEXT") }
EXPORT void glClipPlanex(GLenum plane, const GLfixed *equation) { LOG_W_FORCE("glClipPlanex") }
EXPORT void glWindowPos3ubv(const GLubyte *v) { LOG_W_FORCE("glWindowPos3ubv") }
EXPORT void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params) { LOG_W_FORCE("glGetTexParameterxv") }
EXPORT void glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params) { LOG_W_FORCE("glTexParameterxv") }
EXPORT void glVertexAttrib4usv(GLuint index, const GLushort *v) { LOG_W_FORCE("glVertexAttrib4usv") }
EXPORT void glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value) { LOG_W_FORCE("glProgramUniform4ivEXT") }
EXPORT void glProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1) { LOG_W_FORCE("glProgramUniform2iEXT") }
EXPORT void glIndexui(GLuint c) { LOG_W_FORCE("glIndexui") }
EXPORT void glMultiTexCoord3usv(GLenum target, const GLushort *v) { LOG_W_FORCE("glMultiTexCoord3usv") }
EXPORT void glVertex4us(GLushort x, GLushort y, GLushort z, GLushort w) { LOG_W_FORCE("glVertex4us") }
EXPORT void glCompressedTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) { LOG_W_FORCE("glCompressedTexSubImage3DEXT") }
EXPORT void glTexCoord4us(GLushort s, GLushort t, GLushort r, GLushort q) { LOG_W_FORCE("glTexCoord4us") }
EXPORT void glVertexAttrib4Nbv(GLuint index, const GLbyte *v) { LOG_W_FORCE("glVertexAttrib4Nbv") }
EXPORT void glVertexAttrib3sv(GLuint index, const GLshort *v) { LOG_W_FORCE("glVertexAttrib3sv") }
EXPORT void glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { LOG_W_FORCE("glBlendFuncSeparateEXT") }
EXPORT void glVertex3ui(GLuint x, GLuint y, GLuint z) { LOG_W_FORCE("glVertex3ui") }
EXPORT void glVertex2usv(const GLushort *v) { LOG_W_FORCE("glVertex2usv") }
EXPORT void glVertex2ub(GLubyte x, GLubyte y) { LOG_W_FORCE("glVertex2ub") }
EXPORT void glProgramUniform1iEXT(GLuint program, GLint location, GLint v0) { LOG_W_FORCE("glProgramUniform1iEXT") }
EXPORT void glRasterPos4uiv(const GLuint *v) { LOG_W_FORCE("glRasterPos4uiv") }
EXPORT void glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value) { LOG_W_FORCE("glProgramUniform1ivEXT") }
EXPORT void glNormal3ubv(const GLubyte *v) { LOG_W_FORCE("glNormal3ubv") }
EXPORT void glTexCoord4ui(GLuint s, GLuint t, GLuint r, GLuint q) { LOG_W_FORCE("glTexCoord4ui") }
EXPORT const char* glXGetClientString(Display *dpy, int name) { LOG_W_FORCE("glXGetClientString") return nullptr; }
EXPORT void glTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) { LOG_W_FORCE("glTexImage3DEXT") }
EXPORT void glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value) { LOG_W_FORCE("glProgramUniform2fvEXT") }
EXPORT void glNormal3uiv(const GLuint *v) { LOG_W_FORCE("glNormal3uiv") }
EXPORT void glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params) { LOG_W_FORCE("glTexEnvxv") }
EXPORT void glVertexAttrib4Nsv(GLuint index, const GLshort *v) { LOG_W_FORCE("glVertexAttrib4Nsv") }
EXPORT void glVertexAttrib1d(GLuint index, GLdouble x) { LOG_W_FORCE("glVertexAttrib1d") }
EXPORT void glVertexAttrib4Nubv(GLuint index, const GLubyte *v) { LOG_W_FORCE("glVertexAttrib4Nubv") }
EXPORT void glIndexbv(const GLbyte *c) { LOG_W_FORCE("glIndexbv") }
EXPORT void glMultiTexCoord3uivARB(GLenum target, const GLuint *v) { LOG_W_FORCE("glMultiTexCoord3uivARB") }
EXPORT void glGetClipPlanef(GLenum plane, GLfloat *equation) { LOG_W_FORCE("glGetClipPlanef") }
EXPORT void glWindowPos3ub(GLubyte x, GLubyte y, GLubyte z) { LOG_W_FORCE("glWindowPos3ub") }
EXPORT void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count) { LOG_W_FORCE("glDrawArraysEXT") }
EXPORT void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed near_val, GLfixed far_val) { LOG_W_FORCE("glOrthox") }
EXPORT void glTexCoord4uiv(const GLuint *v) { LOG_W_FORCE("glTexCoord4uiv") }
EXPORT void glIndexuiv(const GLuint *c) { LOG_W_FORCE("glIndexuiv") }
EXPORT void glRasterPos2ub(GLubyte x, GLubyte y) { LOG_W_FORCE("glRasterPos2ub") }
EXPORT void glDrawTexi(GLint x, GLint y, GLint z, GLint width, GLint height) { LOG_W_FORCE("glDrawTexi") }
EXPORT void glClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { LOG_W_FORCE("glClearColorx") }
EXPORT void glBlendEquationEXT(GLenum mode) { LOG_W_FORCE("glBlendEquationEXT") }
EXPORT void glTexCoord3uiv(const GLuint *v) { LOG_W_FORCE("glTexCoord3uiv") }
EXPORT void glLoadMatrixx(const GLfixed *m) { LOG_W_FORCE("glLoadMatrixx") }
EXPORT void glWindowPos3b(GLbyte x, GLbyte y, GLbyte z) { LOG_W_FORCE("glWindowPos3b") }
EXPORT void glLineWidthx(GLfixed width) { LOG_W_FORCE("glLineWidthx") }
EXPORT void glTexCoord2ubv(const GLubyte *v) { LOG_W_FORCE("glTexCoord2ubv") }
EXPORT void glVertexAttrib4uiv(GLuint index, const GLuint *v) { LOG_W_FORCE("glVertexAttrib4uiv") }
EXPORT void glIndexb(GLbyte c) { LOG_W_FORCE("glIndexb") }
EXPORT void glWindowPos2usv(const GLushort *v) { LOG_W_FORCE("glWindowPos2usv") }
EXPORT void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz) { LOG_W_FORCE("glNormal3x") }
EXPORT void glMultiTexCoord4usARB(GLenum target, GLushort s, GLushort t, GLushort r, GLushort q) { LOG_W_FORCE("glMultiTexCoord4usARB") }
EXPORT void* glMapNamedBufferEXT(GLuint buffer, GLenum access) { LOG_W_FORCE("glMapNamedBufferEXT") return nullptr; }
EXPORT void glMultiTexCoord1ui(GLenum target, GLuint s) { LOG_W_FORCE("glMultiTexCoord1ui") }
EXPORT void glMultiTexCoord1b(GLenum target, GLbyte s) { LOG_W_FORCE("glMultiTexCoord1b") }
EXPORT void glTexCoord2ub(GLubyte s, GLubyte t) { LOG_W_FORCE("glTexCoord2ub") }
EXPORT void glTexCoord2uiv(const GLuint *v) { LOG_W_FORCE("glTexCoord2uiv") }
EXPORT void glTexCoord3bv(const GLbyte *v) { LOG_W_FORCE("glTexCoord3bv") }
EXPORT void glUniform1iARB(GLint location, GLint v0) { glUniform1i(location, v0); }
EXPORT const char* glXQueryServerString(Display *dpy, int screen, int name) { LOG_W_FORCE("glXQueryServerString") return nullptr; }
EXPORT void glIndexus(GLushort c) { LOG_W_FORCE("glIndexus") }
EXPORT void glPointSizePointerOES(GLenum type, GLsizei stride, const void *pointer) { LOG_W_FORCE("glPointSizePointerOES") }
EXPORT void glCompressedTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) { LOG_W_FORCE("glCompressedTexSubImage2DEXT") }
EXPORT void glTexCoord1ubv(const GLubyte *v) { LOG_W_FORCE("glTexCoord1ubv") }
EXPORT void glCompressedTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data) { LOG_W_FORCE("glCompressedTexImage1DEXT") }
EXPORT void glMultiTexCoord4ubv(const GLubyte *v) { LOG_W_FORCE("glMultiTexCoord4ubv") }
EXPORT void glMultiTexCoord3ubv(const GLubyte *v) { LOG_W_FORCE("glMultiTexCoord3ubv") }
EXPORT void glRasterPos4ubv(const GLubyte *v) { LOG_W_FORCE("glRasterPos4ubv") }
EXPORT void glMultiTexCoord4ub(GLenum target, GLubyte s, GLubyte t, GLubyte r, GLubyte q) { LOG_W_FORCE("glMultiTexCoord4ub") }
EXPORT void glMultiTexCoord4uivARB(GLenum target, const GLuint *v) { LOG_W_FORCE("glMultiTexCoord4uivARB") }
EXPORT void glVertex2ubv(const GLubyte *v) { LOG_W_FORCE("glVertex2ubv") }
EXPORT void glTexCoord3ubv(const GLubyte *v) { LOG_W_FORCE("glTexCoord3ubv") }
EXPORT void glGetLightxv(GLenum light, GLenum pname, GLfixed *params) { LOG_W_FORCE("glGetLightxv") }
EXPORT void glVertexAttrib4Niv(GLuint index, const GLint *v) { LOG_W_FORCE("glVertexAttrib4Niv") }
EXPORT void glSampleCoveragex(GLclampx value, GLboolean invert) { LOG_W_FORCE("glSampleCoveragex") }
EXPORT void glDrawTexf(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) { LOG_W_FORCE("glDrawTexf") }
EXPORT void glMultiTexCoord1usvARB(GLenum target, const GLushort *v) { LOG_W_FORCE("glMultiTexCoord1usvARB") }
EXPORT void glAlphaFuncx(GLenum func, GLfixed ref) { LOG_W_FORCE("glAlphaFuncx") }
EXPORT void glTexCoord1uiv(const GLuint *v) { LOG_W_FORCE("glTexCoord1uiv") }
EXPORT void glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value) { LOG_W_FORCE("glProgramUniform1fvEXT") }
EXPORT void glMultiTexCoord1bv(GLenum target, const GLbyte *v) { LOG_W_FORCE("glMultiTexCoord1bv") }
EXPORT void glNormal3ui(GLuint nx, GLuint ny, GLuint nz) { LOG_W_FORCE("glNormal3ui") }
EXPORT void glIndexusv(const GLushort *c) { LOG_W_FORCE("glIndexusv") }
EXPORT void glVertex4bv(const GLbyte *v) { LOG_W_FORCE("glVertex4bv") }
EXPORT void glMultiTexCoord4usvARB(GLenum target, const GLushort *v) { LOG_W_FORCE("glMultiTexCoord4usvARB") }
EXPORT void glTexCoord1bv(const GLbyte *v) { LOG_W_FORCE("glTexCoord1bv") }
EXPORT void glTexCoord1b(GLbyte s) { LOG_W_FORCE("glTexCoord1b") }
EXPORT void glNormal3ub(GLubyte nx, GLubyte ny, GLubyte nz) { LOG_W_FORCE("glNormal3ub") }
EXPORT void glProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1) { LOG_W_FORCE("glProgramUniform2fEXT") }
EXPORT void glFogfEXT(GLenum pname, GLfloat param) { LOG_W_FORCE("glFogfEXT") }
EXPORT void glMultiTexCoord3bARB(GLenum target, GLbyte s, GLbyte t, GLbyte r) { LOG_W_FORCE("glMultiTexCoord3bARB") }
EXPORT void glGetFixedv(GLenum pname, GLfixed *params) { LOG_W_FORCE("glGetFixedv") }
EXPORT void glVertex2uiv(const GLuint *v) { LOG_W_FORCE("glVertex2uiv") }
EXPORT void glWindowPos3ui(GLuint x, GLuint y, GLuint z) { LOG_W_FORCE("glWindowPos3ui") }
EXPORT void glWindowPos2uiv(const GLuint *v) { LOG_W_FORCE("glWindowPos2uiv") }
EXPORT void glVertexAttrib4Nusv(GLuint index, const GLushort *v) { LOG_W_FORCE("glVertexAttrib4Nusv") }
EXPORT void glTexCoord1us(GLushort s) { LOG_W_FORCE("glTexCoord1us") }
EXPORT void glVertex2b(GLbyte x, GLbyte y) { LOG_W_FORCE("glVertex2b") }
EXPORT void glClearDepthx(GLfixed depth) { LOG_W_FORCE("glClearDepthx") }
EXPORT void glWindowPos2ub(GLubyte x, GLubyte y) { LOG_W_FORCE("glWindowPos2ub") }
EXPORT void glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value) { LOG_W_FORCE("glProgramUniform2ivEXT") }
EXPORT void glGetProgramivARB(GLenum target, GLenum pname, GLint *params) { LOG_W_FORCE("glGetProgramivARB") }
EXPORT void glVertex4ub(GLubyte x, GLubyte y, GLubyte z, GLubyte w) { LOG_W_FORCE("glVertex4ub") }
EXPORT void glTexCoord3us(GLushort s, GLushort t, GLushort r) { LOG_W_FORCE("glTexCoord3us") }
EXPORT void glRasterPos2us(GLushort x, GLushort y) { LOG_W_FORCE("glRasterPos2us") }
EXPORT void glPointParameterxv(GLenum pname, const GLfixed *params) { LOG_W_FORCE("glPointParameterxv") }
EXPORT void glGetCompressedTexImageEXT(GLenum target, GLint lod, void *img) { LOG_W_FORCE("glGetCompressedTexImageEXT") }
EXPORT void glMultiTexCoord3ubvARB(GLenum target, const GLubyte *v) { LOG_W_FORCE("glMultiTexCoord3ubvARB") }
EXPORT void glFrustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) { LOG_W_FORCE("glFrustumf") }
EXPORT void glMaterialxv(GLenum face, GLenum pname, const GLfixed *param) { LOG_W_FORCE("glMaterialxv") }
EXPORT void glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value) { LOG_W_FORCE("glProgramUniform4fvEXT") }
EXPORT void glProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) { LOG_W_FORCE("glProgramUniform3fEXT") }
EXPORT void glScalex(GLfixed x, GLfixed y, GLfixed z) { LOG_W_FORCE("glScalex") }
EXPORT void glTexCoord2bv(const GLbyte *v) { LOG_W_FORCE("glTexCoord2bv") }
EXPORT void glRasterPos2b(GLbyte x, GLbyte y) { LOG_W_FORCE("glRasterPos2b") }
EXPORT void glTranslatex(GLfixed x, GLfixed y, GLfixed z) { LOG_W_FORCE("glTranslatex") }
#ifdef __cplusplus
}
#endif

61
src/main/cpp/gl/program.cpp
View File

@ -131,3 +131,64 @@ void glGetProgramiv(GLuint program, GLenum pname, GLint *params) {
}
CHECK_GL_ERROR
}
extern "C" {
EXPORT void glGetActiveUniformName(GLuint program,
GLuint uniformIndex,
GLsizei bufSize,
GLsizei* length,
char* uniformName)
{
GLint uniformSize;
GLenum uniformType;
char rawName[bufSize];
glGetActiveUniform(program, uniformIndex, bufSize, length,
&uniformSize, &uniformType, rawName);
char* bracketPos = strchr(rawName, '[');
if (bracketPos != nullptr) {
*bracketPos = '\0';
}
strncpy(uniformName, rawName, bufSize);
if (length != nullptr && *length > bufSize) {
*length = (GLsizei)strlen(rawName);
}
}
EXPORT void glGetActiveUniformNameARB(GLuint program,
GLuint uniformIndex,
GLsizei bufSize,
GLsizei* length,
char* uniformName) __attribute__((alias("glGetActiveUniformName")));
EXPORT GLint glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const char *name) {
if (program == 0 || glIsProgram(program) == GL_FALSE) {
return -1;
}
GLuint resourceIndex = glGetProgramResourceIndex(program, programInterface, name);
if (resourceIndex == GL_INVALID_INDEX) {
return -1;
}
switch (programInterface) {
case GL_PROGRAM_OUTPUT: {
GLint index = 0;
GLenum props[] = { GL_INDEX };
GLsizei length;
glGetProgramResourceiv(program, programInterface, resourceIndex,
1, props, 1, &length, &index);
return index;
}
case GL_UNIFORM: {
return -1;
}
default: {
return -1;
}
}
}
EXPORT void glGetProgramResourceLocationIndexARB(GLuint program, GLenum programInterface, const char *name) __attribute__((alias("glGetProgramResourceLocationIndex")));
}

91
src/main/cpp/gl/shader.cpp
View File

@ -113,11 +113,20 @@ void glGetShaderiv(GLuint shader, GLenum pname, GLint *params) {
extern "C" {
EXPORT void glDeleteObjectARB(GLhandleARB obj) {
glDeleteProgram(obj);
if (glIsProgram(obj)) {
glDeleteProgram(obj);
} else {
glDeleteShader(obj);
}
}
EXPORT GLhandleARB glGetHandleARB(GLenum pname) {
return glGetHandleARB(pname);
if (pname == GL_PROGRAM_OBJECT_ARB) {
GLint currentProg;
glGetIntegerv(GL_CURRENT_PROGRAM, &currentProg);
return (GLhandleARB)currentProg;
}
return 0;
}
EXPORT void glDetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj) {
@ -149,4 +158,82 @@ EXPORT void glUseProgramObjectARB(GLhandleARB programObj) {
glUseProgram(programObj);
}
EXPORT void glGetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat *params) {
GLint iparam;
if (glIsShader(obj)) {
glGetShaderiv(obj, pname, &iparam);
} else {
glGetProgramiv(obj, pname, &iparam);
}
if (params) {
params[0] = (GLfloat)iparam;
}
}
EXPORT void glGetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint *params) {
if (glIsShader(obj)) {
glGetShaderiv(obj, pname, params);
} else {
glGetProgramiv(obj, pname, params);
}
}
//EXPORT void glVertexAttrib1fARB(GLuint index, GLfloat v0) { glVertexAttrib1f(index, v0); }
EXPORT void glVertexAttrib1sARB(GLuint index, GLshort v0) { glVertexAttrib1f(index, v0); }
EXPORT void glVertexAttrib1dARB(GLuint index, GLdouble v0) { glVertexAttrib1f(index, v0); }
//EXPORT void glVertexAttrib2fARB(GLuint index, GLfloat v0, GLfloat v1) { glVertexAttrib2f(index, v0, v1); }
EXPORT void glVertexAttrib2sARB(GLuint index, GLshort v0, GLshort v1) { glVertexAttrib2f(index, v0, v1); }
EXPORT void glVertexAttrib2dARB(GLuint index, GLdouble v0, GLdouble v1) { glVertexAttrib2f(index, v0, v1); }
//EXPORT void glVertexAttrib3fARB(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2) { glVertexAttrib3f(index, v0, v1, v2); }
EXPORT void glVertexAttrib3sARB(GLuint index, GLshort v0, GLshort v1, GLshort v2) { glVertexAttrib3f(index, v0, v1, v2); }
EXPORT void glVertexAttrib3dARB(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2) { glVertexAttrib3f(index, v0, v1, v2); }
//EXPORT void glVertexAttrib4fARB(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { glVertexAttrib4f(index, v0, v1, v2, v3); }
EXPORT void glVertexAttrib4sARB(GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3) { glVertexAttrib4f(index, v0, v1, v2, v3); }
EXPORT void glVertexAttrib4dARB(GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) { glVertexAttrib4f(index, v0, v1, v2, v3); }
//EXPORT void glVertexAttrib1fvARB(GLuint index, const GLfloat *v) { glVertexAttrib1fv(index, v); }
EXPORT void glVertexAttrib1svARB(GLuint index, const GLshort *v) { glVertexAttrib1fv(index, (GLfloat*)v); }
EXPORT void glVertexAttrib1dvARB(GLuint index, const GLdouble *v) { glVertexAttrib1fv(index, (GLfloat*)v); }
//EXPORT void glVertexAttrib2fvARB(GLuint index, const GLfloat *v) { glVertexAttrib2fv(index, v); }
EXPORT void glVertexAttrib2svARB(GLuint index, const GLshort *v) { glVertexAttrib2fv(index, (GLfloat*)v); }
EXPORT void glVertexAttrib2dvARB(GLuint index, const GLdouble *v) { glVertexAttrib2fv(index, (GLfloat*)v); }
//EXPORT void glVertexAttrib3fvARB(GLuint index, const GLfloat *v) { glVertexAttrib3fv(index, v); }
EXPORT void glVertexAttrib3svARB(GLuint index, const GLshort *v) { glVertexAttrib3fv(index, (GLfloat*)v); }
EXPORT void glVertexAttrib3dvARB(GLuint index, const GLdouble *v) { glVertexAttrib3fv(index, (GLfloat*)v); }
//EXPORT void glVertexAttrib4fvARB(GLuint index, const GLfloat *v) { glVertexAttrib4fv(index, v); }
EXPORT void glVertexAttrib4svARB(GLuint index, const GLshort *v) { glVertexAttrib4fv(index, (GLfloat*)v); }
EXPORT void glVertexAttrib4dvARB(GLuint index, const GLdouble *v) { glVertexAttrib4fv(index, (GLfloat*)v); }
EXPORT void glVertexAttrib4ivARB(GLuint index, const GLint *v) { glVertexAttrib4fv(index, (GLfloat*)v); }
EXPORT void glVertexAttrib4bvARB(GLuint index, const GLbyte *v) { glVertexAttrib4fv(index, (GLfloat*)v); }
EXPORT void glVertexAttrib4ubvARB(GLuint index, const GLubyte *v) { glVertexAttrib4fv(index, (GLfloat*)v); }
EXPORT void glVertexAttrib4usvARB(GLuint index, const GLushort *v) { glVertexAttrib4fv(index, (GLfloat*)v); }
EXPORT void glVertexAttrib4uivARB(GLuint index, const GLuint *v) { glVertexAttrib4fv(index, (GLfloat*)v); }
//EXPORT void glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) {
// glVertexAttribPointer(index, size, type, normalized, stride, pointer);
//}
//EXPORT void glEnableVertexAttribArrayARB(GLuint index) { glEnableVertexAttribArray(index); }
//EXPORT void glDisableVertexAttribArrayARB(GLuint index) { glDisableVertexAttribArray(index); }
//EXPORT void glBindAttribLocationARB(GLhandleARB programObj, GLuint index, const GLcharARB *name) {
// glBindAttribLocation(programObj, index, name);
//}
//EXPORT void glGetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength,
// GLsizei *length, GLint *size, GLenum *type, GLcharARB *name) {
// glGetActiveAttrib(programObj, index, maxLength, length, size, type, name);
//}
//EXPORT GLint glGetAttribLocationARB(GLhandleARB programObj, const GLcharARB *name) {
// return glGetAttribLocation(programObj, name);
//}
EXPORT void glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params) { glGetVertexAttribfv(index, pname,(GLfloat*) params); }
//EXPORT void glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params) { glGetVertexAttribfv(index, pname, params); }
//EXPORT void glGetVertexAttribivARB(GLuint index, GLenum pname, GLint *params) { glGetVertexAttribiv(index, pname, params); }
//EXPORT void glGetVertexAttribPointervARB(GLuint index, GLenum pname, void **pointer) {
// glGetVertexAttribPointerv(index, pname, pointer);
//}
}

4
src/main/cpp/gles/loader.h
View File

@ -98,14 +98,14 @@ static name##_PTR egl_##name = NULL; \
static void *GL4ES_FUNC_sym = dlsym(RTLD_DEFAULT, "gl4es_" #name); \
if (GL4ES_FUNC_sym) { \
((GL4ES_##name##_PTR)GL4ES_FUNC_sym)(__VA_ARGS__); \
}
} else {LOG_I("%s not found in gl4es", #name)}
#define CALL_GL4ES_FUNC_RETURN(type, name, ...) \
type GL4ES_RETURN_VALUE; \
static void *GL4ES_FUNC_sym = dlsym(RTLD_DEFAULT, "gl4es_" #name); \
if (GL4ES_FUNC_sym) { \
GL4ES_RETURN_VALUE = (type)((GL4ES_##name##_PTR)GL4ES_FUNC_sym)(__VA_ARGS__); \
}
} else {LOG_I("%s not found in gl4es", #name)}
#define NATIVE_FUNCTION_HEAD(type,name,...) \
extern "C" GLAPI GLAPIENTRY type name##ARB(__VA_ARGS__) __attribute__((alias(#name))); \