diff options
Diffstat (limited to 'src/opengl/bind')
39 files changed, 5390 insertions, 0 deletions
diff --git a/src/opengl/bind/a b/src/opengl/bind/a new file mode 100644 index 0000000..b414962 --- /dev/null +++ b/src/opengl/bind/a @@ -0,0 +1,3 @@ +void glActiveShaderProgram( GLuint pipeline, GLuint program); +void glActiveTexture( GLenum texture); +void glAttachShader( GLuint program, GLuint shader); diff --git a/src/opengl/bind/a.bind b/src/opengl/bind/a.bind new file mode 100644 index 0000000..41eef56 --- /dev/null +++ b/src/opengl/bind/a.bind @@ -0,0 +1,26 @@ +int glActiveShaderProgram_bind(lua_State *L) +{ + GLuint pipeline = luaL_checkinteger(L, 1); + GLuint program = luaL_checkinteger(L, 2); + glActiveShaderProgram(pipeline, program); + return 0; +} + + +int glActiveTexture_bind(lua_State *L) +{ + GLenum texture = luaL_checkinteger(L, 1); + glActiveTexture(texture); + return 0; +} + + +int glAttachShader_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint shader = luaL_checkinteger(L, 2); + glAttachShader(program, shader); + return 0; +} + + diff --git a/src/opengl/bind/b b/src/opengl/bind/b new file mode 100644 index 0000000..e95cea1 --- /dev/null +++ b/src/opengl/bind/b @@ -0,0 +1,35 @@ +void glBeginConditionalRender( GLuint id, GLenum mode); +void glBeginQuery( GLenum target, GLuint id); +void glBeginQuery( GLenum target, GLuint id); +void glBeginTransformFeedback( GLenum primitiveMode); +void glBindAttribLocation( GLuint program, GLuint index, const GLchar *name); +void glBindBuffer( GLenum target, GLuint buffer); +void glBindBufferBase( GLenum target, GLuint index, GLuint buffer); +void glBindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void glBindFragDataLocation( GLuint program, GLuint colorNumber, const char * name); +void glBindFragDataLocationIndexed( GLuint program, GLuint colorNumber, GLuint index, const char *name); +void glBindFramebuffer( GLenum target, GLuint framebuffer); +void glBindImageTexture( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +void glBindProgramPipeline( GLuint pipeline); +void glBindRenderbuffer( GLenum target, GLuint renderbuffer); +void glBindSampler( GLuint unit, GLuint sampler); +void glBindTexture( GLenum target, GLuint texture); +void glBindTextureUnit( GLuint unit, GLuint texture); +void glBindTransformFeedback( GLenum target, GLuint id); +void glBindVertexArray( GLuint array); +void glBindVertexBuffer( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); +void glBlendColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void glBlendEquation( GLenum mode); + +void glBlendEquationi( GLuint buf, GLenum mode); +void glBlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha); +void glBlendEquationSeparatei( GLuint buf, GLenum modeRGB, GLenum modeAlpha); +void glBlendFunc( GLenum sfactor, GLenum dfactor); +void glBlendFunci( GLuint buf, GLenum sfactor, GLenum dfactor); +void glBlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void glBlendFuncSeparatei( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void glBlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void glBlitNamedFramebuffer( GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void glBufferData( GLenum target, GLsizeiptr size, const void * data, GLenum usage); +void glBufferStorage( GLenum target, GLsizeiptr size, const void * data, GLbitfield flags); +void glBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const void * data); diff --git a/src/opengl/bind/b.bind b/src/opengl/bind/b.bind new file mode 100644 index 0000000..ee2cfa0 --- /dev/null +++ b/src/opengl/bind/b.bind @@ -0,0 +1,350 @@ +int glBeginConditionalRender_bind(lua_State *L) +{ + GLuint id = luaL_checkinteger(L, 1); + GLenum mode = luaL_checkinteger(L, 2); + glBeginConditionalRender(id, mode); + return 0; +} + + +int glBeginQuery_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint id = luaL_checkinteger(L, 2); + glBeginQuery(target, id); + return 0; +} + + +int glBeginQuery_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint id = luaL_checkinteger(L, 2); + glBeginQuery(target, id); + return 0; +} + + +int glBeginTransformFeedback_bind(lua_State *L) +{ + GLenum primitiveMode = luaL_checkinteger(L, 1); + glBeginTransformFeedback(primitiveMode); + return 0; +} + + +int glBindAttribLocation_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + const GLchar * name = luaL_checkstring(L, 3); + glBindAttribLocation(program, index, name); + return 0; +} + + +int glBindBuffer_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint buffer = luaL_checkinteger(L, 2); + glBindBuffer(target, buffer); + return 0; +} + + +int glBindBufferBase_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLuint buffer = luaL_checkinteger(L, 3); + glBindBufferBase(target, index, buffer); + return 0; +} + + +int glBindBufferRange_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLuint buffer = luaL_checkinteger(L, 3); + GLintptr offset = luaL_checkinteger(L, 4); + GLsizeiptr size = luaL_checkinteger(L, 5); + glBindBufferRange(target, index, buffer, offset, size); + return 0; +} + + +int glBindFragDataLocation_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint colorNumber = luaL_checkinteger(L, 2); + const char * name = luaL_checkstring(L, 3); + glBindFragDataLocation(program, colorNumber, name); + return 0; +} + + +int glBindFragDataLocationIndexed_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint colorNumber = luaL_checkinteger(L, 2); + GLuint index = luaL_checkinteger(L, 3); + const char * name = luaL_checkstring(L, 4); + glBindFragDataLocationIndexed(program, colorNumber, index, name); + return 0; +} + + +int glBindFramebuffer_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint framebuffer = luaL_checkinteger(L, 2); + glBindFramebuffer(target, framebuffer); + return 0; +} + + +int glBindImageTexture_bind(lua_State *L) +{ + GLuint unit = luaL_checkinteger(L, 1); + GLuint texture = luaL_checkinteger(L, 2); + GLint level = luaL_checkinteger(L, 3); + GLboolean layered = get: GLboolean + GLint layer = luaL_checkinteger(L, 5); + GLenum access = luaL_checkinteger(L, 6); + GLenum format = luaL_checkinteger(L, 7); + glBindImageTexture(unit, texture, level, layered, layer, access, format); + return 0; +} + + +int glBindProgramPipeline_bind(lua_State *L) +{ + GLuint pipeline = luaL_checkinteger(L, 1); + glBindProgramPipeline(pipeline); + return 0; +} + + +int glBindRenderbuffer_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint renderbuffer = luaL_checkinteger(L, 2); + glBindRenderbuffer(target, renderbuffer); + return 0; +} + + +int glBindSampler_bind(lua_State *L) +{ + GLuint unit = luaL_checkinteger(L, 1); + GLuint sampler = luaL_checkinteger(L, 2); + glBindSampler(unit, sampler); + return 0; +} + + +int glBindTexture_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint texture = luaL_checkinteger(L, 2); + glBindTexture(target, texture); + return 0; +} + + +int glBindTextureUnit_bind(lua_State *L) +{ + GLuint unit = luaL_checkinteger(L, 1); + GLuint texture = luaL_checkinteger(L, 2); + glBindTextureUnit(unit, texture); + return 0; +} + + +int glBindTransformFeedback_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint id = luaL_checkinteger(L, 2); + glBindTransformFeedback(target, id); + return 0; +} + + +int glBindVertexArray_bind(lua_State *L) +{ + GLuint array = luaL_checkinteger(L, 1); + glBindVertexArray(array); + return 0; +} + + +int glBindVertexBuffer_bind(lua_State *L) +{ + GLuint bindingindex = luaL_checkinteger(L, 1); + GLuint buffer = luaL_checkinteger(L, 2); + GLintptr offset = luaL_checkinteger(L, 3); + GLsizei stride = luaL_checkinteger(L, 4); + glBindVertexBuffer(bindingindex, buffer, offset, stride); + return 0; +} + + +int glBlendColor_bind(lua_State *L) +{ + GLfloat red = luaL_checknumber(L, 1); + GLfloat green = luaL_checknumber(L, 2); + GLfloat blue = luaL_checknumber(L, 3); + GLfloat alpha = luaL_checknumber(L, 4); + glBlendColor(red, green, blue, alpha); + return 0; +} + + +int glBlendEquation_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + glBlendEquation(mode); + return 0; +} + + +int glBlendEquationi_bind(lua_State *L) +{ + GLuint buf = luaL_checkinteger(L, 1); + GLenum mode = luaL_checkinteger(L, 2); + glBlendEquationi(buf, mode); + return 0; +} + + +int glBlendEquationSeparate_bind(lua_State *L) +{ + GLenum modeRGB = luaL_checkinteger(L, 1); + GLenum modeAlpha = luaL_checkinteger(L, 2); + glBlendEquationSeparate(modeRGB, modeAlpha); + return 0; +} + + +int glBlendEquationSeparatei_bind(lua_State *L) +{ + GLuint buf = luaL_checkinteger(L, 1); + GLenum modeRGB = luaL_checkinteger(L, 2); + GLenum modeAlpha = luaL_checkinteger(L, 3); + glBlendEquationSeparatei(buf, modeRGB, modeAlpha); + return 0; +} + + +int glBlendFunc_bind(lua_State *L) +{ + GLenum sfactor = luaL_checkinteger(L, 1); + GLenum dfactor = luaL_checkinteger(L, 2); + glBlendFunc(sfactor, dfactor); + return 0; +} + + +int glBlendFunci_bind(lua_State *L) +{ + GLuint buf = luaL_checkinteger(L, 1); + GLenum sfactor = luaL_checkinteger(L, 2); + GLenum dfactor = luaL_checkinteger(L, 3); + glBlendFunci(buf, sfactor, dfactor); + return 0; +} + + +int glBlendFuncSeparate_bind(lua_State *L) +{ + GLenum srcRGB = luaL_checkinteger(L, 1); + GLenum dstRGB = luaL_checkinteger(L, 2); + GLenum srcAlpha = luaL_checkinteger(L, 3); + GLenum dstAlpha = luaL_checkinteger(L, 4); + glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); + return 0; +} + + +int glBlendFuncSeparatei_bind(lua_State *L) +{ + GLuint buf = luaL_checkinteger(L, 1); + GLenum srcRGB = luaL_checkinteger(L, 2); + GLenum dstRGB = luaL_checkinteger(L, 3); + GLenum srcAlpha = luaL_checkinteger(L, 4); + GLenum dstAlpha = luaL_checkinteger(L, 5); + glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); + return 0; +} + + +int glBlitFramebuffer_bind(lua_State *L) +{ + GLint srcX0 = luaL_checkinteger(L, 1); + GLint srcY0 = luaL_checkinteger(L, 2); + GLint srcX1 = luaL_checkinteger(L, 3); + GLint srcY1 = luaL_checkinteger(L, 4); + GLint dstX0 = luaL_checkinteger(L, 5); + GLint dstY0 = luaL_checkinteger(L, 6); + GLint dstX1 = luaL_checkinteger(L, 7); + GLint dstY1 = luaL_checkinteger(L, 8); + GLbitfield mask = luaL_checkinteger(L, 9); + GLenum filter = luaL_checkinteger(L, 10); + glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); + return 0; +} + + +int glBlitNamedFramebuffer_bind(lua_State *L) +{ + GLuint readFramebuffer = luaL_checkinteger(L, 1); + GLuint drawFramebuffer = luaL_checkinteger(L, 2); + GLint srcX0 = luaL_checkinteger(L, 3); + GLint srcY0 = luaL_checkinteger(L, 4); + GLint srcX1 = luaL_checkinteger(L, 5); + GLint srcY1 = luaL_checkinteger(L, 6); + GLint dstX0 = luaL_checkinteger(L, 7); + GLint dstY0 = luaL_checkinteger(L, 8); + GLint dstX1 = luaL_checkinteger(L, 9); + GLint dstY1 = luaL_checkinteger(L, 10); + GLbitfield mask = luaL_checkinteger(L, 11); + GLenum filter = luaL_checkinteger(L, 12); + glBlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); + return 0; +} + + +int glBufferData_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLsizeiptr size = luaL_checkinteger(L, 2); + const void * data = get: const void * + GLenum usage = luaL_checkinteger(L, 4); + glBufferData(target, size, data, usage); + return 0; +} + + +int glBufferStorage_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLsizeiptr size = luaL_checkinteger(L, 2); + const void * data = get: const void * + GLbitfield flags = luaL_checkinteger(L, 4); + glBufferStorage(target, size, data, flags); + return 0; +} + + +int glBufferSubData_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLintptr offset = luaL_checkinteger(L, 2); + GLsizeiptr size = luaL_checkinteger(L, 3); + const void * data = get: const void * + glBufferSubData(target, offset, size, data); + return 0; +} + + diff --git a/src/opengl/bind/c b/src/opengl/bind/c new file mode 100644 index 0000000..a53aa8f --- /dev/null +++ b/src/opengl/bind/c @@ -0,0 +1,31 @@ +GLenum glCheckFramebufferStatus( GLenum target); +GLenum glCheckNamedFramebufferStatus( GLuint framebuffer, GLenum target); +void glClampColor( GLenum target, GLenum clamp); +void glClear( GLbitfield mask); +void glClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint * value); +void glClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint * value); +void glClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat * value); +void glClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void glClearStencil( GLint s); +GLenum glClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout); +void glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void glColorMaski( GLuint buf, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void glCompileShader( GLuint shader); +void glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data); +void glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data); +void glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data); +void glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data); +void glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data); +void glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data); +void glCopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void glCopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +void glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void glCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLuint glCreateProgram( void); +GLuint glCreateShader( GLenum shaderType); +GLuint glCreateShaderProgramv( GLenum type, GLsizei count, const char **strings); +void glCullFace( GLenum mode); + diff --git a/src/opengl/bind/c.bind b/src/opengl/bind/c.bind new file mode 100644 index 0000000..1cf6e80 --- /dev/null +++ b/src/opengl/bind/c.bind @@ -0,0 +1,354 @@ +int glCheckFramebufferStatus_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum bind_result = glCheckFramebufferStatus(target); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glCheckNamedFramebufferStatus_bind(lua_State *L) +{ + GLuint framebuffer = luaL_checkinteger(L, 1); + GLenum target = luaL_checkinteger(L, 2); + GLenum bind_result = glCheckNamedFramebufferStatus(framebuffer, target); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glClampColor_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum clamp = luaL_checkinteger(L, 2); + glClampColor(target, clamp); + return 0; +} + + +int glClear_bind(lua_State *L) +{ + GLbitfield mask = luaL_checkinteger(L, 1); + glClear(mask); + return 0; +} + + +int glClearBufferiv_bind(lua_State *L) +{ + GLenum buffer = luaL_checkinteger(L, 1); + GLint drawbuffer = luaL_checkinteger(L, 2); + const GLint * value = get: const GLint * + glClearBufferiv(buffer, drawbuffer, value); + return 0; +} + + +int glClearBufferuiv_bind(lua_State *L) +{ + GLenum buffer = luaL_checkinteger(L, 1); + GLint drawbuffer = luaL_checkinteger(L, 2); + const GLuint * value = get: const GLuint * + glClearBufferuiv(buffer, drawbuffer, value); + return 0; +} + + +int glClearBufferfv_bind(lua_State *L) +{ + GLenum buffer = luaL_checkinteger(L, 1); + GLint drawbuffer = luaL_checkinteger(L, 2); + const GLfloat * value = get: const GLfloat * + glClearBufferfv(buffer, drawbuffer, value); + return 0; +} + + +int glClearBufferfi_bind(lua_State *L) +{ + GLenum buffer = luaL_checkinteger(L, 1); + GLint drawbuffer = luaL_checkinteger(L, 2); + GLfloat depth = luaL_checknumber(L, 3); + GLint stencil = luaL_checkinteger(L, 4); + glClearBufferfi(buffer, drawbuffer, depth, stencil); + return 0; +} + + +int glClearStencil_bind(lua_State *L) +{ + GLint s = luaL_checkinteger(L, 1); + glClearStencil(s); + return 0; +} + + +int glClientWaitSync_bind(lua_State *L) +{ + GLsync sync = luaL_checkinteger(L, 1); + GLbitfield flags = luaL_checkinteger(L, 2); + GLuint64 timeout = luaL_checkinteger(L, 3); + GLenum bind_result = glClientWaitSync(sync, flags, timeout); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glColorMask_bind(lua_State *L) +{ + GLboolean red = get: GLboolean + GLboolean green = get: GLboolean + GLboolean blue = get: GLboolean + GLboolean alpha = get: GLboolean + glColorMask(red, green, blue, alpha); + return 0; +} + + +int glColorMaski_bind(lua_State *L) +{ + GLuint buf = luaL_checkinteger(L, 1); + GLboolean red = get: GLboolean + GLboolean green = get: GLboolean + GLboolean blue = get: GLboolean + GLboolean alpha = get: GLboolean + glColorMaski(buf, red, green, blue, alpha); + return 0; +} + + +int glCompileShader_bind(lua_State *L) +{ + GLuint shader = luaL_checkinteger(L, 1); + glCompileShader(shader); + return 0; +} + + +int glCompressedTexImage1D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLenum internalformat = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLint border = luaL_checkinteger(L, 5); + GLsizei imageSize = luaL_checkinteger(L, 6); + const void * data = get: const void * + glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data); + return 0; +} + + +int glCompressedTexImage2D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLenum internalformat = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLsizei height = luaL_checkinteger(L, 5); + GLint border = luaL_checkinteger(L, 6); + GLsizei imageSize = luaL_checkinteger(L, 7); + const void * data = get: const void * + glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); + return 0; +} + + +int glCompressedTexImage3D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLenum internalformat = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLsizei height = luaL_checkinteger(L, 5); + GLsizei depth = luaL_checkinteger(L, 6); + GLint border = luaL_checkinteger(L, 7); + GLsizei imageSize = luaL_checkinteger(L, 8); + const void * data = get: const void * + glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data); + return 0; +} + + +int glCompressedTexSubImage1D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint xoffset = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLenum format = luaL_checkinteger(L, 5); + GLsizei imageSize = luaL_checkinteger(L, 6); + const void * data = get: const void * + glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); + return 0; +} + + +int glCompressedTexSubImage2D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint xoffset = luaL_checkinteger(L, 3); + GLint yoffset = luaL_checkinteger(L, 4); + GLsizei width = luaL_checkinteger(L, 5); + GLsizei height = luaL_checkinteger(L, 6); + GLenum format = luaL_checkinteger(L, 7); + GLsizei imageSize = luaL_checkinteger(L, 8); + const void * data = get: const void * + glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); + return 0; +} + + +int glCompressedTexSubImage3D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint xoffset = luaL_checkinteger(L, 3); + GLint yoffset = luaL_checkinteger(L, 4); + GLint zoffset = luaL_checkinteger(L, 5); + GLsizei width = luaL_checkinteger(L, 6); + GLsizei height = luaL_checkinteger(L, 7); + GLsizei depth = luaL_checkinteger(L, 8); + GLenum format = luaL_checkinteger(L, 9); + GLsizei imageSize = luaL_checkinteger(L, 10); + const void * data = get: const void * + glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); + return 0; +} + + +int glCopyBufferSubData_bind(lua_State *L) +{ + GLenum readTarget = luaL_checkinteger(L, 1); + GLenum writeTarget = luaL_checkinteger(L, 2); + GLintptr readOffset = luaL_checkinteger(L, 3); + GLintptr writeOffset = luaL_checkinteger(L, 4); + GLsizeiptr size = luaL_checkinteger(L, 5); + glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); + return 0; +} + + +int glCopyBufferSubData_bind(lua_State *L) +{ + GLenum readTarget = luaL_checkinteger(L, 1); + GLenum writeTarget = luaL_checkinteger(L, 2); + GLintptr readOffset = luaL_checkinteger(L, 3); + GLintptr writeOffset = luaL_checkinteger(L, 4); + GLsizeiptr size = luaL_checkinteger(L, 5); + glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); + return 0; +} + + +int glCopyTexImage1D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLenum internalformat = luaL_checkinteger(L, 3); + GLint x = luaL_checkinteger(L, 4); + GLint y = luaL_checkinteger(L, 5); + GLsizei width = luaL_checkinteger(L, 6); + GLint border = luaL_checkinteger(L, 7); + glCopyTexImage1D(target, level, internalformat, x, y, width, border); + return 0; +} + + +int glCopyTexImage2D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLenum internalformat = luaL_checkinteger(L, 3); + GLint x = luaL_checkinteger(L, 4); + GLint y = luaL_checkinteger(L, 5); + GLsizei width = luaL_checkinteger(L, 6); + GLsizei height = luaL_checkinteger(L, 7); + GLint border = luaL_checkinteger(L, 8); + glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); + return 0; +} + + +int glCopyTexSubImage1D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint xoffset = luaL_checkinteger(L, 3); + GLint x = luaL_checkinteger(L, 4); + GLint y = luaL_checkinteger(L, 5); + GLsizei width = luaL_checkinteger(L, 6); + glCopyTexSubImage1D(target, level, xoffset, x, y, width); + return 0; +} + + +int glCopyTexSubImage2D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint xoffset = luaL_checkinteger(L, 3); + GLint yoffset = luaL_checkinteger(L, 4); + GLint x = luaL_checkinteger(L, 5); + GLint y = luaL_checkinteger(L, 6); + GLsizei width = luaL_checkinteger(L, 7); + GLsizei height = luaL_checkinteger(L, 8); + glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); + return 0; +} + + +int glCopyTexSubImage3D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint xoffset = luaL_checkinteger(L, 3); + GLint yoffset = luaL_checkinteger(L, 4); + GLint zoffset = luaL_checkinteger(L, 5); + GLint x = luaL_checkinteger(L, 6); + GLint y = luaL_checkinteger(L, 7); + GLsizei width = luaL_checkinteger(L, 8); + GLsizei height = luaL_checkinteger(L, 9); + glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); + return 0; +} + + +int glCreateProgram_bind(lua_State *L) +{ + void = get: + GLuint bind_result = glCreateProgram(void); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glCreateShader_bind(lua_State *L) +{ + GLenum shaderType = luaL_checkinteger(L, 1); + GLuint bind_result = glCreateShader(shaderType); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glCreateShaderProgramv_bind(lua_State *L) +{ + GLenum type = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const char ** strings = get: const char ** + GLuint bind_result = glCreateShaderProgramv(type, count, strings); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glCullFace_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + glCullFace(mode); + return 0; +} + + diff --git a/src/opengl/bind/d b/src/opengl/bind/d new file mode 100644 index 0000000..1437c2e --- /dev/null +++ b/src/opengl/bind/d @@ -0,0 +1,36 @@ +void glDeleteBuffers( GLsizei n, const GLuint * buffers); +void glDeleteFramebuffers( GLsizei n, GLuint *framebuffers); +void glDeleteProgram( GLuint program); +void glDeleteProgramPipelines( GLsizei n, const GLuint *pipelines); +void glDeleteQueries( GLsizei n, const GLuint * ids); +void glDeleteRenderbuffers( GLsizei n, GLuint *renderbuffers); +void glDeleteSamplers( GLsizei n, const GLuint * samplers); +void glDeleteShader( GLuint shader); +void glDeleteSync( GLsync sync); +void glDeleteTextures( GLsizei n, const GLuint * textures); +void glDeleteTransformFeedbacks( GLsizei n, const GLuint *ids); +void glDeleteVertexArrays( GLsizei n, const GLuint *arrays); +void glDepthFunc( GLenum func); +void glDepthMask( GLboolean flag); +void glDepthRange( GLdouble nearVal, GLdouble farVal); +void glDepthRangef( GLfloat nearVal, GLfloat farVal); +void glDepthRangeArrayv( GLuint first, GLsizei count, const GLdouble *v); +void glDepthRangeIndexed( GLuint index, GLdouble nearVal, GLdouble farVal); +void glDetachShader( GLuint program, GLuint shader); +void glDisable( GLenum cap); +void glDisablei( GLenum cap, GLuint index); +void glDisableVertexAttribArray( GLuint index); +void glDrawArrays( GLenum mode, GLint first, GLsizei count); +void glDrawArraysIndirect( GLenum mode, const void *indirect); +void glDrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void glDrawBuffer( GLenum buf); +void glDrawBuffers( GLsizei n, const GLenum *bufs); +void glDrawElements( GLenum mode, GLsizei count, GLenum type, const void * indices); +void glDrawElementsBaseVertex( GLenum mode, GLsizei count, GLenum type, void *indices, GLint basevertex); +void glDrawElementsIndirect( GLenum mode, GLenum type, const void *indirect); +void glDrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount); +void glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices); +void glDrawRangeElementsBaseVertex( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, void *indices, GLint basevertex); +void glDrawTransformFeedback( GLenum mode, GLuint id); +void glDrawTransformFeedbackStream( GLenum mode, GLuint id, GLuint stream); + diff --git a/src/opengl/bind/d.bind b/src/opengl/bind/d.bind new file mode 100644 index 0000000..b307029 --- /dev/null +++ b/src/opengl/bind/d.bind @@ -0,0 +1,331 @@ +int glDeleteBuffers_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + const GLuint * buffers = get: const GLuint * + glDeleteBuffers(n, buffers); + return 0; +} + + +int glDeleteFramebuffers_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * framebuffers = get: GLuint * + glDeleteFramebuffers(n, framebuffers); + return 0; +} + + +int glDeleteProgram_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + glDeleteProgram(program); + return 0; +} + + +int glDeleteProgramPipelines_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + const GLuint * pipelines = get: const GLuint * + glDeleteProgramPipelines(n, pipelines); + return 0; +} + + +int glDeleteQueries_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + const GLuint * ids = get: const GLuint * + glDeleteQueries(n, ids); + return 0; +} + + +int glDeleteRenderbuffers_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * renderbuffers = get: GLuint * + glDeleteRenderbuffers(n, renderbuffers); + return 0; +} + + +int glDeleteSamplers_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + const GLuint * samplers = get: const GLuint * + glDeleteSamplers(n, samplers); + return 0; +} + + +int glDeleteShader_bind(lua_State *L) +{ + GLuint shader = luaL_checkinteger(L, 1); + glDeleteShader(shader); + return 0; +} + + +int glDeleteSync_bind(lua_State *L) +{ + GLsync sync = luaL_checkinteger(L, 1); + glDeleteSync(sync); + return 0; +} + + +int glDeleteTextures_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + const GLuint * textures = get: const GLuint * + glDeleteTextures(n, textures); + return 0; +} + + +int glDeleteTransformFeedbacks_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + const GLuint * ids = get: const GLuint * + glDeleteTransformFeedbacks(n, ids); + return 0; +} + + +int glDeleteVertexArrays_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + const GLuint * arrays = get: const GLuint * + glDeleteVertexArrays(n, arrays); + return 0; +} + + +int glDepthFunc_bind(lua_State *L) +{ + GLenum func = luaL_checkinteger(L, 1); + glDepthFunc(func); + return 0; +} + + +int glDepthMask_bind(lua_State *L) +{ + GLboolean flag = get: GLboolean + glDepthMask(flag); + return 0; +} + + +int glDepthRange_bind(lua_State *L) +{ + GLdouble nearVal = luaL_checknumber(L, 1); + GLdouble farVal = luaL_checknumber(L, 2); + glDepthRange(nearVal, farVal); + return 0; +} + + +int glDepthRangef_bind(lua_State *L) +{ + GLfloat nearVal = luaL_checknumber(L, 1); + GLfloat farVal = luaL_checknumber(L, 2); + glDepthRangef(nearVal, farVal); + return 0; +} + + +int glDepthRangeArrayv_bind(lua_State *L) +{ + GLuint first = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLdouble * v = get: const GLdouble * + glDepthRangeArrayv(first, count, v); + return 0; +} + + +int glDepthRangeIndexed_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLdouble nearVal = luaL_checknumber(L, 2); + GLdouble farVal = luaL_checknumber(L, 3); + glDepthRangeIndexed(index, nearVal, farVal); + return 0; +} + + +int glDetachShader_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint shader = luaL_checkinteger(L, 2); + glDetachShader(program, shader); + return 0; +} + + +int glDisable_bind(lua_State *L) +{ + GLenum cap = luaL_checkinteger(L, 1); + glDisable(cap); + return 0; +} + + +int glDisablei_bind(lua_State *L) +{ + GLenum cap = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + glDisablei(cap, index); + return 0; +} + + +int glDisableVertexAttribArray_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + glDisableVertexAttribArray(index); + return 0; +} + + +int glDrawArrays_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + GLint first = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + glDrawArrays(mode, first, count); + return 0; +} + + +int glDrawArraysIndirect_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + const void * indirect = get: const void * + glDrawArraysIndirect(mode, indirect); + return 0; +} + + +int glDrawArraysInstanced_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + GLint first = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + GLsizei instancecount = luaL_checkinteger(L, 4); + glDrawArraysInstanced(mode, first, count, instancecount); + return 0; +} + + +int glDrawBuffer_bind(lua_State *L) +{ + GLenum buf = luaL_checkinteger(L, 1); + glDrawBuffer(buf); + return 0; +} + + +int glDrawBuffers_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + const GLenum * bufs = get: const GLenum * + glDrawBuffers(n, bufs); + return 0; +} + + +int glDrawElements_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLenum type = luaL_checkinteger(L, 3); + const void * indices = get: const void * + glDrawElements(mode, count, type, indices); + return 0; +} + + +int glDrawElementsBaseVertex_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLenum type = luaL_checkinteger(L, 3); + void * indices = get: void * + GLint basevertex = luaL_checkinteger(L, 5); + glDrawElementsBaseVertex(mode, count, type, indices, basevertex); + return 0; +} + + +int glDrawElementsIndirect_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + GLenum type = luaL_checkinteger(L, 2); + const void * indirect = get: const void * + glDrawElementsIndirect(mode, type, indirect); + return 0; +} + + +int glDrawElementsInstanced_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLenum type = luaL_checkinteger(L, 3); + const void * indices = get: const void * + GLsizei instancecount = luaL_checkinteger(L, 5); + glDrawElementsInstanced(mode, count, type, indices, instancecount); + return 0; +} + + +int glDrawRangeElements_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + GLuint start = luaL_checkinteger(L, 2); + GLuint end = luaL_checkinteger(L, 3); + GLsizei count = luaL_checkinteger(L, 4); + GLenum type = luaL_checkinteger(L, 5); + const void * indices = get: const void * + glDrawRangeElements(mode, start, end, count, type, indices); + return 0; +} + + +int glDrawRangeElementsBaseVertex_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + GLuint start = luaL_checkinteger(L, 2); + GLuint end = luaL_checkinteger(L, 3); + GLsizei count = luaL_checkinteger(L, 4); + GLenum type = luaL_checkinteger(L, 5); + void * indices = get: void * + GLint basevertex = luaL_checkinteger(L, 7); + glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex); + return 0; +} + + +int glDrawTransformFeedback_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + GLuint id = luaL_checkinteger(L, 2); + glDrawTransformFeedback(mode, id); + return 0; +} + + +int glDrawTransformFeedbackStream_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + GLuint id = luaL_checkinteger(L, 2); + GLuint stream = luaL_checkinteger(L, 3); + glDrawTransformFeedbackStream(mode, id, stream); + return 0; +} + + diff --git a/src/opengl/bind/e b/src/opengl/bind/e new file mode 100644 index 0000000..4502836 --- /dev/null +++ b/src/opengl/bind/e @@ -0,0 +1,7 @@ +void glEnable( GLenum cap); +void glEnablei( GLenum cap, GLuint index); +void glEnableVertexAttribArray( GLuint index); +void glEndConditionalRender( void); +void glEndQuery( GLenum target); +void glEndQueryIndexed( GLenum target, GLuint index); +void glEndTransformFeedback(); diff --git a/src/opengl/bind/e.bind b/src/opengl/bind/e.bind new file mode 100644 index 0000000..50332d5 --- /dev/null +++ b/src/opengl/bind/e.bind @@ -0,0 +1,57 @@ +int glEnable_bind(lua_State *L) +{ + GLenum cap = luaL_checkinteger(L, 1); + glEnable(cap); + return 0; +} + + +int glEnablei_bind(lua_State *L) +{ + GLenum cap = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + glEnablei(cap, index); + return 0; +} + + +int glEnableVertexAttribArray_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + glEnableVertexAttribArray(index); + return 0; +} + + +int glEndConditionalRender_bind(lua_State *L) +{ + void = get: + glEndConditionalRender(void); + return 0; +} + + +int glEndQuery_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + glEndQuery(target); + return 0; +} + + +int glEndQueryIndexed_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + glEndQueryIndexed(target, index); + return 0; +} + + +int glEndTransformFeedback_bind(lua_State *L) +{ + glEndTransformFeedback(); + return 0; +} + + diff --git a/src/opengl/bind/f b/src/opengl/bind/f new file mode 100644 index 0000000..63b8140 --- /dev/null +++ b/src/opengl/bind/f @@ -0,0 +1,11 @@ +GLsync glFenceSync( GLenum condition, GLbitfield flags); +void glFinish( void); +void glFlush( void); +void glFlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length); +void glFramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void glFramebufferTexture( GLenum target, GLenum attachment, GLuint texture, GLint level); +void glFramebufferTexture1D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void glFramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void glFramebufferTexture3D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer); +void glFramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void glFrontFace( GLenum mode); diff --git a/src/opengl/bind/f.bind b/src/opengl/bind/f.bind new file mode 100644 index 0000000..de6a297 --- /dev/null +++ b/src/opengl/bind/f.bind @@ -0,0 +1,115 @@ +int glFenceSync_bind(lua_State *L) +{ + GLenum condition = luaL_checkinteger(L, 1); + GLbitfield flags = luaL_checkinteger(L, 2); + GLsync bind_result = glFenceSync(condition, flags); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glFinish_bind(lua_State *L) +{ + void = get: + glFinish(void); + return 0; +} + + +int glFlush_bind(lua_State *L) +{ + void = get: + glFlush(void); + return 0; +} + + +int glFlushMappedBufferRange_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLintptr offset = luaL_checkinteger(L, 2); + GLsizeiptr length = luaL_checkinteger(L, 3); + glFlushMappedBufferRange(target, offset, length); + return 0; +} + + +int glFramebufferRenderbuffer_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum attachment = luaL_checkinteger(L, 2); + GLenum renderbuffertarget = luaL_checkinteger(L, 3); + GLuint renderbuffer = luaL_checkinteger(L, 4); + glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); + return 0; +} + + +int glFramebufferTexture_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum attachment = luaL_checkinteger(L, 2); + GLuint texture = luaL_checkinteger(L, 3); + GLint level = luaL_checkinteger(L, 4); + glFramebufferTexture(target, attachment, texture, level); + return 0; +} + + +int glFramebufferTexture1D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum attachment = luaL_checkinteger(L, 2); + GLenum textarget = luaL_checkinteger(L, 3); + GLuint texture = luaL_checkinteger(L, 4); + GLint level = luaL_checkinteger(L, 5); + glFramebufferTexture1D(target, attachment, textarget, texture, level); + return 0; +} + + +int glFramebufferTexture2D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum attachment = luaL_checkinteger(L, 2); + GLenum textarget = luaL_checkinteger(L, 3); + GLuint texture = luaL_checkinteger(L, 4); + GLint level = luaL_checkinteger(L, 5); + glFramebufferTexture2D(target, attachment, textarget, texture, level); + return 0; +} + + +int glFramebufferTexture3D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum attachment = luaL_checkinteger(L, 2); + GLenum textarget = luaL_checkinteger(L, 3); + GLuint texture = luaL_checkinteger(L, 4); + GLint level = luaL_checkinteger(L, 5); + GLint layer = luaL_checkinteger(L, 6); + glFramebufferTexture3D(target, attachment, textarget, texture, level, layer); + return 0; +} + + +int glFramebufferTextureLayer_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum attachment = luaL_checkinteger(L, 2); + GLuint texture = luaL_checkinteger(L, 3); + GLint level = luaL_checkinteger(L, 4); + GLint layer = luaL_checkinteger(L, 5); + glFramebufferTextureLayer(target, attachment, texture, level, layer); + return 0; +} + + +int glFrontFace_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + glFrontFace(mode); + return 0; +} + + diff --git a/src/opengl/bind/g b/src/opengl/bind/g new file mode 100644 index 0000000..bc61f25 --- /dev/null +++ b/src/opengl/bind/g @@ -0,0 +1,88 @@ +void glGenBuffers( GLsizei n, GLuint * buffers); +void glGenerateMipmap( GLenum target); +void glGenFramebuffers( GLsizei n, GLuint *ids); +void glGenProgramPipelines( GLsizei n, GLuint *pipelines); +void glGenQueries( GLsizei n, GLuint * ids); +void glGenRenderbuffers( GLsizei n, GLuint *renderbuffers); +void glGenSamplers( GLsizei n, GLuint *samplers); +void glGenTextures( GLsizei n, GLuint * textures); +void glGenTransformFeedbacks( GLsizei n, GLuint *ids); +void glGenVertexArrays( GLsizei n, GLuint *arrays); +void glGetBooleanv( GLenum pname, GLboolean * data); +void glGetDoublev( GLenum pname, GLdouble * data); +void glGetFloatv( GLenum pname, GLfloat * data); +void glGetIntegerv( GLenum pname, GLint * data); +void glGetInteger64v( GLenum pname, GLint64 * data); +void glGetBooleani_v( GLenum target, GLuint index, GLboolean * data); +void glGetIntegeri_v( GLenum target, GLuint index, GLint * data); +void glGetFloati_v( GLenum target, GLuint index, GLfloat * data); +void glGetDoublei_v( GLenum target, GLuint index, GLdouble * data); +void glGetInteger64i_v( GLenum target, GLuint index, GLint64 * data); +void glGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +void glGetActiveSubroutineName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name); +void glGetActiveSubroutineUniformiv( GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values); +void glGetActiveSubroutineUniformName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name); +void glGetActiveUniform( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +void glGetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +void glGetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +void glGetActiveUniformName( GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +void glGetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +void glGetAttachedShaders( GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLint glGetAttribLocation( GLuint program, const GLchar *name); +void glGetBufferParameteriv( GLenum target, GLenum value, GLint * data); +void glGetBufferParameteri64v( GLenum target, GLenum value, GLint64 * data); +void glGetBufferPointerv( GLenum target, GLenum pname, void ** params); +void glGetBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, void * data); +void glGetCompressedTexImage( GLenum target, GLint level, void * pixels); +GLenum glGetError( void); +GLint glGetFragDataIndex( GLuint program, const char * name); +GLint glGetFragDataLocation( GLuint program, const char * name); +void glGetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint *params); +void glGetMultisamplefv( GLenum pname, GLuint index, GLfloat *val); +void glGetUniformfv( GLuint program, GLint location, GLfloat *params); +void glGetUniformiv( GLuint program, GLint location, GLint *params); +void glGetUniformuiv( GLuint program, GLint location, GLuint *params); +void glGetUniformdv( GLuint program, GLint location, GLdouble *params); +void glGetProgramiv( GLuint program, GLenum pname, GLint *params); +void glGetProgramBinary( GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary); +void glGetProgramInfoLog( GLuint program, GLsizei maxLength, GLsizei *length, GLchar *infoLog); +void glGetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint *params); +void glGetProgramPipelineInfoLog( GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +void glGetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint *params); +void glGetProgramStageiv( GLuint program, GLenum shadertype, GLenum pname, GLint *values); +void glGetQueryIndexediv( GLenum target, GLuint index, GLenum pname, GLint * params); +void glGetQueryiv( GLenum target, GLenum pname, GLint * params); +void glGetRenderbufferParameteriv( GLenum target, GLenum pname, GLint *params); +void glGetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat * params); +void glGetSamplerParameteriv( GLuint sampler, GLenum pname, GLint * params); +void glGetSamplerParameterIiv( GLuint sampler, GLenum pname, GLint * params); +void glGetSamplerParameterIuiv( GLuint sampler, GLenum pname, GLuint * params); +void glGetShaderiv( GLuint shader, GLenum pname, GLint *params); +void glGetShaderInfoLog( GLuint shader, GLsizei maxLength, GLsizei *length, GLchar *infoLog); +void glGetShaderiv( GLuint shader, GLenum pname, GLint *params); +void glGetShaderPrecisionFormat( GLenum shaderType, GLenum precisionType, GLint *range, GLint *precision); +void glGetShaderSource( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +const GLubyte * glGetString(GLenum name); +const GLubyte * glGetStringi(GLenum name, GLuint index); +GLuint glGetSubroutineIndex( GLuint program, GLenum shadertype, const GLchar *name); +GLint glGetSubroutineUniformLocation( GLuint program, GLenum shadertype, const GLchar *name); +void glGetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values); +void glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +void glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat * params); +void glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint * params); +void glGetTexParameterfv( GLenum target, GLenum pname, GLfloat * params); +void glGetTexParameteriv( GLenum target, GLenum pname, GLint * params); +void glGetTexParameterIiv( GLenum target, GLenum pname, GLint * params); +void glGetTexParameterIuiv( GLenum target, GLenum pname, GLuint * params); +void glGetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, char *name); +GLuint glGetUniformBlockIndex( GLuint program, const GLchar *uniformBlockName); +void glGetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar **uniformNames, GLuint *uniformIndices); +GLint glGetUniformLocation( GLuint program, const GLchar *name); +void glGetUniformSubroutineuiv( GLenum shadertype, GLint location, GLuint *values); +void glGetVertexAttribdv( GLuint index, GLenum pname, GLdouble *params); +void glGetVertexAttribfv( GLuint index, GLenum pname, GLfloat *params); +void glGetVertexAttribiv( GLuint index, GLenum pname, GLint *params); +void glGetVertexAttribIiv( GLuint index, GLenum pname, GLint *params); +void glGetVertexAttribIuiv( GLuint index, GLenum pname, GLuint *params); +void glGetVertexAttribLdv( GLuint index, GLenum pname, GLdouble *params); +void glGetVertexAttribPointerv( GLuint index, GLenum pname, void **pointer); diff --git a/src/opengl/bind/g.bind b/src/opengl/bind/g.bind new file mode 100644 index 0000000..2c608b8 --- /dev/null +++ b/src/opengl/bind/g.bind @@ -0,0 +1,910 @@ +int glGenBuffers_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * buffers = get: GLuint * + glGenBuffers(n, buffers); + return 0; +} + + +int glGenerateMipmap_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + glGenerateMipmap(target); + return 0; +} + + +int glGenFramebuffers_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * ids = get: GLuint * + glGenFramebuffers(n, ids); + return 0; +} + + +int glGenProgramPipelines_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * pipelines = get: GLuint * + glGenProgramPipelines(n, pipelines); + return 0; +} + + +int glGenQueries_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * ids = get: GLuint * + glGenQueries(n, ids); + return 0; +} + + +int glGenRenderbuffers_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * renderbuffers = get: GLuint * + glGenRenderbuffers(n, renderbuffers); + return 0; +} + + +int glGenSamplers_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * samplers = get: GLuint * + glGenSamplers(n, samplers); + return 0; +} + + +int glGenTextures_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * textures = get: GLuint * + glGenTextures(n, textures); + return 0; +} + + +int glGenTransformFeedbacks_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * ids = get: GLuint * + glGenTransformFeedbacks(n, ids); + return 0; +} + + +int glGenVertexArrays_bind(lua_State *L) +{ + GLsizei n = luaL_checkinteger(L, 1); + GLuint * arrays = get: GLuint * + glGenVertexArrays(n, arrays); + return 0; +} + + +int glGetBooleanv_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLboolean * data = get: GLboolean * + glGetBooleanv(pname, data); + return 0; +} + + +int glGetDoublev_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLdouble * data = get: GLdouble * + glGetDoublev(pname, data); + return 0; +} + + +int glGetFloatv_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLfloat * data = get: GLfloat * + glGetFloatv(pname, data); + return 0; +} + + +int glGetIntegerv_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLint * data = get: GLint * + glGetIntegerv(pname, data); + return 0; +} + + +int glGetInteger64v_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLint64 * data = get: GLint64 * + glGetInteger64v(pname, data); + return 0; +} + + +int glGetBooleani_v_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLboolean * data = get: GLboolean * + glGetBooleani_v(target, index, data); + return 0; +} + + +int glGetIntegeri_v_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLint * data = get: GLint * + glGetIntegeri_v(target, index, data); + return 0; +} + + +int glGetFloati_v_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLfloat * data = get: GLfloat * + glGetFloati_v(target, index, data); + return 0; +} + + +int glGetDoublei_v_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLdouble * data = get: GLdouble * + glGetDoublei_v(target, index, data); + return 0; +} + + +int glGetInteger64i_v_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLint64 * data = get: GLint64 * + glGetInteger64i_v(target, index, data); + return 0; +} + + +int glGetActiveAttrib_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLsizei bufSize = luaL_checkinteger(L, 3); + GLsizei * length = get: GLsizei * + GLint * size = get: GLint * + GLenum * type = get: GLenum * + GLchar * name = luaL_checkstring(L, 7); + glGetActiveAttrib(program, index, bufSize, length, size, type, name); + return 0; +} + + +int glGetActiveSubroutineName_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLenum shadertype = luaL_checkinteger(L, 2); + GLuint index = luaL_checkinteger(L, 3); + GLsizei bufSize = luaL_checkinteger(L, 4); + GLsizei * length = get: GLsizei * + GLchar * name = luaL_checkstring(L, 6); + glGetActiveSubroutineName(program, shadertype, index, bufSize, length, name); + return 0; +} + + +int glGetActiveSubroutineUniformiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLenum shadertype = luaL_checkinteger(L, 2); + GLuint index = luaL_checkinteger(L, 3); + GLenum pname = luaL_checkinteger(L, 4); + GLint * values = get: GLint * + glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values); + return 0; +} + + +int glGetActiveSubroutineUniformName_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLenum shadertype = luaL_checkinteger(L, 2); + GLuint index = luaL_checkinteger(L, 3); + GLsizei bufSize = luaL_checkinteger(L, 4); + GLsizei * length = get: GLsizei * + GLchar * name = luaL_checkstring(L, 6); + glGetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); + return 0; +} + + +int glGetActiveUniform_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLsizei bufSize = luaL_checkinteger(L, 3); + GLsizei * length = get: GLsizei * + GLint * size = get: GLint * + GLenum * type = get: GLenum * + GLchar * name = luaL_checkstring(L, 7); + glGetActiveUniform(program, index, bufSize, length, size, type, name); + return 0; +} + + +int glGetActiveUniformBlockiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint uniformBlockIndex = luaL_checkinteger(L, 2); + GLenum pname = luaL_checkinteger(L, 3); + GLint * params = get: GLint * + glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); + return 0; +} + + +int glGetActiveUniformBlockName_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint uniformBlockIndex = luaL_checkinteger(L, 2); + GLsizei bufSize = luaL_checkinteger(L, 3); + GLsizei * length = get: GLsizei * + GLchar * uniformBlockName = luaL_checkstring(L, 5); + glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); + return 0; +} + + +int glGetActiveUniformName_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint uniformIndex = luaL_checkinteger(L, 2); + GLsizei bufSize = luaL_checkinteger(L, 3); + GLsizei * length = get: GLsizei * + GLchar * uniformName = luaL_checkstring(L, 5); + glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); + return 0; +} + + +int glGetActiveUniformsiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLsizei uniformCount = luaL_checkinteger(L, 2); + const GLuint * uniformIndices = get: const GLuint * + GLenum pname = luaL_checkinteger(L, 4); + GLint * params = get: GLint * + glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); + return 0; +} + + +int glGetAttachedShaders_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLsizei maxCount = luaL_checkinteger(L, 2); + GLsizei * count = get: GLsizei * + GLuint * shaders = get: GLuint * + glGetAttachedShaders(program, maxCount, count, shaders); + return 0; +} + + +int glGetAttribLocation_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + const GLchar * name = luaL_checkstring(L, 2); + GLint bind_result = glGetAttribLocation(program, name); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glGetBufferParameteriv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum value = luaL_checkinteger(L, 2); + GLint * data = get: GLint * + glGetBufferParameteriv(target, value, data); + return 0; +} + + +int glGetBufferParameteri64v_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum value = luaL_checkinteger(L, 2); + GLint64 * data = get: GLint64 * + glGetBufferParameteri64v(target, value, data); + return 0; +} + + +int glGetBufferPointerv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + void ** params = get: void ** + glGetBufferPointerv(target, pname, params); + return 0; +} + + +int glGetBufferSubData_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLintptr offset = luaL_checkinteger(L, 2); + GLsizeiptr size = luaL_checkinteger(L, 3); + void * data = get: void * + glGetBufferSubData(target, offset, size, data); + return 0; +} + + +int glGetCompressedTexImage_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + void * pixels = get: void * + glGetCompressedTexImage(target, level, pixels); + return 0; +} + + +int glGetError_bind(lua_State *L) +{ + void = get: + GLenum bind_result = glGetError(void); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glGetFragDataIndex_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + const char * name = luaL_checkstring(L, 2); + GLint bind_result = glGetFragDataIndex(program, name); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glGetFragDataLocation_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + const char * name = luaL_checkstring(L, 2); + GLint bind_result = glGetFragDataLocation(program, name); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glGetFramebufferAttachmentParameteriv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum attachment = luaL_checkinteger(L, 2); + GLenum pname = luaL_checkinteger(L, 3); + GLint * params = get: GLint * + glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); + return 0; +} + + +int glGetMultisamplefv_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLfloat * val = get: GLfloat * + glGetMultisamplefv(pname, index, val); + return 0; +} + + +int glGetUniformfv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLfloat * params = get: GLfloat * + glGetUniformfv(program, location, params); + return 0; +} + + +int glGetUniformiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetUniformiv(program, location, params); + return 0; +} + + +int glGetUniformuiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLuint * params = get: GLuint * + glGetUniformuiv(program, location, params); + return 0; +} + + +int glGetUniformdv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLdouble * params = get: GLdouble * + glGetUniformdv(program, location, params); + return 0; +} + + +int glGetProgramiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetProgramiv(program, pname, params); + return 0; +} + + +int glGetProgramBinary_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLsizei bufSize = luaL_checkinteger(L, 2); + GLsizei * length = get: GLsizei * + GLenum * binaryFormat = get: GLenum * + void * binary = get: void * + glGetProgramBinary(program, bufSize, length, binaryFormat, binary); + return 0; +} + + +int glGetProgramInfoLog_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLsizei maxLength = luaL_checkinteger(L, 2); + GLsizei * length = get: GLsizei * + GLchar * infoLog = luaL_checkstring(L, 4); + glGetProgramInfoLog(program, maxLength, length, infoLog); + return 0; +} + + +int glGetProgramPipelineiv_bind(lua_State *L) +{ + GLuint pipeline = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetProgramPipelineiv(pipeline, pname, params); + return 0; +} + + +int glGetProgramPipelineInfoLog_bind(lua_State *L) +{ + GLuint pipeline = luaL_checkinteger(L, 1); + GLsizei bufSize = luaL_checkinteger(L, 2); + GLsizei * length = get: GLsizei * + GLchar * infoLog = luaL_checkstring(L, 4); + glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); + return 0; +} + + +int glGetProgramPipelineiv_bind(lua_State *L) +{ + GLuint pipeline = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetProgramPipelineiv(pipeline, pname, params); + return 0; +} + + +int glGetProgramStageiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLenum shadertype = luaL_checkinteger(L, 2); + GLenum pname = luaL_checkinteger(L, 3); + GLint * values = get: GLint * + glGetProgramStageiv(program, shadertype, pname, values); + return 0; +} + + +int glGetQueryIndexediv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLenum pname = luaL_checkinteger(L, 3); + GLint * params = get: GLint * + glGetQueryIndexediv(target, index, pname, params); + return 0; +} + + +int glGetQueryiv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetQueryiv(target, pname, params); + return 0; +} + + +int glGetRenderbufferParameteriv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetRenderbufferParameteriv(target, pname, params); + return 0; +} + + +int glGetSamplerParameterfv_bind(lua_State *L) +{ + GLuint sampler = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLfloat * params = get: GLfloat * + glGetSamplerParameterfv(sampler, pname, params); + return 0; +} + + +int glGetSamplerParameteriv_bind(lua_State *L) +{ + GLuint sampler = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetSamplerParameteriv(sampler, pname, params); + return 0; +} + + +int glGetSamplerParameterIiv_bind(lua_State *L) +{ + GLuint sampler = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetSamplerParameterIiv(sampler, pname, params); + return 0; +} + + +int glGetSamplerParameterIuiv_bind(lua_State *L) +{ + GLuint sampler = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLuint * params = get: GLuint * + glGetSamplerParameterIuiv(sampler, pname, params); + return 0; +} + + +int glGetShaderiv_bind(lua_State *L) +{ + GLuint shader = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetShaderiv(shader, pname, params); + return 0; +} + + +int glGetShaderInfoLog_bind(lua_State *L) +{ + GLuint shader = luaL_checkinteger(L, 1); + GLsizei maxLength = luaL_checkinteger(L, 2); + GLsizei * length = get: GLsizei * + GLchar * infoLog = luaL_checkstring(L, 4); + glGetShaderInfoLog(shader, maxLength, length, infoLog); + return 0; +} + + +int glGetShaderiv_bind(lua_State *L) +{ + GLuint shader = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetShaderiv(shader, pname, params); + return 0; +} + + +int glGetShaderPrecisionFormat_bind(lua_State *L) +{ + GLenum shaderType = luaL_checkinteger(L, 1); + GLenum precisionType = luaL_checkinteger(L, 2); + GLint * range = get: GLint * + GLint * precision = get: GLint * + glGetShaderPrecisionFormat(shaderType, precisionType, range, precision); + return 0; +} + + +int glGetShaderSource_bind(lua_State *L) +{ + GLuint shader = luaL_checkinteger(L, 1); + GLsizei bufSize = luaL_checkinteger(L, 2); + GLsizei * length = get: GLsizei * + GLchar * source = luaL_checkstring(L, 4); + glGetShaderSource(shader, bufSize, length, source); + return 0; +} + + +int glGetString_bind(lua_State *L) +{ + GLenum name = luaL_checkinteger(L, 1); + const GLubyte * bind_result = glGetString(name); + /* push result */ + return /* count */; +} + + +int glGetStringi_bind(lua_State *L) +{ + GLenum name = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + const GLubyte * bind_result = glGetStringi(name, index); + /* push result */ + return /* count */; +} + + +int glGetSubroutineIndex_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLenum shadertype = luaL_checkinteger(L, 2); + const GLchar * name = luaL_checkstring(L, 3); + GLuint bind_result = glGetSubroutineIndex(program, shadertype, name); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glGetSubroutineUniformLocation_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLenum shadertype = luaL_checkinteger(L, 2); + const GLchar * name = luaL_checkstring(L, 3); + GLint bind_result = glGetSubroutineUniformLocation(program, shadertype, name); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glGetSynciv_bind(lua_State *L) +{ + GLsync sync = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLsizei bufSize = luaL_checkinteger(L, 3); + GLsizei * length = get: GLsizei * + GLint * values = get: GLint * + glGetSynciv(sync, pname, bufSize, length, values); + return 0; +} + + +int glGetTexImage_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLenum format = luaL_checkinteger(L, 3); + GLenum type = luaL_checkinteger(L, 4); + void * pixels = get: void * + glGetTexImage(target, level, format, type, pixels); + return 0; +} + + +int glGetTexLevelParameterfv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLenum pname = luaL_checkinteger(L, 3); + GLfloat * params = get: GLfloat * + glGetTexLevelParameterfv(target, level, pname, params); + return 0; +} + + +int glGetTexLevelParameteriv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLenum pname = luaL_checkinteger(L, 3); + GLint * params = get: GLint * + glGetTexLevelParameteriv(target, level, pname, params); + return 0; +} + + +int glGetTexParameterfv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLfloat * params = get: GLfloat * + glGetTexParameterfv(target, pname, params); + return 0; +} + + +int glGetTexParameteriv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetTexParameteriv(target, pname, params); + return 0; +} + + +int glGetTexParameterIiv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetTexParameterIiv(target, pname, params); + return 0; +} + + +int glGetTexParameterIuiv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLuint * params = get: GLuint * + glGetTexParameterIuiv(target, pname, params); + return 0; +} + + +int glGetTransformFeedbackVarying_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLsizei bufSize = luaL_checkinteger(L, 3); + GLsizei * length = get: GLsizei * + GLsizei * size = get: GLsizei * + GLenum * type = get: GLenum * + char * name = luaL_checkstring(L, 7); + glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); + return 0; +} + + +int glGetUniformBlockIndex_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + const GLchar * uniformBlockName = luaL_checkstring(L, 2); + GLuint bind_result = glGetUniformBlockIndex(program, uniformBlockName); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glGetUniformIndices_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLsizei uniformCount = luaL_checkinteger(L, 2); + const GLchar ** uniformNames = get: const GLchar ** + GLuint * uniformIndices = get: GLuint * + glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices); + return 0; +} + + +int glGetUniformLocation_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + const GLchar * name = luaL_checkstring(L, 2); + GLint bind_result = glGetUniformLocation(program, name); + lua_pushinteger(L, bind_result); + return 1; +} + + +int glGetUniformSubroutineuiv_bind(lua_State *L) +{ + GLenum shadertype = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLuint * values = get: GLuint * + glGetUniformSubroutineuiv(shadertype, location, values); + return 0; +} + + +int glGetVertexAttribdv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLdouble * params = get: GLdouble * + glGetVertexAttribdv(index, pname, params); + return 0; +} + + +int glGetVertexAttribfv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLfloat * params = get: GLfloat * + glGetVertexAttribfv(index, pname, params); + return 0; +} + + +int glGetVertexAttribiv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetVertexAttribiv(index, pname, params); + return 0; +} + + +int glGetVertexAttribIiv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint * params = get: GLint * + glGetVertexAttribIiv(index, pname, params); + return 0; +} + + +int glGetVertexAttribIuiv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLuint * params = get: GLuint * + glGetVertexAttribIuiv(index, pname, params); + return 0; +} + + +int glGetVertexAttribLdv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLdouble * params = get: GLdouble * + glGetVertexAttribLdv(index, pname, params); + return 0; +} + + +int glGetVertexAttribPointerv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + void ** pointer = get: void ** + glGetVertexAttribPointerv(index, pname, pointer); + return 0; +} + + diff --git a/src/opengl/bind/h b/src/opengl/bind/h new file mode 100644 index 0000000..00590da --- /dev/null +++ b/src/opengl/bind/h @@ -0,0 +1 @@ +void glHint( GLenum target, GLenum mode); diff --git a/src/opengl/bind/h.bind b/src/opengl/bind/h.bind new file mode 100644 index 0000000..7837656 --- /dev/null +++ b/src/opengl/bind/h.bind @@ -0,0 +1,9 @@ +int glHint_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum mode = luaL_checkinteger(L, 2); + glHint(target, mode); + return 0; +} + + diff --git a/src/opengl/bind/i b/src/opengl/bind/i new file mode 100644 index 0000000..6cb0306 --- /dev/null +++ b/src/opengl/bind/i @@ -0,0 +1,14 @@ +GLboolean glIsBuffer( GLuint buffer); +GLboolean glIsEnabled( GLenum cap); +GLboolean glIsEnabledi( GLenum cap, GLuint index); +GLboolean glIsFramebuffer( GLuint framebuffer); +GLboolean glIsProgram( GLuint program); +GLboolean glIsProgramPipeline( GLuint pipeline); +GLboolean glIsQuery( GLuint id); +GLboolean glIsRenderbuffer( GLuint renderbuffer); +GLboolean glIsSampler( GLuint id); +GLboolean glIsShader( GLuint shader); +GLboolean glIsSync( GLsync sync); +GLboolean glIsTexture( GLuint texture); +GLboolean glIsTransformFeedback( GLuint id); +GLboolean glIsVertexArray( GLuint array); diff --git a/src/opengl/bind/i.bind b/src/opengl/bind/i.bind new file mode 100644 index 0000000..044b72b --- /dev/null +++ b/src/opengl/bind/i.bind @@ -0,0 +1,127 @@ +int glIsBuffer_bind(lua_State *L) +{ + GLuint buffer = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsBuffer(buffer); + /* push result */ + return /* count */; +} + + +int glIsEnabled_bind(lua_State *L) +{ + GLenum cap = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsEnabled(cap); + /* push result */ + return /* count */; +} + + +int glIsEnabledi_bind(lua_State *L) +{ + GLenum cap = luaL_checkinteger(L, 1); + GLuint index = luaL_checkinteger(L, 2); + GLboolean bind_result = glIsEnabledi(cap, index); + /* push result */ + return /* count */; +} + + +int glIsFramebuffer_bind(lua_State *L) +{ + GLuint framebuffer = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsFramebuffer(framebuffer); + /* push result */ + return /* count */; +} + + +int glIsProgram_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsProgram(program); + /* push result */ + return /* count */; +} + + +int glIsProgramPipeline_bind(lua_State *L) +{ + GLuint pipeline = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsProgramPipeline(pipeline); + /* push result */ + return /* count */; +} + + +int glIsQuery_bind(lua_State *L) +{ + GLuint id = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsQuery(id); + /* push result */ + return /* count */; +} + + +int glIsRenderbuffer_bind(lua_State *L) +{ + GLuint renderbuffer = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsRenderbuffer(renderbuffer); + /* push result */ + return /* count */; +} + + +int glIsSampler_bind(lua_State *L) +{ + GLuint id = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsSampler(id); + /* push result */ + return /* count */; +} + + +int glIsShader_bind(lua_State *L) +{ + GLuint shader = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsShader(shader); + /* push result */ + return /* count */; +} + + +int glIsSync_bind(lua_State *L) +{ + GLsync sync = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsSync(sync); + /* push result */ + return /* count */; +} + + +int glIsTexture_bind(lua_State *L) +{ + GLuint texture = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsTexture(texture); + /* push result */ + return /* count */; +} + + +int glIsTransformFeedback_bind(lua_State *L) +{ + GLuint id = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsTransformFeedback(id); + /* push result */ + return /* count */; +} + + +int glIsVertexArray_bind(lua_State *L) +{ + GLuint array = luaL_checkinteger(L, 1); + GLboolean bind_result = glIsVertexArray(array); + /* push result */ + return /* count */; +} + + diff --git a/src/opengl/bind/l b/src/opengl/bind/l new file mode 100644 index 0000000..eb6ec73 --- /dev/null +++ b/src/opengl/bind/l @@ -0,0 +1,4 @@ +void glLineWidth( GLfloat width); +void glLinkProgram( GLuint program); +void glLogicOp( GLenum opcode); + diff --git a/src/opengl/bind/l.bind b/src/opengl/bind/l.bind new file mode 100644 index 0000000..1c8601b --- /dev/null +++ b/src/opengl/bind/l.bind @@ -0,0 +1,24 @@ +int glLineWidth_bind(lua_State *L) +{ + GLfloat width = luaL_checknumber(L, 1); + glLineWidth(width); + return 0; +} + + +int glLinkProgram_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + glLinkProgram(program); + return 0; +} + + +int glLogicOp_bind(lua_State *L) +{ + GLenum opcode = luaL_checkinteger(L, 1); + glLogicOp(opcode); + return 0; +} + + diff --git a/src/opengl/bind/m b/src/opengl/bind/m new file mode 100644 index 0000000..a346dd1 --- /dev/null +++ b/src/opengl/bind/m @@ -0,0 +1,7 @@ +void * glMapBuffer( GLenum target, GLenum access); +void * glMapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +void glMinSampleShading( GLfloat value); +void glMultiDrawArrays( GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount); +void glMultiDrawElements( GLenum mode, const GLsizei * count, GLenum type, const void * const * indices, GLsizei drawcount); +void glMultiDrawElementsBaseVertex( GLenum mode, const GLsizei *count, GLenum type, const void * const *indices, GLsizei drawcount, const GLint *basevertex); + diff --git a/src/opengl/bind/m.bind b/src/opengl/bind/m.bind new file mode 100644 index 0000000..e76b3df --- /dev/null +++ b/src/opengl/bind/m.bind @@ -0,0 +1,66 @@ +int glMapBuffer_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum access = luaL_checkinteger(L, 2); + void * bind_result = glMapBuffer(target, access); + /* push result */ + return /* count */; +} + + +int glMapBufferRange_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLintptr offset = luaL_checkinteger(L, 2); + GLsizeiptr length = luaL_checkinteger(L, 3); + GLbitfield access = luaL_checkinteger(L, 4); + void * bind_result = glMapBufferRange(target, offset, length, access); + /* push result */ + return /* count */; +} + + +int glMinSampleShading_bind(lua_State *L) +{ + GLfloat value = luaL_checknumber(L, 1); + glMinSampleShading(value); + return 0; +} + + +int glMultiDrawArrays_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + const GLint * first = get: const GLint * + const GLsizei * count = get: const GLsizei * + GLsizei drawcount = luaL_checkinteger(L, 4); + glMultiDrawArrays(mode, first, count, drawcount); + return 0; +} + + +int glMultiDrawElements_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + const GLsizei * count = get: const GLsizei * + GLenum type = luaL_checkinteger(L, 3); + const void * const * indices = get: const void * const * + GLsizei drawcount = luaL_checkinteger(L, 5); + glMultiDrawElements(mode, count, type, indices, drawcount); + return 0; +} + + +int glMultiDrawElementsBaseVertex_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + const GLsizei * count = get: const GLsizei * + GLenum type = luaL_checkinteger(L, 3); + const void * const * indices = get: const void * const * + GLsizei drawcount = luaL_checkinteger(L, 5); + const GLint * basevertex = get: const GLint * + glMultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex); + return 0; +} + + diff --git a/src/opengl/bind/p b/src/opengl/bind/p new file mode 100644 index 0000000..98ee850 --- /dev/null +++ b/src/opengl/bind/p @@ -0,0 +1,50 @@ +void glPatchParameteri( GLenum pname, GLint value); +void glPatchParameterfv( GLenum pname, const GLfloat *values); +void glPauseTransformFeedback( void); +void glPixelStoref( GLenum pname, GLfloat param); +void glPixelStorei( GLenum pname, GLint param); +void glPointParameterf( GLenum pname, GLfloat param); +void glPointParameteri( GLenum pname, GLint param); +void glPointParameterfv( GLenum pname, const GLfloat * params); +void glPointParameteriv( GLenum pname, const GLint * params); +void glPointSize( GLfloat size); +void glPolygonMode( GLenum face, GLenum mode); +void glPolygonOffset( GLfloat factor, GLfloat units); +void glPrimitiveRestartIndex( GLuint index); +void glProgramBinary( GLuint program, GLenum binaryFormat, const void *binary, GLsizei length); +void glProgramParameteri( GLuint program, GLenum pname, GLint value); +void glProgramUniform1f( GLuint program, GLint location, GLfloat v0); +void glProgramUniform2f( GLuint program, GLint location, GLfloat v0, GLfloat v1); +void glProgramUniform3f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void glProgramUniform4f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void glProgramUniform1i( GLuint program, GLint location, GLint v0); +void glProgramUniform2i( GLuint program, GLint location, GLint v0, GLint v1); +void glProgramUniform3i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +void glProgramUniform4i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void glProgramUniform1ui( GLuint program, GLint location, GLuint v0); +void glProgramUniform2ui( GLuint program, GLint location, GLuint v0, GLuint v1); +void glProgramUniform3ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +void glProgramUniform4ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void glProgramUniform1fv( GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform2fv( GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform3fv( GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform4fv( GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform1iv( GLuint program, GLint location, GLsizei count, const GLint *value); +void glProgramUniform2iv( GLuint program, GLint location, GLsizei count, const GLint *value); +void glProgramUniform3iv( GLuint program, GLint location, GLsizei count, const GLint *value); +void glProgramUniform4iv( GLuint program, GLint location, GLsizei count, const GLint *value); +void glProgramUniform1uiv( GLuint program, GLint location, GLsizei count, const GLuint *value); +void glProgramUniform2uiv( GLuint program, GLint location, GLsizei count, const GLuint *value); +void glProgramUniform3uiv( GLuint program, GLint location, GLsizei count, const GLuint *value); +void glProgramUniform4uiv( GLuint program, GLint location, GLsizei count, const GLuint *value); +void glProgramUniformMatrix2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix2x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix3x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix2x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix4x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix3x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix4x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProvokingVertex( GLenum provokeMode); + diff --git a/src/opengl/bind/p.bind b/src/opengl/bind/p.bind new file mode 100644 index 0000000..55411f4 --- /dev/null +++ b/src/opengl/bind/p.bind @@ -0,0 +1,521 @@ +int glPatchParameteri_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLint value = luaL_checkinteger(L, 2); + glPatchParameteri(pname, value); + return 0; +} + + +int glPatchParameterfv_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + const GLfloat * values = get: const GLfloat * + glPatchParameterfv(pname, values); + return 0; +} + + +int glPauseTransformFeedback_bind(lua_State *L) +{ + void = get: + glPauseTransformFeedback(void); + return 0; +} + + +int glPixelStoref_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLfloat param = luaL_checknumber(L, 2); + glPixelStoref(pname, param); + return 0; +} + + +int glPixelStorei_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLint param = luaL_checkinteger(L, 2); + glPixelStorei(pname, param); + return 0; +} + + +int glPointParameterf_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLfloat param = luaL_checknumber(L, 2); + glPointParameterf(pname, param); + return 0; +} + + +int glPointParameteri_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + GLint param = luaL_checkinteger(L, 2); + glPointParameteri(pname, param); + return 0; +} + + +int glPointParameterfv_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + const GLfloat * params = get: const GLfloat * + glPointParameterfv(pname, params); + return 0; +} + + +int glPointParameteriv_bind(lua_State *L) +{ + GLenum pname = luaL_checkinteger(L, 1); + const GLint * params = get: const GLint * + glPointParameteriv(pname, params); + return 0; +} + + +int glPointSize_bind(lua_State *L) +{ + GLfloat size = luaL_checknumber(L, 1); + glPointSize(size); + return 0; +} + + +int glPolygonMode_bind(lua_State *L) +{ + GLenum face = luaL_checkinteger(L, 1); + GLenum mode = luaL_checkinteger(L, 2); + glPolygonMode(face, mode); + return 0; +} + + +int glPolygonOffset_bind(lua_State *L) +{ + GLfloat factor = luaL_checknumber(L, 1); + GLfloat units = luaL_checknumber(L, 2); + glPolygonOffset(factor, units); + return 0; +} + + +int glPrimitiveRestartIndex_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + glPrimitiveRestartIndex(index); + return 0; +} + + +int glProgramBinary_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLenum binaryFormat = luaL_checkinteger(L, 2); + const void * binary = get: const void * + GLsizei length = luaL_checkinteger(L, 4); + glProgramBinary(program, binaryFormat, binary, length); + return 0; +} + + +int glProgramParameteri_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint value = luaL_checkinteger(L, 3); + glProgramParameteri(program, pname, value); + return 0; +} + + +int glProgramUniform1f_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLfloat v0 = luaL_checknumber(L, 3); + glProgramUniform1f(program, location, v0); + return 0; +} + + +int glProgramUniform2f_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLfloat v0 = luaL_checknumber(L, 3); + GLfloat v1 = luaL_checknumber(L, 4); + glProgramUniform2f(program, location, v0, v1); + return 0; +} + + +int glProgramUniform3f_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLfloat v0 = luaL_checknumber(L, 3); + GLfloat v1 = luaL_checknumber(L, 4); + GLfloat v2 = luaL_checknumber(L, 5); + glProgramUniform3f(program, location, v0, v1, v2); + return 0; +} + + +int glProgramUniform4f_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLfloat v0 = luaL_checknumber(L, 3); + GLfloat v1 = luaL_checknumber(L, 4); + GLfloat v2 = luaL_checknumber(L, 5); + GLfloat v3 = luaL_checknumber(L, 6); + glProgramUniform4f(program, location, v0, v1, v2, v3); + return 0; +} + + +int glProgramUniform1i_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLint v0 = luaL_checkinteger(L, 3); + glProgramUniform1i(program, location, v0); + return 0; +} + + +int glProgramUniform2i_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLint v0 = luaL_checkinteger(L, 3); + GLint v1 = luaL_checkinteger(L, 4); + glProgramUniform2i(program, location, v0, v1); + return 0; +} + + +int glProgramUniform3i_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLint v0 = luaL_checkinteger(L, 3); + GLint v1 = luaL_checkinteger(L, 4); + GLint v2 = luaL_checkinteger(L, 5); + glProgramUniform3i(program, location, v0, v1, v2); + return 0; +} + + +int glProgramUniform4i_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLint v0 = luaL_checkinteger(L, 3); + GLint v1 = luaL_checkinteger(L, 4); + GLint v2 = luaL_checkinteger(L, 5); + GLint v3 = luaL_checkinteger(L, 6); + glProgramUniform4i(program, location, v0, v1, v2, v3); + return 0; +} + + +int glProgramUniform1ui_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLuint v0 = luaL_checkinteger(L, 3); + glProgramUniform1ui(program, location, v0); + return 0; +} + + +int glProgramUniform2ui_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLuint v0 = luaL_checkinteger(L, 3); + GLuint v1 = luaL_checkinteger(L, 4); + glProgramUniform2ui(program, location, v0, v1); + return 0; +} + + +int glProgramUniform3ui_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLuint v0 = luaL_checkinteger(L, 3); + GLuint v1 = luaL_checkinteger(L, 4); + GLuint v2 = luaL_checkinteger(L, 5); + glProgramUniform3ui(program, location, v0, v1, v2); + return 0; +} + + +int glProgramUniform4ui_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLuint v0 = luaL_checkinteger(L, 3); + GLuint v1 = luaL_checkinteger(L, 4); + GLuint v2 = luaL_checkinteger(L, 5); + GLuint v3 = luaL_checkinteger(L, 6); + glProgramUniform4ui(program, location, v0, v1, v2, v3); + return 0; +} + + +int glProgramUniform1fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLfloat * value = get: const GLfloat * + glProgramUniform1fv(program, location, count, value); + return 0; +} + + +int glProgramUniform2fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLfloat * value = get: const GLfloat * + glProgramUniform2fv(program, location, count, value); + return 0; +} + + +int glProgramUniform3fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLfloat * value = get: const GLfloat * + glProgramUniform3fv(program, location, count, value); + return 0; +} + + +int glProgramUniform4fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLfloat * value = get: const GLfloat * + glProgramUniform4fv(program, location, count, value); + return 0; +} + + +int glProgramUniform1iv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLint * value = get: const GLint * + glProgramUniform1iv(program, location, count, value); + return 0; +} + + +int glProgramUniform2iv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLint * value = get: const GLint * + glProgramUniform2iv(program, location, count, value); + return 0; +} + + +int glProgramUniform3iv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLint * value = get: const GLint * + glProgramUniform3iv(program, location, count, value); + return 0; +} + + +int glProgramUniform4iv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLint * value = get: const GLint * + glProgramUniform4iv(program, location, count, value); + return 0; +} + + +int glProgramUniform1uiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLuint * value = get: const GLuint * + glProgramUniform1uiv(program, location, count, value); + return 0; +} + + +int glProgramUniform2uiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLuint * value = get: const GLuint * + glProgramUniform2uiv(program, location, count, value); + return 0; +} + + +int glProgramUniform3uiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLuint * value = get: const GLuint * + glProgramUniform3uiv(program, location, count, value); + return 0; +} + + +int glProgramUniform4uiv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + const GLuint * value = get: const GLuint * + glProgramUniform4uiv(program, location, count, value); + return 0; +} + + +int glProgramUniformMatrix2fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glProgramUniformMatrix2fv(program, location, count, transpose, value); + return 0; +} + + +int glProgramUniformMatrix3fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glProgramUniformMatrix3fv(program, location, count, transpose, value); + return 0; +} + + +int glProgramUniformMatrix4fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glProgramUniformMatrix4fv(program, location, count, transpose, value); + return 0; +} + + +int glProgramUniformMatrix2x3fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glProgramUniformMatrix2x3fv(program, location, count, transpose, value); + return 0; +} + + +int glProgramUniformMatrix3x2fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glProgramUniformMatrix3x2fv(program, location, count, transpose, value); + return 0; +} + + +int glProgramUniformMatrix2x4fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glProgramUniformMatrix2x4fv(program, location, count, transpose, value); + return 0; +} + + +int glProgramUniformMatrix4x2fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glProgramUniformMatrix4x2fv(program, location, count, transpose, value); + return 0; +} + + +int glProgramUniformMatrix3x4fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glProgramUniformMatrix3x4fv(program, location, count, transpose, value); + return 0; +} + + +int glProgramUniformMatrix4x3fv_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLint location = luaL_checkinteger(L, 2); + GLsizei count = luaL_checkinteger(L, 3); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glProgramUniformMatrix4x3fv(program, location, count, transpose, value); + return 0; +} + + +int glProvokingVertex_bind(lua_State *L) +{ + GLenum provokeMode = luaL_checkinteger(L, 1); + glProvokingVertex(provokeMode); + return 0; +} + + diff --git a/src/opengl/bind/q b/src/opengl/bind/q new file mode 100644 index 0000000..840f97b --- /dev/null +++ b/src/opengl/bind/q @@ -0,0 +1 @@ +void glQueryCounter( GLuint id, GLenum target); diff --git a/src/opengl/bind/q.bind b/src/opengl/bind/q.bind new file mode 100644 index 0000000..7209f1f --- /dev/null +++ b/src/opengl/bind/q.bind @@ -0,0 +1,9 @@ +int glQueryCounter_bind(lua_State *L) +{ + GLuint id = luaL_checkinteger(L, 1); + GLenum target = luaL_checkinteger(L, 2); + glQueryCounter(id, target); + return 0; +} + + diff --git a/src/opengl/bind/r b/src/opengl/bind/r new file mode 100644 index 0000000..f4e581c --- /dev/null +++ b/src/opengl/bind/r @@ -0,0 +1,6 @@ +void glReadBuffer( GLenum mode); +void glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * data); +void glReleaseShaderCompiler( void); +void glRenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +void glRenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +void glResumeTransformFeedback( void); diff --git a/src/opengl/bind/r.bind b/src/opengl/bind/r.bind new file mode 100644 index 0000000..d070737 --- /dev/null +++ b/src/opengl/bind/r.bind @@ -0,0 +1,61 @@ +int glReadBuffer_bind(lua_State *L) +{ + GLenum mode = luaL_checkinteger(L, 1); + glReadBuffer(mode); + return 0; +} + + +int glReadPixels_bind(lua_State *L) +{ + GLint x = luaL_checkinteger(L, 1); + GLint y = luaL_checkinteger(L, 2); + GLsizei width = luaL_checkinteger(L, 3); + GLsizei height = luaL_checkinteger(L, 4); + GLenum format = luaL_checkinteger(L, 5); + GLenum type = luaL_checkinteger(L, 6); + void * data = get: void * + glReadPixels(x, y, width, height, format, type, data); + return 0; +} + + +int glReleaseShaderCompiler_bind(lua_State *L) +{ + void = get: + glReleaseShaderCompiler(void); + return 0; +} + + +int glRenderbufferStorage_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum internalformat = luaL_checkinteger(L, 2); + GLsizei width = luaL_checkinteger(L, 3); + GLsizei height = luaL_checkinteger(L, 4); + glRenderbufferStorage(target, internalformat, width, height); + return 0; +} + + +int glRenderbufferStorageMultisample_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLsizei samples = luaL_checkinteger(L, 2); + GLenum internalformat = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLsizei height = luaL_checkinteger(L, 5); + glRenderbufferStorageMultisample(target, samples, internalformat, width, height); + return 0; +} + + +int glResumeTransformFeedback_bind(lua_State *L) +{ + void = get: + glResumeTransformFeedback(void); + return 0; +} + + diff --git a/src/opengl/bind/s b/src/opengl/bind/s new file mode 100644 index 0000000..cdddf6b --- /dev/null +++ b/src/opengl/bind/s @@ -0,0 +1,21 @@ +void glSampleCoverage( GLfloat value, GLboolean invert); +void glSampleMaski( GLuint maskNumber, GLbitfield mask); +void glSamplerParameterf( GLuint sampler, GLenum pname, GLfloat param); +void glSamplerParameteri( GLuint sampler, GLenum pname, GLint param); +void glSamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat * params); +void glSamplerParameteriv( GLuint sampler, GLenum pname, const GLint * params); +void glSamplerParameterIiv( GLuint sampler, GLenum pname, const GLint *params); +void glSamplerParameterIuiv( GLuint sampler, GLenum pname, const GLuint *params); +void glScissor( GLint x, GLint y, GLsizei width, GLsizei height); +void glScissorArrayv( GLuint first, GLsizei count, const GLint *v); +void glScissorIndexed( GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +void glScissorIndexedv( GLuint index, const GLint *v); +void glShaderBinary( GLsizei count, const GLuint *shaders, GLenum binaryFormat, const void *binary, GLsizei length); +void glShaderSource( GLuint shader, GLsizei count, const GLchar **string, const GLint *length); +void glStencilFunc( GLenum func, GLint ref, GLuint mask); +void glStencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask); +void glStencilMask( GLuint mask); +void glStencilMaskSeparate( GLenum face, GLuint mask); +void glStencilOp( GLenum sfail, GLenum dpfail, GLenum dppass); +void glStencilOpSeparate( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); + diff --git a/src/opengl/bind/s.bind b/src/opengl/bind/s.bind new file mode 100644 index 0000000..256ebe2 --- /dev/null +++ b/src/opengl/bind/s.bind @@ -0,0 +1,202 @@ +int glSampleCoverage_bind(lua_State *L) +{ + GLfloat value = luaL_checknumber(L, 1); + GLboolean invert = get: GLboolean + glSampleCoverage(value, invert); + return 0; +} + + +int glSampleMaski_bind(lua_State *L) +{ + GLuint maskNumber = luaL_checkinteger(L, 1); + GLbitfield mask = luaL_checkinteger(L, 2); + glSampleMaski(maskNumber, mask); + return 0; +} + + +int glSamplerParameterf_bind(lua_State *L) +{ + GLuint sampler = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLfloat param = luaL_checknumber(L, 3); + glSamplerParameterf(sampler, pname, param); + return 0; +} + + +int glSamplerParameteri_bind(lua_State *L) +{ + GLuint sampler = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint param = luaL_checkinteger(L, 3); + glSamplerParameteri(sampler, pname, param); + return 0; +} + + +int glSamplerParameterfv_bind(lua_State *L) +{ + GLuint sampler = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + const GLfloat * params = get: const GLfloat * + glSamplerParameterfv(sampler, pname, params); + return 0; +} + + +int glSamplerParameteriv_bind(lua_State *L) +{ + GLuint sampler = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + const GLint * params = get: const GLint * + glSamplerParameteriv(sampler, pname, params); + return 0; +} + + +int glSamplerParameterIiv_bind(lua_State *L) +{ + GLuint sampler = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + const GLint * params = get: const GLint * + glSamplerParameterIiv(sampler, pname, params); + return 0; +} + + +int glSamplerParameterIuiv_bind(lua_State *L) +{ + GLuint sampler = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + const GLuint * params = get: const GLuint * + glSamplerParameterIuiv(sampler, pname, params); + return 0; +} + + +int glScissor_bind(lua_State *L) +{ + GLint x = luaL_checkinteger(L, 1); + GLint y = luaL_checkinteger(L, 2); + GLsizei width = luaL_checkinteger(L, 3); + GLsizei height = luaL_checkinteger(L, 4); + glScissor(x, y, width, height); + return 0; +} + + +int glScissorArrayv_bind(lua_State *L) +{ + GLuint first = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLint * v = get: const GLint * + glScissorArrayv(first, count, v); + return 0; +} + + +int glScissorIndexed_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLint left = luaL_checkinteger(L, 2); + GLint bottom = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLsizei height = luaL_checkinteger(L, 5); + glScissorIndexed(index, left, bottom, width, height); + return 0; +} + + +int glScissorIndexedv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLint * v = get: const GLint * + glScissorIndexedv(index, v); + return 0; +} + + +int glShaderBinary_bind(lua_State *L) +{ + GLsizei count = luaL_checkinteger(L, 1); + const GLuint * shaders = get: const GLuint * + GLenum binaryFormat = luaL_checkinteger(L, 3); + const void * binary = get: const void * + GLsizei length = luaL_checkinteger(L, 5); + glShaderBinary(count, shaders, binaryFormat, binary, length); + return 0; +} + + +int glShaderSource_bind(lua_State *L) +{ + GLuint shader = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLchar ** string = get: const GLchar ** + const GLint * length = get: const GLint * + glShaderSource(shader, count, string, length); + return 0; +} + + +int glStencilFunc_bind(lua_State *L) +{ + GLenum func = luaL_checkinteger(L, 1); + GLint ref = luaL_checkinteger(L, 2); + GLuint mask = luaL_checkinteger(L, 3); + glStencilFunc(func, ref, mask); + return 0; +} + + +int glStencilFuncSeparate_bind(lua_State *L) +{ + GLenum face = luaL_checkinteger(L, 1); + GLenum func = luaL_checkinteger(L, 2); + GLint ref = luaL_checkinteger(L, 3); + GLuint mask = luaL_checkinteger(L, 4); + glStencilFuncSeparate(face, func, ref, mask); + return 0; +} + + +int glStencilMask_bind(lua_State *L) +{ + GLuint mask = luaL_checkinteger(L, 1); + glStencilMask(mask); + return 0; +} + + +int glStencilMaskSeparate_bind(lua_State *L) +{ + GLenum face = luaL_checkinteger(L, 1); + GLuint mask = luaL_checkinteger(L, 2); + glStencilMaskSeparate(face, mask); + return 0; +} + + +int glStencilOp_bind(lua_State *L) +{ + GLenum sfail = luaL_checkinteger(L, 1); + GLenum dpfail = luaL_checkinteger(L, 2); + GLenum dppass = luaL_checkinteger(L, 3); + glStencilOp(sfail, dpfail, dppass); + return 0; +} + + +int glStencilOpSeparate_bind(lua_State *L) +{ + GLenum face = luaL_checkinteger(L, 1); + GLenum sfail = luaL_checkinteger(L, 2); + GLenum dpfail = luaL_checkinteger(L, 3); + GLenum dppass = luaL_checkinteger(L, 4); + glStencilOpSeparate(face, sfail, dpfail, dppass); + return 0; +} + + diff --git a/src/opengl/bind/sigs b/src/opengl/bind/sigs new file mode 100644 index 0000000..60479df --- /dev/null +++ b/src/opengl/bind/sigs @@ -0,0 +1,445 @@ +void glActiveShaderProgram( GLuint pipeline, GLuint program); +void glActiveTexture( GLenum texture); +void glAttachShader( GLuint program, GLuint shader); +void glBeginConditionalRender( GLuint id, GLenum mode); +void glBeginQuery( GLenum target, GLuint id); +void glBeginQuery( GLenum target, GLuint id); +void glBeginTransformFeedback( GLenum primitiveMode); +void glBindAttribLocation( GLuint program, GLuint index, const GLchar *name); +void glBindBuffer( GLenum target, GLuint buffer); +void glBindBufferBase( GLenum target, GLuint index, GLuint buffer); +void glBindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +void glBindFragDataLocation( GLuint program, GLuint colorNumber, const char * name); +void glBindFragDataLocationIndexed( GLuint program, GLuint colorNumber, GLuint index, const char *name); +void glBindFramebuffer( GLenum target, GLuint framebuffer); +void glBindImageTexture( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +void glBindProgramPipeline( GLuint pipeline); +void glBindRenderbuffer( GLenum target, GLuint renderbuffer); +void glBindSampler( GLuint unit, GLuint sampler); +void glBindTexture( GLenum target, GLuint texture); +void glBindTextureUnit( GLuint unit, GLuint texture); +void glBindTransformFeedback( GLenum target, GLuint id); +void glBindVertexArray( GLuint array); +void glBindVertexBuffer( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); +void glBlendColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +void glBlendEquation( GLenum mode); + +void glBlendEquationi( GLuint buf, GLenum mode); +void glBlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha); +void glBlendEquationSeparatei( GLuint buf, GLenum modeRGB, GLenum modeAlpha); +void glBlendFunc( GLenum sfactor, GLenum dfactor); +void glBlendFunci( GLuint buf, GLenum sfactor, GLenum dfactor); +void glBlendFuncSeparate( GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void glBlendFuncSeparatei( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +void glBlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void glBlitNamedFramebuffer( GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +void glBufferData( GLenum target, GLsizeiptr size, const void * data, GLenum usage); +void glBufferStorage( GLenum target, GLsizeiptr size, const void * data, GLbitfield flags); +void glBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const void * data); +GLenum glCheckFramebufferStatus( GLenum target); +GLenum glCheckNamedFramebufferStatus( GLuint framebuffer, GLenum target); +void glClampColor( GLenum target, GLenum clamp); +void glClear( GLbitfield mask); +void glClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint * value); +void glClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint * value); +void glClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat * value); +void glClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +void glClearStencil( GLint s); +GLenum glClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout); +void glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void glColorMaski( GLuint buf, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +void glCompileShader( GLuint shader); +void glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data); +void glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data); +void glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data); +void glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data); +void glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data); +void glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data); +void glCopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void glCopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +void glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +void glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +void glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +void glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +void glCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLuint glCreateProgram( void); +GLuint glCreateShader( GLenum shaderType); +GLuint glCreateShaderProgramv( GLenum type, GLsizei count, const char **strings); +void glCullFace( GLenum mode); + +void glDeleteBuffers( GLsizei n, const GLuint * buffers); +void glDeleteFramebuffers( GLsizei n, GLuint *framebuffers); +void glDeleteProgram( GLuint program); +void glDeleteProgramPipelines( GLsizei n, const GLuint *pipelines); +void glDeleteQueries( GLsizei n, const GLuint * ids); +void glDeleteRenderbuffers( GLsizei n, GLuint *renderbuffers); +void glDeleteSamplers( GLsizei n, const GLuint * samplers); +void glDeleteShader( GLuint shader); +void glDeleteSync( GLsync sync); +void glDeleteTextures( GLsizei n, const GLuint * textures); +void glDeleteTransformFeedbacks( GLsizei n, const GLuint *ids); +void glDeleteVertexArrays( GLsizei n, const GLuint *arrays); +void glDepthFunc( GLenum func); +void glDepthMask( GLboolean flag); +void glDepthRange( GLdouble nearVal, GLdouble farVal); +void glDepthRangef( GLfloat nearVal, GLfloat farVal); +void glDepthRangeArrayv( GLuint first, GLsizei count, const GLdouble *v); +void glDepthRangeIndexed( GLuint index, GLdouble nearVal, GLdouble farVal); +void glDetachShader( GLuint program, GLuint shader); +void glDisable( GLenum cap); +void glDisablei( GLenum cap, GLuint index); +void glDisableVertexAttribArray( GLuint index); +void glDrawArrays( GLenum mode, GLint first, GLsizei count); +void glDrawArraysIndirect( GLenum mode, const void *indirect); +void glDrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +void glDrawBuffer( GLenum buf); +void glDrawBuffers( GLsizei n, const GLenum *bufs); +void glDrawElements( GLenum mode, GLsizei count, GLenum type, const void * indices); +void glDrawElementsBaseVertex( GLenum mode, GLsizei count, GLenum type, void *indices, GLint basevertex); +void glDrawElementsIndirect( GLenum mode, GLenum type, const void *indirect); +void glDrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount); +void glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices); +void glDrawRangeElementsBaseVertex( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, void *indices, GLint basevertex); +void glDrawTransformFeedback( GLenum mode, GLuint id); +void glDrawTransformFeedbackStream( GLenum mode, GLuint id, GLuint stream); + +void glEnable( GLenum cap); +void glEnablei( GLenum cap, GLuint index); +void glEnableVertexAttribArray( GLuint index); +void glEndConditionalRender( void); +void glEndQuery( GLenum target); +void glEndQueryIndexed( GLenum target, GLuint index); +void glEndTransformFeedback(); +GLsync glFenceSync( GLenum condition, GLbitfield flags); +void glFinish( void); +void glFlush( void); +void glFlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length); +void glFramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +void glFramebufferTexture( GLenum target, GLenum attachment, GLuint texture, GLint level); +void glFramebufferTexture1D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void glFramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +void glFramebufferTexture3D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer); +void glFramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +void glFrontFace( GLenum mode); +void glGenBuffers( GLsizei n, GLuint * buffers); +void glGenerateMipmap( GLenum target); +void glGenFramebuffers( GLsizei n, GLuint *ids); +void glGenProgramPipelines( GLsizei n, GLuint *pipelines); +void glGenQueries( GLsizei n, GLuint * ids); +void glGenRenderbuffers( GLsizei n, GLuint *renderbuffers); +void glGenSamplers( GLsizei n, GLuint *samplers); +void glGenTextures( GLsizei n, GLuint * textures); +void glGenTransformFeedbacks( GLsizei n, GLuint *ids); +void glGenVertexArrays( GLsizei n, GLuint *arrays); +void glGetBooleanv( GLenum pname, GLboolean * data); +void glGetDoublev( GLenum pname, GLdouble * data); +void glGetFloatv( GLenum pname, GLfloat * data); +void glGetIntegerv( GLenum pname, GLint * data); +void glGetInteger64v( GLenum pname, GLint64 * data); +void glGetBooleani_v( GLenum target, GLuint index, GLboolean * data); +void glGetIntegeri_v( GLenum target, GLuint index, GLint * data); +void glGetFloati_v( GLenum target, GLuint index, GLfloat * data); +void glGetDoublei_v( GLenum target, GLuint index, GLdouble * data); +void glGetInteger64i_v( GLenum target, GLuint index, GLint64 * data); +void glGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +void glGetActiveSubroutineName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name); +void glGetActiveSubroutineUniformiv( GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values); +void glGetActiveSubroutineUniformName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name); +void glGetActiveUniform( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +void glGetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +void glGetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +void glGetActiveUniformName( GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +void glGetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +void glGetAttachedShaders( GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLint glGetAttribLocation( GLuint program, const GLchar *name); +void glGetBufferParameteriv( GLenum target, GLenum value, GLint * data); +void glGetBufferParameteri64v( GLenum target, GLenum value, GLint64 * data); +void glGetBufferPointerv( GLenum target, GLenum pname, void ** params); +void glGetBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, void * data); +void glGetCompressedTexImage( GLenum target, GLint level, void * pixels); +GLenum glGetError( void); +GLint glGetFragDataIndex( GLuint program, const char * name); +GLint glGetFragDataLocation( GLuint program, const char * name); +void glGetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint *params); +void glGetMultisamplefv( GLenum pname, GLuint index, GLfloat *val); +void glGetUniformfv( GLuint program, GLint location, GLfloat *params); +void glGetUniformiv( GLuint program, GLint location, GLint *params); +void glGetUniformuiv( GLuint program, GLint location, GLuint *params); +void glGetUniformdv( GLuint program, GLint location, GLdouble *params); +void glGetProgramiv( GLuint program, GLenum pname, GLint *params); +void glGetProgramBinary( GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary); +void glGetProgramInfoLog( GLuint program, GLsizei maxLength, GLsizei *length, GLchar *infoLog); +void glGetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint *params); +void glGetProgramPipelineInfoLog( GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +void glGetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint *params); +void glGetProgramStageiv( GLuint program, GLenum shadertype, GLenum pname, GLint *values); +void glGetQueryIndexediv( GLenum target, GLuint index, GLenum pname, GLint * params); +void glGetQueryiv( GLenum target, GLenum pname, GLint * params); +void glGetRenderbufferParameteriv( GLenum target, GLenum pname, GLint *params); +void glGetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat * params); +void glGetSamplerParameteriv( GLuint sampler, GLenum pname, GLint * params); +void glGetSamplerParameterIiv( GLuint sampler, GLenum pname, GLint * params); +void glGetSamplerParameterIuiv( GLuint sampler, GLenum pname, GLuint * params); +void glGetShaderiv( GLuint shader, GLenum pname, GLint *params); +void glGetShaderInfoLog( GLuint shader, GLsizei maxLength, GLsizei *length, GLchar *infoLog); +void glGetShaderiv( GLuint shader, GLenum pname, GLint *params); +void glGetShaderPrecisionFormat( GLenum shaderType, GLenum precisionType, GLint *range, GLint *precision); +void glGetShaderSource( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +const GLubyte * glGetString(GLenum name); +const GLubyte * glGetStringi(GLenum name, GLuint index); +GLuint glGetSubroutineIndex( GLuint program, GLenum shadertype, const GLchar *name); +GLint glGetSubroutineUniformLocation( GLuint program, GLenum shadertype, const GLchar *name); +void glGetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values); +void glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +void glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat * params); +void glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint * params); +void glGetTexParameterfv( GLenum target, GLenum pname, GLfloat * params); +void glGetTexParameteriv( GLenum target, GLenum pname, GLint * params); +void glGetTexParameterIiv( GLenum target, GLenum pname, GLint * params); +void glGetTexParameterIuiv( GLenum target, GLenum pname, GLuint * params); +void glGetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, char *name); +GLuint glGetUniformBlockIndex( GLuint program, const GLchar *uniformBlockName); +void glGetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar **uniformNames, GLuint *uniformIndices); +GLint glGetUniformLocation( GLuint program, const GLchar *name); +void glGetUniformSubroutineuiv( GLenum shadertype, GLint location, GLuint *values); +void glGetVertexAttribdv( GLuint index, GLenum pname, GLdouble *params); +void glGetVertexAttribfv( GLuint index, GLenum pname, GLfloat *params); +void glGetVertexAttribiv( GLuint index, GLenum pname, GLint *params); +void glGetVertexAttribIiv( GLuint index, GLenum pname, GLint *params); +void glGetVertexAttribIuiv( GLuint index, GLenum pname, GLuint *params); +void glGetVertexAttribLdv( GLuint index, GLenum pname, GLdouble *params); +void glGetVertexAttribPointerv( GLuint index, GLenum pname, void **pointer); +void glHint( GLenum target, GLenum mode); +GLboolean glIsBuffer( GLuint buffer); +GLboolean glIsEnabled( GLenum cap); +GLboolean glIsEnabledi( GLenum cap, GLuint index); +GLboolean glIsFramebuffer( GLuint framebuffer); +GLboolean glIsProgram( GLuint program); +GLboolean glIsProgramPipeline( GLuint pipeline); +GLboolean glIsQuery( GLuint id); +GLboolean glIsRenderbuffer( GLuint renderbuffer); +GLboolean glIsSampler( GLuint id); +GLboolean glIsShader( GLuint shader); +GLboolean glIsSync( GLsync sync); +GLboolean glIsTexture( GLuint texture); +GLboolean glIsTransformFeedback( GLuint id); +GLboolean glIsVertexArray( GLuint array); +void glLineWidth( GLfloat width); +void glLinkProgram( GLuint program); +void glLogicOp( GLenum opcode); + +void * glMapBuffer( GLenum target, GLenum access); +void * glMapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +void glMinSampleShading( GLfloat value); +void glMultiDrawArrays( GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount); +void glMultiDrawElements( GLenum mode, const GLsizei * count, GLenum type, const void * const * indices, GLsizei drawcount); +void glMultiDrawElementsBaseVertex( GLenum mode, const GLsizei *count, GLenum type, const void * const *indices, GLsizei drawcount, const GLint *basevertex); + +void glPatchParameteri( GLenum pname, GLint value); +void glPatchParameterfv( GLenum pname, const GLfloat *values); +void glPauseTransformFeedback( void); +void glPixelStoref( GLenum pname, GLfloat param); +void glPixelStorei( GLenum pname, GLint param); +void glPointParameterf( GLenum pname, GLfloat param); +void glPointParameteri( GLenum pname, GLint param); +void glPointParameterfv( GLenum pname, const GLfloat * params); +void glPointParameteriv( GLenum pname, const GLint * params); +void glPointSize( GLfloat size); +void glPolygonMode( GLenum face, GLenum mode); +void glPolygonOffset( GLfloat factor, GLfloat units); +void glPrimitiveRestartIndex( GLuint index); +void glProgramBinary( GLuint program, GLenum binaryFormat, const void *binary, GLsizei length); +void glProgramParameteri( GLuint program, GLenum pname, GLint value); +void glProgramUniform1f( GLuint program, GLint location, GLfloat v0); +void glProgramUniform2f( GLuint program, GLint location, GLfloat v0, GLfloat v1); +void glProgramUniform3f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void glProgramUniform4f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void glProgramUniform1i( GLuint program, GLint location, GLint v0); +void glProgramUniform2i( GLuint program, GLint location, GLint v0, GLint v1); +void glProgramUniform3i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +void glProgramUniform4i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void glProgramUniform1ui( GLuint program, GLint location, GLuint v0); +void glProgramUniform2ui( GLuint program, GLint location, GLuint v0, GLuint v1); +void glProgramUniform3ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +void glProgramUniform4ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void glProgramUniform1fv( GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform2fv( GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform3fv( GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform4fv( GLuint program, GLint location, GLsizei count, const GLfloat *value); +void glProgramUniform1iv( GLuint program, GLint location, GLsizei count, const GLint *value); +void glProgramUniform2iv( GLuint program, GLint location, GLsizei count, const GLint *value); +void glProgramUniform3iv( GLuint program, GLint location, GLsizei count, const GLint *value); +void glProgramUniform4iv( GLuint program, GLint location, GLsizei count, const GLint *value); +void glProgramUniform1uiv( GLuint program, GLint location, GLsizei count, const GLuint *value); +void glProgramUniform2uiv( GLuint program, GLint location, GLsizei count, const GLuint *value); +void glProgramUniform3uiv( GLuint program, GLint location, GLsizei count, const GLuint *value); +void glProgramUniform4uiv( GLuint program, GLint location, GLsizei count, const GLuint *value); +void glProgramUniformMatrix2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix2x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix3x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix2x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix4x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix3x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProgramUniformMatrix4x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glProvokingVertex( GLenum provokeMode); + +void glQueryCounter( GLuint id, GLenum target); +void glReadBuffer( GLenum mode); +void glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * data); +void glReleaseShaderCompiler( void); +void glRenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +void glRenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +void glResumeTransformFeedback( void); +void glSampleCoverage( GLfloat value, GLboolean invert); +void glSampleMaski( GLuint maskNumber, GLbitfield mask); +void glSamplerParameterf( GLuint sampler, GLenum pname, GLfloat param); +void glSamplerParameteri( GLuint sampler, GLenum pname, GLint param); +void glSamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat * params); +void glSamplerParameteriv( GLuint sampler, GLenum pname, const GLint * params); +void glSamplerParameterIiv( GLuint sampler, GLenum pname, const GLint *params); +void glSamplerParameterIuiv( GLuint sampler, GLenum pname, const GLuint *params); +void glScissor( GLint x, GLint y, GLsizei width, GLsizei height); +void glScissorArrayv( GLuint first, GLsizei count, const GLint *v); +void glScissorIndexed( GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +void glScissorIndexedv( GLuint index, const GLint *v); +void glShaderBinary( GLsizei count, const GLuint *shaders, GLenum binaryFormat, const void *binary, GLsizei length); +void glShaderSource( GLuint shader, GLsizei count, const GLchar **string, const GLint *length); +void glStencilFunc( GLenum func, GLint ref, GLuint mask); +void glStencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask); +void glStencilMask( GLuint mask); +void glStencilMaskSeparate( GLenum face, GLuint mask); +void glStencilOp( GLenum sfail, GLenum dpfail, GLenum dppass); +void glStencilOpSeparate( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); + +void glTexBuffer( GLenum target, GLenum internalformat, GLuint buffer); +void glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * data); +void glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * data); +void glTexImage2DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * data); +void glTexImage3DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void glTexParameterf( GLenum target, GLenum pname, GLfloat param); +void glTexParameteri( GLenum target, GLenum pname, GLint param); +void glTexParameterfv( GLenum target, GLenum pname, const GLfloat * params); +void glTexParameteriv( GLenum target, GLenum pname, const GLint * params); +void glTexParameterIiv( GLenum target, GLenum pname, const GLint * params); +void glTexParameterIuiv( GLenum target, GLenum pname, const GLuint * params); +void glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); +void glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +void glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); +void glTransformFeedbackVaryings( GLuint program, GLsizei count, const char **varyings, GLenum bufferMode); +void glUniform1f( GLint location, GLfloat v0); +void glUniform2f( GLint location, GLfloat v0, GLfloat v1); +void glUniform3f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void glUniform4f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void glUniform1i( GLint location, GLint v0); +void glUniform2i( GLint location, GLint v0, GLint v1); +void glUniform3i( GLint location, GLint v0, GLint v1, GLint v2); +void glUniform4i( GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void glUniform1ui( GLint location, GLuint v0); +void glUniform2ui( GLint location, GLuint v0, GLuint v1); +void glUniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2); +void glUniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void glUniform1fv( GLint location, GLsizei count, const GLfloat *value); +void glUniform2fv( GLint location, GLsizei count, const GLfloat *value); +void glUniform3fv( GLint location, GLsizei count, const GLfloat *value); +void glUniform4fv( GLint location, GLsizei count, const GLfloat *value); +void glUniform1iv( GLint location, GLsizei count, const GLint *value); +void glUniform2iv( GLint location, GLsizei count, const GLint *value); +void glUniform3iv( GLint location, GLsizei count, const GLint *value); +void glUniform4iv( GLint location, GLsizei count, const GLint *value); +void glUniform1uiv( GLint location, GLsizei count, const GLuint *value); +void glUniform2uiv( GLint location, GLsizei count, const GLuint *value); +void glUniform3uiv( GLint location, GLsizei count, const GLuint *value); +void glUniform4uiv( GLint location, GLsizei count, const GLuint *value); +void glUniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformSubroutinesuiv( GLenum shadertype, GLsizei count, const GLuint *indices); +GLboolean glUnmapBuffer( GLenum target); +void glUseProgram( GLuint program); +void glUseProgramStages( GLuint pipeline, GLbitfield stages, GLuint program); +void glValidateProgram( GLuint program); +void glValidateProgramPipeline( GLuint pipeline); +void glVertexAttrib1f( GLuint index, GLfloat v0); +void glVertexAttrib1s( GLuint index, GLshort v0); +void glVertexAttrib1d( GLuint index, GLdouble v0); +void glVertexAttribI1i( GLuint index, GLint v0); +void glVertexAttribI1ui( GLuint index, GLuint v0); +void glVertexAttrib2f( GLuint index, GLfloat v0, GLfloat v1); +void glVertexAttrib2s( GLuint index, GLshort v0, GLshort v1); +void glVertexAttrib2d( GLuint index, GLdouble v0, GLdouble v1); +void glVertexAttribI2i( GLuint index, GLint v0, GLint v1); +void glVertexAttribI2ui( GLuint index, GLuint v0, GLuint v1); +void glVertexAttrib3f( GLuint index, GLfloat v0, GLfloat v1, GLfloat v2); +void glVertexAttrib3s( GLuint index, GLshort v0, GLshort v1, GLshort v2); +void glVertexAttrib3d( GLuint index, GLdouble v0, GLdouble v1, GLdouble v2); +void glVertexAttribI3i( GLuint index, GLint v0, GLint v1, GLint v2); +void glVertexAttribI3ui( GLuint index, GLuint v0, GLuint v1, GLuint v2); +void glVertexAttrib4f( GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void glVertexAttrib4s( GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3); +void glVertexAttrib4d( GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void glVertexAttrib4Nub( GLuint index, GLubyte v0, GLubyte v1, GLubyte v2, GLubyte v3); +void glVertexAttribI4i( GLuint index, GLint v0, GLint v1, GLint v2, GLint v3); +void glVertexAttribI4ui( GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void glVertexAttribL1d( GLuint index, GLdouble v0); +void glVertexAttribL2d( GLuint index, GLdouble v0, GLdouble v1); +void glVertexAttribL3d( GLuint index, GLdouble v0, GLdouble v1, GLdouble v2); +void glVertexAttribL4d( GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void glVertexAttrib1fv( GLuint index, const GLfloat *v); +void glVertexAttrib1sv( GLuint index, const GLshort *v); +void glVertexAttrib1dv( GLuint index, const GLdouble *v); +void glVertexAttribI1iv( GLuint index, const GLint *v); +void glVertexAttribI1uiv( GLuint index, const GLuint *v); +void glVertexAttrib2fv( GLuint index, const GLfloat *v); +void glVertexAttrib2sv( GLuint index, const GLshort *v); +void glVertexAttrib2dv( GLuint index, const GLdouble *v); +void glVertexAttribI2iv( GLuint index, const GLint *v); +void glVertexAttribI2uiv( GLuint index, const GLuint *v); +void glVertexAttrib3fv( GLuint index, const GLfloat *v); +void glVertexAttrib3sv( GLuint index, const GLshort *v); +void glVertexAttrib3dv( GLuint index, const GLdouble *v); +void glVertexAttribI3iv( GLuint index, const GLint *v); +void glVertexAttribI3uiv( GLuint index, const GLuint *v); +void glVertexAttrib4fv( GLuint index, const GLfloat *v); +void glVertexAttrib4sv( GLuint index, const GLshort *v); +void glVertexAttrib4dv( GLuint index, const GLdouble *v); +void glVertexAttrib4iv( GLuint index, const GLint *v); +void glVertexAttrib4bv( GLuint index, const GLbyte *v); +void glVertexAttrib4ubv( GLuint index, const GLubyte *v); +void glVertexAttrib4usv( GLuint index, const GLushort *v); +void glVertexAttrib4uiv( GLuint index, const GLuint *v); +void glVertexAttrib4Nbv( GLuint index, const GLbyte *v); +void glVertexAttrib4Nsv( GLuint index, const GLshort *v); +void glVertexAttrib4Niv( GLuint index, const GLint *v); +void glVertexAttrib4Nubv( GLuint index, const GLubyte *v); +void glVertexAttrib4Nusv( GLuint index, const GLushort *v); +void glVertexAttrib4Nuiv( GLuint index, const GLuint *v); +void glVertexAttribI4bv( GLuint index, const GLbyte *v); +void glVertexAttribI4ubv( GLuint index, const GLubyte *v); +void glVertexAttribI4sv( GLuint index, const GLshort *v); +void glVertexAttribI4usv( GLuint index, const GLushort *v); +void glVertexAttribI4iv( GLuint index, const GLint *v); +void glVertexAttribI4uiv( GLuint index, const GLuint *v); +void glVertexAttribL1dv( GLuint index, const GLdouble *v); +void glVertexAttribL2dv( GLuint index, const GLdouble *v); +void glVertexAttribL3dv( GLuint index, const GLdouble *v); +void glVertexAttribL4dv( GLuint index, const GLdouble *v); +void glVertexAttribP1ui( GLuint index, GLenum type, GLboolean normalized, GLuint value); +void glVertexAttribP2ui( GLuint index, GLenum type, GLboolean normalized, GLuint value); +void glVertexAttribP3ui( GLuint index, GLenum type, GLboolean normalized, GLuint value); +void glVertexAttribP4ui( GLuint index, GLenum type, GLboolean normalized, GLuint value); +void glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); +void glVertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer); +void glViewport( GLint x, GLint y, GLsizei width, GLsizei height); +void glViewportArrayv( GLuint first, GLsizei count, const GLfloat *v); +void glViewportIndexedf( GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +void glViewportIndexedfv( GLuint index, const GLfloat *v); +void glWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout); diff --git a/src/opengl/bind/t b/src/opengl/bind/t new file mode 100644 index 0000000..d503c1e --- /dev/null +++ b/src/opengl/bind/t @@ -0,0 +1,16 @@ +void glTexBuffer( GLenum target, GLenum internalformat, GLuint buffer); +void glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * data); +void glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * data); +void glTexImage2DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +void glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * data); +void glTexImage3DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +void glTexParameterf( GLenum target, GLenum pname, GLfloat param); +void glTexParameteri( GLenum target, GLenum pname, GLint param); +void glTexParameterfv( GLenum target, GLenum pname, const GLfloat * params); +void glTexParameteriv( GLenum target, GLenum pname, const GLint * params); +void glTexParameterIiv( GLenum target, GLenum pname, const GLint * params); +void glTexParameterIuiv( GLenum target, GLenum pname, const GLuint * params); +void glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); +void glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +void glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); +void glTransformFeedbackVaryings( GLuint program, GLsizei count, const char **varyings, GLenum bufferMode); diff --git a/src/opengl/bind/t.bind b/src/opengl/bind/t.bind new file mode 100644 index 0000000..1a447e7 --- /dev/null +++ b/src/opengl/bind/t.bind @@ -0,0 +1,204 @@ +int glTexBuffer_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum internalformat = luaL_checkinteger(L, 2); + GLuint buffer = luaL_checkinteger(L, 3); + glTexBuffer(target, internalformat, buffer); + return 0; +} + + +int glTexImage1D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint internalformat = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLint border = luaL_checkinteger(L, 5); + GLenum format = luaL_checkinteger(L, 6); + GLenum type = luaL_checkinteger(L, 7); + const void * data = get: const void * + glTexImage1D(target, level, internalformat, width, border, format, type, data); + return 0; +} + + +int glTexImage2D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint internalformat = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLsizei height = luaL_checkinteger(L, 5); + GLint border = luaL_checkinteger(L, 6); + GLenum format = luaL_checkinteger(L, 7); + GLenum type = luaL_checkinteger(L, 8); + const void * data = get: const void * + glTexImage2D(target, level, internalformat, width, height, border, format, type, data); + return 0; +} + + +int glTexImage2DMultisample_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLsizei samples = luaL_checkinteger(L, 2); + GLenum internalformat = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLsizei height = luaL_checkinteger(L, 5); + GLboolean fixedsamplelocations = get: GLboolean + glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); + return 0; +} + + +int glTexImage3D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint internalformat = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLsizei height = luaL_checkinteger(L, 5); + GLsizei depth = luaL_checkinteger(L, 6); + GLint border = luaL_checkinteger(L, 7); + GLenum format = luaL_checkinteger(L, 8); + GLenum type = luaL_checkinteger(L, 9); + const void * data = get: const void * + glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, data); + return 0; +} + + +int glTexImage3DMultisample_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLsizei samples = luaL_checkinteger(L, 2); + GLenum internalformat = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLsizei height = luaL_checkinteger(L, 5); + GLsizei depth = luaL_checkinteger(L, 6); + GLboolean fixedsamplelocations = get: GLboolean + glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); + return 0; +} + + +int glTexParameterf_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLfloat param = luaL_checknumber(L, 3); + glTexParameterf(target, pname, param); + return 0; +} + + +int glTexParameteri_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + GLint param = luaL_checkinteger(L, 3); + glTexParameteri(target, pname, param); + return 0; +} + + +int glTexParameterfv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + const GLfloat * params = get: const GLfloat * + glTexParameterfv(target, pname, params); + return 0; +} + + +int glTexParameteriv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + const GLint * params = get: const GLint * + glTexParameteriv(target, pname, params); + return 0; +} + + +int glTexParameterIiv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + const GLint * params = get: const GLint * + glTexParameterIiv(target, pname, params); + return 0; +} + + +int glTexParameterIuiv_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLenum pname = luaL_checkinteger(L, 2); + const GLuint * params = get: const GLuint * + glTexParameterIuiv(target, pname, params); + return 0; +} + + +int glTexSubImage1D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint xoffset = luaL_checkinteger(L, 3); + GLsizei width = luaL_checkinteger(L, 4); + GLenum format = luaL_checkinteger(L, 5); + GLenum type = luaL_checkinteger(L, 6); + const void * pixels = get: const void * + glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + return 0; +} + + +int glTexSubImage2D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint xoffset = luaL_checkinteger(L, 3); + GLint yoffset = luaL_checkinteger(L, 4); + GLsizei width = luaL_checkinteger(L, 5); + GLsizei height = luaL_checkinteger(L, 6); + GLenum format = luaL_checkinteger(L, 7); + GLenum type = luaL_checkinteger(L, 8); + const void * pixels = get: const void * + glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + return 0; +} + + +int glTexSubImage3D_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLint level = luaL_checkinteger(L, 2); + GLint xoffset = luaL_checkinteger(L, 3); + GLint yoffset = luaL_checkinteger(L, 4); + GLint zoffset = luaL_checkinteger(L, 5); + GLsizei width = luaL_checkinteger(L, 6); + GLsizei height = luaL_checkinteger(L, 7); + GLsizei depth = luaL_checkinteger(L, 8); + GLenum format = luaL_checkinteger(L, 9); + GLenum type = luaL_checkinteger(L, 10); + const void * pixels = get: const void * + glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + return 0; +} + + +int glTransformFeedbackVaryings_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const char ** varyings = get: const char ** + GLenum bufferMode = luaL_checkinteger(L, 4); + glTransformFeedbackVaryings(program, count, varyings, bufferMode); + return 0; +} + + diff --git a/src/opengl/bind/u b/src/opengl/bind/u new file mode 100644 index 0000000..7cd3e42 --- /dev/null +++ b/src/opengl/bind/u @@ -0,0 +1,37 @@ +void glUniform1f( GLint location, GLfloat v0); +void glUniform2f( GLint location, GLfloat v0, GLfloat v1); +void glUniform3f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +void glUniform4f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void glUniform1i( GLint location, GLint v0); +void glUniform2i( GLint location, GLint v0, GLint v1); +void glUniform3i( GLint location, GLint v0, GLint v1, GLint v2); +void glUniform4i( GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +void glUniform1ui( GLint location, GLuint v0); +void glUniform2ui( GLint location, GLuint v0, GLuint v1); +void glUniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2); +void glUniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void glUniform1fv( GLint location, GLsizei count, const GLfloat *value); +void glUniform2fv( GLint location, GLsizei count, const GLfloat *value); +void glUniform3fv( GLint location, GLsizei count, const GLfloat *value); +void glUniform4fv( GLint location, GLsizei count, const GLfloat *value); +void glUniform1iv( GLint location, GLsizei count, const GLint *value); +void glUniform2iv( GLint location, GLsizei count, const GLint *value); +void glUniform3iv( GLint location, GLsizei count, const GLint *value); +void glUniform4iv( GLint location, GLsizei count, const GLint *value); +void glUniform1uiv( GLint location, GLsizei count, const GLuint *value); +void glUniform2uiv( GLint location, GLsizei count, const GLuint *value); +void glUniform3uiv( GLint location, GLsizei count, const GLuint *value); +void glUniform4uiv( GLint location, GLsizei count, const GLuint *value); +void glUniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +void glUniformSubroutinesuiv( GLenum shadertype, GLsizei count, const GLuint *indices); +GLboolean glUnmapBuffer( GLenum target); +void glUseProgram( GLuint program); +void glUseProgramStages( GLuint pipeline, GLbitfield stages, GLuint program); diff --git a/src/opengl/bind/u.bind b/src/opengl/bind/u.bind new file mode 100644 index 0000000..07785a8 --- /dev/null +++ b/src/opengl/bind/u.bind @@ -0,0 +1,382 @@ +int glUniform1f_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLfloat v0 = luaL_checknumber(L, 2); + glUniform1f(location, v0); + return 0; +} + + +int glUniform2f_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLfloat v0 = luaL_checknumber(L, 2); + GLfloat v1 = luaL_checknumber(L, 3); + glUniform2f(location, v0, v1); + return 0; +} + + +int glUniform3f_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLfloat v0 = luaL_checknumber(L, 2); + GLfloat v1 = luaL_checknumber(L, 3); + GLfloat v2 = luaL_checknumber(L, 4); + glUniform3f(location, v0, v1, v2); + return 0; +} + + +int glUniform4f_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLfloat v0 = luaL_checknumber(L, 2); + GLfloat v1 = luaL_checknumber(L, 3); + GLfloat v2 = luaL_checknumber(L, 4); + GLfloat v3 = luaL_checknumber(L, 5); + glUniform4f(location, v0, v1, v2, v3); + return 0; +} + + +int glUniform1i_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLint v0 = luaL_checkinteger(L, 2); + glUniform1i(location, v0); + return 0; +} + + +int glUniform2i_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLint v0 = luaL_checkinteger(L, 2); + GLint v1 = luaL_checkinteger(L, 3); + glUniform2i(location, v0, v1); + return 0; +} + + +int glUniform3i_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLint v0 = luaL_checkinteger(L, 2); + GLint v1 = luaL_checkinteger(L, 3); + GLint v2 = luaL_checkinteger(L, 4); + glUniform3i(location, v0, v1, v2); + return 0; +} + + +int glUniform4i_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLint v0 = luaL_checkinteger(L, 2); + GLint v1 = luaL_checkinteger(L, 3); + GLint v2 = luaL_checkinteger(L, 4); + GLint v3 = luaL_checkinteger(L, 5); + glUniform4i(location, v0, v1, v2, v3); + return 0; +} + + +int glUniform1ui_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLuint v0 = luaL_checkinteger(L, 2); + glUniform1ui(location, v0); + return 0; +} + + +int glUniform2ui_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLuint v0 = luaL_checkinteger(L, 2); + GLuint v1 = luaL_checkinteger(L, 3); + glUniform2ui(location, v0, v1); + return 0; +} + + +int glUniform3ui_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLuint v0 = luaL_checkinteger(L, 2); + GLuint v1 = luaL_checkinteger(L, 3); + GLuint v2 = luaL_checkinteger(L, 4); + glUniform3ui(location, v0, v1, v2); + return 0; +} + + +int glUniform4ui_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLuint v0 = luaL_checkinteger(L, 2); + GLuint v1 = luaL_checkinteger(L, 3); + GLuint v2 = luaL_checkinteger(L, 4); + GLuint v3 = luaL_checkinteger(L, 5); + glUniform4ui(location, v0, v1, v2, v3); + return 0; +} + + +int glUniform1fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLfloat * value = get: const GLfloat * + glUniform1fv(location, count, value); + return 0; +} + + +int glUniform2fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLfloat * value = get: const GLfloat * + glUniform2fv(location, count, value); + return 0; +} + + +int glUniform3fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLfloat * value = get: const GLfloat * + glUniform3fv(location, count, value); + return 0; +} + + +int glUniform4fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLfloat * value = get: const GLfloat * + glUniform4fv(location, count, value); + return 0; +} + + +int glUniform1iv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLint * value = get: const GLint * + glUniform1iv(location, count, value); + return 0; +} + + +int glUniform2iv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLint * value = get: const GLint * + glUniform2iv(location, count, value); + return 0; +} + + +int glUniform3iv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLint * value = get: const GLint * + glUniform3iv(location, count, value); + return 0; +} + + +int glUniform4iv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLint * value = get: const GLint * + glUniform4iv(location, count, value); + return 0; +} + + +int glUniform1uiv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLuint * value = get: const GLuint * + glUniform1uiv(location, count, value); + return 0; +} + + +int glUniform2uiv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLuint * value = get: const GLuint * + glUniform2uiv(location, count, value); + return 0; +} + + +int glUniform3uiv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLuint * value = get: const GLuint * + glUniform3uiv(location, count, value); + return 0; +} + + +int glUniform4uiv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLuint * value = get: const GLuint * + glUniform4uiv(location, count, value); + return 0; +} + + +int glUniformMatrix2fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glUniformMatrix2fv(location, count, transpose, value); + return 0; +} + + +int glUniformMatrix3fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glUniformMatrix3fv(location, count, transpose, value); + return 0; +} + + +int glUniformMatrix4fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glUniformMatrix4fv(location, count, transpose, value); + return 0; +} + + +int glUniformMatrix2x3fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glUniformMatrix2x3fv(location, count, transpose, value); + return 0; +} + + +int glUniformMatrix3x2fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glUniformMatrix3x2fv(location, count, transpose, value); + return 0; +} + + +int glUniformMatrix2x4fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glUniformMatrix2x4fv(location, count, transpose, value); + return 0; +} + + +int glUniformMatrix4x2fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glUniformMatrix4x2fv(location, count, transpose, value); + return 0; +} + + +int glUniformMatrix3x4fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glUniformMatrix3x4fv(location, count, transpose, value); + return 0; +} + + +int glUniformMatrix4x3fv_bind(lua_State *L) +{ + GLint location = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + GLboolean transpose = get: GLboolean + const GLfloat * value = get: const GLfloat * + glUniformMatrix4x3fv(location, count, transpose, value); + return 0; +} + + +int glUniformSubroutinesuiv_bind(lua_State *L) +{ + GLenum shadertype = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLuint * indices = get: const GLuint * + glUniformSubroutinesuiv(shadertype, count, indices); + return 0; +} + + +int glUnmapBuffer_bind(lua_State *L) +{ + GLenum target = luaL_checkinteger(L, 1); + GLboolean bind_result = glUnmapBuffer(target); + /* push result */ + return /* count */; +} + + +int glUseProgram_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + glUseProgram(program); + return 0; +} + + +int glUseProgramStages_bind(lua_State *L) +{ + GLuint pipeline = luaL_checkinteger(L, 1); + GLbitfield stages = luaL_checkinteger(L, 2); + GLuint program = luaL_checkinteger(L, 3); + glUseProgramStages(pipeline, stages, program); + return 0; +} + + diff --git a/src/opengl/bind/v b/src/opengl/bind/v new file mode 100644 index 0000000..d6bb3aa --- /dev/null +++ b/src/opengl/bind/v @@ -0,0 +1,76 @@ +void glValidateProgram( GLuint program); +void glValidateProgramPipeline( GLuint pipeline); +void glVertexAttrib1f( GLuint index, GLfloat v0); +void glVertexAttrib1s( GLuint index, GLshort v0); +void glVertexAttrib1d( GLuint index, GLdouble v0); +void glVertexAttribI1i( GLuint index, GLint v0); +void glVertexAttribI1ui( GLuint index, GLuint v0); +void glVertexAttrib2f( GLuint index, GLfloat v0, GLfloat v1); +void glVertexAttrib2s( GLuint index, GLshort v0, GLshort v1); +void glVertexAttrib2d( GLuint index, GLdouble v0, GLdouble v1); +void glVertexAttribI2i( GLuint index, GLint v0, GLint v1); +void glVertexAttribI2ui( GLuint index, GLuint v0, GLuint v1); +void glVertexAttrib3f( GLuint index, GLfloat v0, GLfloat v1, GLfloat v2); +void glVertexAttrib3s( GLuint index, GLshort v0, GLshort v1, GLshort v2); +void glVertexAttrib3d( GLuint index, GLdouble v0, GLdouble v1, GLdouble v2); +void glVertexAttribI3i( GLuint index, GLint v0, GLint v1, GLint v2); +void glVertexAttribI3ui( GLuint index, GLuint v0, GLuint v1, GLuint v2); +void glVertexAttrib4f( GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +void glVertexAttrib4s( GLuint index, GLshort v0, GLshort v1, GLshort v2, GLshort v3); +void glVertexAttrib4d( GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void glVertexAttrib4Nub( GLuint index, GLubyte v0, GLubyte v1, GLubyte v2, GLubyte v3); +void glVertexAttribI4i( GLuint index, GLint v0, GLint v1, GLint v2, GLint v3); +void glVertexAttribI4ui( GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +void glVertexAttribL1d( GLuint index, GLdouble v0); +void glVertexAttribL2d( GLuint index, GLdouble v0, GLdouble v1); +void glVertexAttribL3d( GLuint index, GLdouble v0, GLdouble v1, GLdouble v2); +void glVertexAttribL4d( GLuint index, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +void glVertexAttrib1fv( GLuint index, const GLfloat *v); +void glVertexAttrib1sv( GLuint index, const GLshort *v); +void glVertexAttrib1dv( GLuint index, const GLdouble *v); +void glVertexAttribI1iv( GLuint index, const GLint *v); +void glVertexAttribI1uiv( GLuint index, const GLuint *v); +void glVertexAttrib2fv( GLuint index, const GLfloat *v); +void glVertexAttrib2sv( GLuint index, const GLshort *v); +void glVertexAttrib2dv( GLuint index, const GLdouble *v); +void glVertexAttribI2iv( GLuint index, const GLint *v); +void glVertexAttribI2uiv( GLuint index, const GLuint *v); +void glVertexAttrib3fv( GLuint index, const GLfloat *v); +void glVertexAttrib3sv( GLuint index, const GLshort *v); +void glVertexAttrib3dv( GLuint index, const GLdouble *v); +void glVertexAttribI3iv( GLuint index, const GLint *v); +void glVertexAttribI3uiv( GLuint index, const GLuint *v); +void glVertexAttrib4fv( GLuint index, const GLfloat *v); +void glVertexAttrib4sv( GLuint index, const GLshort *v); +void glVertexAttrib4dv( GLuint index, const GLdouble *v); +void glVertexAttrib4iv( GLuint index, const GLint *v); +void glVertexAttrib4bv( GLuint index, const GLbyte *v); +void glVertexAttrib4ubv( GLuint index, const GLubyte *v); +void glVertexAttrib4usv( GLuint index, const GLushort *v); +void glVertexAttrib4uiv( GLuint index, const GLuint *v); +void glVertexAttrib4Nbv( GLuint index, const GLbyte *v); +void glVertexAttrib4Nsv( GLuint index, const GLshort *v); +void glVertexAttrib4Niv( GLuint index, const GLint *v); +void glVertexAttrib4Nubv( GLuint index, const GLubyte *v); +void glVertexAttrib4Nusv( GLuint index, const GLushort *v); +void glVertexAttrib4Nuiv( GLuint index, const GLuint *v); +void glVertexAttribI4bv( GLuint index, const GLbyte *v); +void glVertexAttribI4ubv( GLuint index, const GLubyte *v); +void glVertexAttribI4sv( GLuint index, const GLshort *v); +void glVertexAttribI4usv( GLuint index, const GLushort *v); +void glVertexAttribI4iv( GLuint index, const GLint *v); +void glVertexAttribI4uiv( GLuint index, const GLuint *v); +void glVertexAttribL1dv( GLuint index, const GLdouble *v); +void glVertexAttribL2dv( GLuint index, const GLdouble *v); +void glVertexAttribL3dv( GLuint index, const GLdouble *v); +void glVertexAttribL4dv( GLuint index, const GLdouble *v); +void glVertexAttribP1ui( GLuint index, GLenum type, GLboolean normalized, GLuint value); +void glVertexAttribP2ui( GLuint index, GLenum type, GLboolean normalized, GLuint value); +void glVertexAttribP3ui( GLuint index, GLenum type, GLboolean normalized, GLuint value); +void glVertexAttribP4ui( GLuint index, GLenum type, GLboolean normalized, GLuint value); +void glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); +void glVertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer); +void glViewport( GLint x, GLint y, GLsizei width, GLsizei height); +void glViewportArrayv( GLuint first, GLsizei count, const GLfloat *v); +void glViewportIndexedf( GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +void glViewportIndexedfv( GLuint index, const GLfloat *v); diff --git a/src/opengl/bind/v.bind b/src/opengl/bind/v.bind new file mode 100644 index 0000000..ec35e3f --- /dev/null +++ b/src/opengl/bind/v.bind @@ -0,0 +1,742 @@ +int glValidateProgram_bind(lua_State *L) +{ + GLuint program = luaL_checkinteger(L, 1); + glValidateProgram(program); + return 0; +} + + +int glValidateProgramPipeline_bind(lua_State *L) +{ + GLuint pipeline = luaL_checkinteger(L, 1); + glValidateProgramPipeline(pipeline); + return 0; +} + + +int glVertexAttrib1f_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLfloat v0 = luaL_checknumber(L, 2); + glVertexAttrib1f(index, v0); + return 0; +} + + +int glVertexAttrib1s_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLshort v0 = luaL_checkinteger(L, 2); + glVertexAttrib1s(index, v0); + return 0; +} + + +int glVertexAttrib1d_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLdouble v0 = luaL_checknumber(L, 2); + glVertexAttrib1d(index, v0); + return 0; +} + + +int glVertexAttribI1i_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLint v0 = luaL_checkinteger(L, 2); + glVertexAttribI1i(index, v0); + return 0; +} + + +int glVertexAttribI1ui_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLuint v0 = luaL_checkinteger(L, 2); + glVertexAttribI1ui(index, v0); + return 0; +} + + +int glVertexAttrib2f_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLfloat v0 = luaL_checknumber(L, 2); + GLfloat v1 = luaL_checknumber(L, 3); + glVertexAttrib2f(index, v0, v1); + return 0; +} + + +int glVertexAttrib2s_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLshort v0 = luaL_checkinteger(L, 2); + GLshort v1 = luaL_checkinteger(L, 3); + glVertexAttrib2s(index, v0, v1); + return 0; +} + + +int glVertexAttrib2d_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLdouble v0 = luaL_checknumber(L, 2); + GLdouble v1 = luaL_checknumber(L, 3); + glVertexAttrib2d(index, v0, v1); + return 0; +} + + +int glVertexAttribI2i_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLint v0 = luaL_checkinteger(L, 2); + GLint v1 = luaL_checkinteger(L, 3); + glVertexAttribI2i(index, v0, v1); + return 0; +} + + +int glVertexAttribI2ui_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLuint v0 = luaL_checkinteger(L, 2); + GLuint v1 = luaL_checkinteger(L, 3); + glVertexAttribI2ui(index, v0, v1); + return 0; +} + + +int glVertexAttrib3f_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLfloat v0 = luaL_checknumber(L, 2); + GLfloat v1 = luaL_checknumber(L, 3); + GLfloat v2 = luaL_checknumber(L, 4); + glVertexAttrib3f(index, v0, v1, v2); + return 0; +} + + +int glVertexAttrib3s_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLshort v0 = luaL_checkinteger(L, 2); + GLshort v1 = luaL_checkinteger(L, 3); + GLshort v2 = luaL_checkinteger(L, 4); + glVertexAttrib3s(index, v0, v1, v2); + return 0; +} + + +int glVertexAttrib3d_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLdouble v0 = luaL_checknumber(L, 2); + GLdouble v1 = luaL_checknumber(L, 3); + GLdouble v2 = luaL_checknumber(L, 4); + glVertexAttrib3d(index, v0, v1, v2); + return 0; +} + + +int glVertexAttribI3i_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLint v0 = luaL_checkinteger(L, 2); + GLint v1 = luaL_checkinteger(L, 3); + GLint v2 = luaL_checkinteger(L, 4); + glVertexAttribI3i(index, v0, v1, v2); + return 0; +} + + +int glVertexAttribI3ui_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLuint v0 = luaL_checkinteger(L, 2); + GLuint v1 = luaL_checkinteger(L, 3); + GLuint v2 = luaL_checkinteger(L, 4); + glVertexAttribI3ui(index, v0, v1, v2); + return 0; +} + + +int glVertexAttrib4f_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLfloat v0 = luaL_checknumber(L, 2); + GLfloat v1 = luaL_checknumber(L, 3); + GLfloat v2 = luaL_checknumber(L, 4); + GLfloat v3 = luaL_checknumber(L, 5); + glVertexAttrib4f(index, v0, v1, v2, v3); + return 0; +} + + +int glVertexAttrib4s_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLshort v0 = luaL_checkinteger(L, 2); + GLshort v1 = luaL_checkinteger(L, 3); + GLshort v2 = luaL_checkinteger(L, 4); + GLshort v3 = luaL_checkinteger(L, 5); + glVertexAttrib4s(index, v0, v1, v2, v3); + return 0; +} + + +int glVertexAttrib4d_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLdouble v0 = luaL_checknumber(L, 2); + GLdouble v1 = luaL_checknumber(L, 3); + GLdouble v2 = luaL_checknumber(L, 4); + GLdouble v3 = luaL_checknumber(L, 5); + glVertexAttrib4d(index, v0, v1, v2, v3); + return 0; +} + + +int glVertexAttrib4Nub_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLubyte v0 = luaL_checkinteger(L, 2); + GLubyte v1 = luaL_checkinteger(L, 3); + GLubyte v2 = luaL_checkinteger(L, 4); + GLubyte v3 = luaL_checkinteger(L, 5); + glVertexAttrib4Nub(index, v0, v1, v2, v3); + return 0; +} + + +int glVertexAttribI4i_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLint v0 = luaL_checkinteger(L, 2); + GLint v1 = luaL_checkinteger(L, 3); + GLint v2 = luaL_checkinteger(L, 4); + GLint v3 = luaL_checkinteger(L, 5); + glVertexAttribI4i(index, v0, v1, v2, v3); + return 0; +} + + +int glVertexAttribI4ui_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLuint v0 = luaL_checkinteger(L, 2); + GLuint v1 = luaL_checkinteger(L, 3); + GLuint v2 = luaL_checkinteger(L, 4); + GLuint v3 = luaL_checkinteger(L, 5); + glVertexAttribI4ui(index, v0, v1, v2, v3); + return 0; +} + + +int glVertexAttribL1d_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLdouble v0 = luaL_checknumber(L, 2); + glVertexAttribL1d(index, v0); + return 0; +} + + +int glVertexAttribL2d_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLdouble v0 = luaL_checknumber(L, 2); + GLdouble v1 = luaL_checknumber(L, 3); + glVertexAttribL2d(index, v0, v1); + return 0; +} + + +int glVertexAttribL3d_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLdouble v0 = luaL_checknumber(L, 2); + GLdouble v1 = luaL_checknumber(L, 3); + GLdouble v2 = luaL_checknumber(L, 4); + glVertexAttribL3d(index, v0, v1, v2); + return 0; +} + + +int glVertexAttribL4d_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLdouble v0 = luaL_checknumber(L, 2); + GLdouble v1 = luaL_checknumber(L, 3); + GLdouble v2 = luaL_checknumber(L, 4); + GLdouble v3 = luaL_checknumber(L, 5); + glVertexAttribL4d(index, v0, v1, v2, v3); + return 0; +} + + +int glVertexAttrib1fv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLfloat * v = get: const GLfloat * + glVertexAttrib1fv(index, v); + return 0; +} + + +int glVertexAttrib1sv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLshort * v = get: const GLshort * + glVertexAttrib1sv(index, v); + return 0; +} + + +int glVertexAttrib1dv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLdouble * v = get: const GLdouble * + glVertexAttrib1dv(index, v); + return 0; +} + + +int glVertexAttribI1iv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLint * v = get: const GLint * + glVertexAttribI1iv(index, v); + return 0; +} + + +int glVertexAttribI1uiv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLuint * v = get: const GLuint * + glVertexAttribI1uiv(index, v); + return 0; +} + + +int glVertexAttrib2fv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLfloat * v = get: const GLfloat * + glVertexAttrib2fv(index, v); + return 0; +} + + +int glVertexAttrib2sv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLshort * v = get: const GLshort * + glVertexAttrib2sv(index, v); + return 0; +} + + +int glVertexAttrib2dv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLdouble * v = get: const GLdouble * + glVertexAttrib2dv(index, v); + return 0; +} + + +int glVertexAttribI2iv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLint * v = get: const GLint * + glVertexAttribI2iv(index, v); + return 0; +} + + +int glVertexAttribI2uiv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLuint * v = get: const GLuint * + glVertexAttribI2uiv(index, v); + return 0; +} + + +int glVertexAttrib3fv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLfloat * v = get: const GLfloat * + glVertexAttrib3fv(index, v); + return 0; +} + + +int glVertexAttrib3sv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLshort * v = get: const GLshort * + glVertexAttrib3sv(index, v); + return 0; +} + + +int glVertexAttrib3dv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLdouble * v = get: const GLdouble * + glVertexAttrib3dv(index, v); + return 0; +} + + +int glVertexAttribI3iv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLint * v = get: const GLint * + glVertexAttribI3iv(index, v); + return 0; +} + + +int glVertexAttribI3uiv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLuint * v = get: const GLuint * + glVertexAttribI3uiv(index, v); + return 0; +} + + +int glVertexAttrib4fv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLfloat * v = get: const GLfloat * + glVertexAttrib4fv(index, v); + return 0; +} + + +int glVertexAttrib4sv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLshort * v = get: const GLshort * + glVertexAttrib4sv(index, v); + return 0; +} + + +int glVertexAttrib4dv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLdouble * v = get: const GLdouble * + glVertexAttrib4dv(index, v); + return 0; +} + + +int glVertexAttrib4iv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLint * v = get: const GLint * + glVertexAttrib4iv(index, v); + return 0; +} + + +int glVertexAttrib4bv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLbyte * v = get: const GLbyte * + glVertexAttrib4bv(index, v); + return 0; +} + + +int glVertexAttrib4ubv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLubyte * v = get: const GLubyte * + glVertexAttrib4ubv(index, v); + return 0; +} + + +int glVertexAttrib4usv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLushort * v = get: const GLushort * + glVertexAttrib4usv(index, v); + return 0; +} + + +int glVertexAttrib4uiv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLuint * v = get: const GLuint * + glVertexAttrib4uiv(index, v); + return 0; +} + + +int glVertexAttrib4Nbv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLbyte * v = get: const GLbyte * + glVertexAttrib4Nbv(index, v); + return 0; +} + + +int glVertexAttrib4Nsv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLshort * v = get: const GLshort * + glVertexAttrib4Nsv(index, v); + return 0; +} + + +int glVertexAttrib4Niv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLint * v = get: const GLint * + glVertexAttrib4Niv(index, v); + return 0; +} + + +int glVertexAttrib4Nubv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLubyte * v = get: const GLubyte * + glVertexAttrib4Nubv(index, v); + return 0; +} + + +int glVertexAttrib4Nusv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLushort * v = get: const GLushort * + glVertexAttrib4Nusv(index, v); + return 0; +} + + +int glVertexAttrib4Nuiv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLuint * v = get: const GLuint * + glVertexAttrib4Nuiv(index, v); + return 0; +} + + +int glVertexAttribI4bv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLbyte * v = get: const GLbyte * + glVertexAttribI4bv(index, v); + return 0; +} + + +int glVertexAttribI4ubv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLubyte * v = get: const GLubyte * + glVertexAttribI4ubv(index, v); + return 0; +} + + +int glVertexAttribI4sv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLshort * v = get: const GLshort * + glVertexAttribI4sv(index, v); + return 0; +} + + +int glVertexAttribI4usv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLushort * v = get: const GLushort * + glVertexAttribI4usv(index, v); + return 0; +} + + +int glVertexAttribI4iv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLint * v = get: const GLint * + glVertexAttribI4iv(index, v); + return 0; +} + + +int glVertexAttribI4uiv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLuint * v = get: const GLuint * + glVertexAttribI4uiv(index, v); + return 0; +} + + +int glVertexAttribL1dv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLdouble * v = get: const GLdouble * + glVertexAttribL1dv(index, v); + return 0; +} + + +int glVertexAttribL2dv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLdouble * v = get: const GLdouble * + glVertexAttribL2dv(index, v); + return 0; +} + + +int glVertexAttribL3dv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLdouble * v = get: const GLdouble * + glVertexAttribL3dv(index, v); + return 0; +} + + +int glVertexAttribL4dv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLdouble * v = get: const GLdouble * + glVertexAttribL4dv(index, v); + return 0; +} + + +int glVertexAttribP1ui_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum type = luaL_checkinteger(L, 2); + GLboolean normalized = get: GLboolean + GLuint value = luaL_checkinteger(L, 4); + glVertexAttribP1ui(index, type, normalized, value); + return 0; +} + + +int glVertexAttribP2ui_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum type = luaL_checkinteger(L, 2); + GLboolean normalized = get: GLboolean + GLuint value = luaL_checkinteger(L, 4); + glVertexAttribP2ui(index, type, normalized, value); + return 0; +} + + +int glVertexAttribP3ui_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum type = luaL_checkinteger(L, 2); + GLboolean normalized = get: GLboolean + GLuint value = luaL_checkinteger(L, 4); + glVertexAttribP3ui(index, type, normalized, value); + return 0; +} + + +int glVertexAttribP4ui_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLenum type = luaL_checkinteger(L, 2); + GLboolean normalized = get: GLboolean + GLuint value = luaL_checkinteger(L, 4); + glVertexAttribP4ui(index, type, normalized, value); + return 0; +} + + +int glVertexAttribPointer_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLint size = luaL_checkinteger(L, 2); + GLenum type = luaL_checkinteger(L, 3); + GLboolean normalized = get: GLboolean + GLsizei stride = luaL_checkinteger(L, 5); + const void * pointer = get: const void * + glVertexAttribPointer(index, size, type, normalized, stride, pointer); + return 0; +} + + +int glVertexAttribIPointer_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLint size = luaL_checkinteger(L, 2); + GLenum type = luaL_checkinteger(L, 3); + GLsizei stride = luaL_checkinteger(L, 4); + const void * pointer = get: const void * + glVertexAttribIPointer(index, size, type, stride, pointer); + return 0; +} + + +int glViewport_bind(lua_State *L) +{ + GLint x = luaL_checkinteger(L, 1); + GLint y = luaL_checkinteger(L, 2); + GLsizei width = luaL_checkinteger(L, 3); + GLsizei height = luaL_checkinteger(L, 4); + glViewport(x, y, width, height); + return 0; +} + + +int glViewportArrayv_bind(lua_State *L) +{ + GLuint first = luaL_checkinteger(L, 1); + GLsizei count = luaL_checkinteger(L, 2); + const GLfloat * v = get: const GLfloat * + glViewportArrayv(first, count, v); + return 0; +} + + +int glViewportIndexedf_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + GLfloat x = luaL_checknumber(L, 2); + GLfloat y = luaL_checknumber(L, 3); + GLfloat w = luaL_checknumber(L, 4); + GLfloat h = luaL_checknumber(L, 5); + glViewportIndexedf(index, x, y, w, h); + return 0; +} + + +int glViewportIndexedfv_bind(lua_State *L) +{ + GLuint index = luaL_checkinteger(L, 1); + const GLfloat * v = get: const GLfloat * + glViewportIndexedfv(index, v); + return 0; +} + + diff --git a/src/opengl/bind/w b/src/opengl/bind/w new file mode 100644 index 0000000..1a75379 --- /dev/null +++ b/src/opengl/bind/w @@ -0,0 +1 @@ +void glWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout); diff --git a/src/opengl/bind/w.bind b/src/opengl/bind/w.bind new file mode 100644 index 0000000..6f5210c --- /dev/null +++ b/src/opengl/bind/w.bind @@ -0,0 +1,10 @@ +int glWaitSync_bind(lua_State *L) +{ + GLsync sync = luaL_checkinteger(L, 1); + GLbitfield flags = luaL_checkinteger(L, 2); + GLuint64 timeout = luaL_checkinteger(L, 3); + glWaitSync(sync, flags, timeout); + return 0; +} + + |