gistfile1.cpp

SCM_DEFINE_PUBLIC(glCullFace,"gl-cull-face",1,0,0,
(SCM mode)
"ADD ME LATER")
#define FUNC_NAME s_glCullFace
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
glCullFace(lp_mode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFrontFace,"gl-front-face",1,0,0,
(SCM mode)
"ADD ME LATER")
#define FUNC_NAME s_glFrontFace
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
glFrontFace(lp_mode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glHint,"gl-hint",2,0,0,
(SCM target, SCM mode)
"ADD ME LATER")
#define FUNC_NAME s_glHint
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
glHint(lp_target, lp_mode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glLineWidth,"gl-line-width",1,0,0,
(SCM width)
"ADD ME LATER")
#define FUNC_NAME s_glLineWidth
{
GLfloat lp_width = (GLfloat)scm_to_double(width);
glLineWidth(lp_width);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPointSize,"gl-point-size",1,0,0,
(SCM size)
"ADD ME LATER")
#define FUNC_NAME s_glPointSize
{
GLfloat lp_size = (GLfloat)scm_to_double(size);
glPointSize(lp_size);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPolygonMode,"gl-polygon-mode",2,0,0,
(SCM face, SCM mode)
"ADD ME LATER")
#define FUNC_NAME s_glPolygonMode
{
GLenum lp_face = (GLenum)scm_to_uint32(face);
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
glPolygonMode(lp_face, lp_mode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glScissor,"gl-scissor",4,0,0,
(SCM x, SCM y, SCM width, SCM height)
"ADD ME LATER")
#define FUNC_NAME s_glScissor
{
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
glScissor(lp_x, lp_y, lp_width, lp_height);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexParameterf,"gl-tex-parameterf",3,0,0,
(SCM target, SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glTexParameterf
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat lp_param = (GLfloat)scm_to_double(param);
glTexParameterf(lp_target, lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexParameterfv,"gl-tex-parameterfv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glTexParameterfv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat* lp_params = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(params);
glTexParameterfv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexParameteri,"gl-tex-parameteri",3,0,0,
(SCM target, SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glTexParameteri
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint lp_param = (GLint)scm_to_int32(param);
glTexParameteri(lp_target, lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexParameteriv,"gl-tex-parameteriv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glTexParameteriv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glTexParameteriv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexImage1D,"gl-tex-image-1D",8,0,0,
(SCM target, SCM level, SCM internalformat, SCM width, SCM border, SCM format, SCM type, SCM pixels)
"ADD ME LATER")
#define FUNC_NAME s_glTexImage1D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_internalformat = (GLint)scm_to_int32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLint lp_border = (GLint)scm_to_int32(border);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_pixels = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pixels);
glTexImage1D(lp_target, lp_level, lp_internalformat, lp_width, lp_border, lp_format, lp_type, lp_pixels);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexImage2D,"gl-tex-image-2D",9,0,0,
(SCM target, SCM level, SCM internalformat, SCM width, SCM height, SCM border, SCM format, SCM type, SCM pixels)
"ADD ME LATER")
#define FUNC_NAME s_glTexImage2D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_internalformat = (GLint)scm_to_int32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLint lp_border = (GLint)scm_to_int32(border);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_pixels = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pixels);
glTexImage2D(lp_target, lp_level, lp_internalformat, lp_width, lp_height, lp_border, lp_format, lp_type, lp_pixels);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawBuffer,"gl-draw-buffer",1,0,0,
(SCM mode)
"ADD ME LATER")
#define FUNC_NAME s_glDrawBuffer
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
glDrawBuffer(lp_mode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClear,"gl-clear",1,0,0,
(SCM mask)
"ADD ME LATER")
#define FUNC_NAME s_glClear
{
GLbitfield lp_mask = (GLbitfield)scm_to_uint32(mask);
glClear(lp_mask);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearColor,"gl-clear-color",4,0,0,
(SCM red, SCM green, SCM blue, SCM alpha)
"ADD ME LATER")
#define FUNC_NAME s_glClearColor
{
GLfloat lp_red = (GLfloat)scm_to_double(red);
GLfloat lp_green = (GLfloat)scm_to_double(green);
GLfloat lp_blue = (GLfloat)scm_to_double(blue);
GLfloat lp_alpha = (GLfloat)scm_to_double(alpha);
glClearColor(lp_red, lp_green, lp_blue, lp_alpha);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearStencil,"gl-clear-stencil",1,0,0,
(SCM s)
"ADD ME LATER")
#define FUNC_NAME s_glClearStencil
{
GLint lp_s = (GLint)scm_to_int32(s);
glClearStencil(lp_s);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearDepth,"gl-clear-depth",1,0,0,
(SCM depth)
"ADD ME LATER")
#define FUNC_NAME s_glClearDepth
{
GLdouble lp_depth = (GLdouble)scm_to_double(depth);
glClearDepth(lp_depth);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glStencilMask,"gl-stencil-mask",1,0,0,
(SCM mask)
"ADD ME LATER")
#define FUNC_NAME s_glStencilMask
{
GLuint lp_mask = (GLuint)scm_to_uint32(mask);
glStencilMask(lp_mask);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glColorMask,"gl-color-mask",4,0,0,
(SCM red, SCM green, SCM blue, SCM alpha)
"ADD ME LATER")
#define FUNC_NAME s_glColorMask
{
GLboolean lp_red = (GLboolean)scm_to_bool(red);
GLboolean lp_green = (GLboolean)scm_to_bool(green);
GLboolean lp_blue = (GLboolean)scm_to_bool(blue);
GLboolean lp_alpha = (GLboolean)scm_to_bool(alpha);
glColorMask(lp_red, lp_green, lp_blue, lp_alpha);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDepthMask,"gl-depth-mask",1,0,0,
(SCM flag)
"ADD ME LATER")
#define FUNC_NAME s_glDepthMask
{
GLboolean lp_flag = (GLboolean)scm_to_bool(flag);
glDepthMask(lp_flag);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDisable,"gl-disable",1,0,0,
(SCM cap)
"ADD ME LATER")
#define FUNC_NAME s_glDisable
{
GLenum lp_cap = (GLenum)scm_to_uint32(cap);
glDisable(lp_cap);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glEnable,"gl-enable",1,0,0,
(SCM cap)
"ADD ME LATER")
#define FUNC_NAME s_glEnable
{
GLenum lp_cap = (GLenum)scm_to_uint32(cap);
glEnable(lp_cap);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFinish,"gl-finish",0,0,0,
(void)
"ADD ME LATER")
#define FUNC_NAME s_glFinish
{
glFinish();
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFlush,"gl-flush",0,0,0,
(void)
"ADD ME LATER")
#define FUNC_NAME s_glFlush
{
glFlush();
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBlendFunc,"gl-blend-func",2,0,0,
(SCM sfactor, SCM dfactor)
"ADD ME LATER")
#define FUNC_NAME s_glBlendFunc
{
GLenum lp_sfactor = (GLenum)scm_to_uint32(sfactor);
GLenum lp_dfactor = (GLenum)scm_to_uint32(dfactor);
glBlendFunc(lp_sfactor, lp_dfactor);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glLogicOp,"gl-logic-op",1,0,0,
(SCM opcode)
"ADD ME LATER")
#define FUNC_NAME s_glLogicOp
{
GLenum lp_opcode = (GLenum)scm_to_uint32(opcode);
glLogicOp(lp_opcode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glStencilFunc,"gl-stencil-func",3,0,0,
(SCM func, SCM ref, SCM mask)
"ADD ME LATER")
#define FUNC_NAME s_glStencilFunc
{
GLenum lp_func = (GLenum)scm_to_uint32(func);
GLint lp_ref = (GLint)scm_to_int32(ref);
GLuint lp_mask = (GLuint)scm_to_uint32(mask);
glStencilFunc(lp_func, lp_ref, lp_mask);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glStencilOp,"gl-stencil-op",3,0,0,
(SCM fail, SCM zfail, SCM zpass)
"ADD ME LATER")
#define FUNC_NAME s_glStencilOp
{
GLenum lp_fail = (GLenum)scm_to_uint32(fail);
GLenum lp_zfail = (GLenum)scm_to_uint32(zfail);
GLenum lp_zpass = (GLenum)scm_to_uint32(zpass);
glStencilOp(lp_fail, lp_zfail, lp_zpass);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDepthFunc,"gl-depth-func",1,0,0,
(SCM func)
"ADD ME LATER")
#define FUNC_NAME s_glDepthFunc
{
GLenum lp_func = (GLenum)scm_to_uint32(func);
glDepthFunc(lp_func);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPixelStoref,"gl-pixel-storef",2,0,0,
(SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glPixelStoref
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat lp_param = (GLfloat)scm_to_double(param);
glPixelStoref(lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPixelStorei,"gl-pixel-storei",2,0,0,
(SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glPixelStorei
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint lp_param = (GLint)scm_to_int32(param);
glPixelStorei(lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glReadBuffer,"gl-read-buffer",1,0,0,
(SCM mode)
"ADD ME LATER")
#define FUNC_NAME s_glReadBuffer
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
glReadBuffer(lp_mode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glReadPixels,"gl-read-pixels",7,0,0,
(SCM x, SCM y, SCM width, SCM height, SCM format, SCM type, SCM pixels)
"ADD ME LATER")
#define FUNC_NAME s_glReadPixels
{
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_pixels = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pixels);
glReadPixels(lp_x, lp_y, lp_width, lp_height, lp_format, lp_type, lp_pixels);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetBooleanv,"gl-get-booleanv",2,0,0,
(SCM pname, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetBooleanv
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLboolean* lp_data = (GLboolean*)SCM_BYTEVECTOR_CONTENTS(data);
glGetBooleanv(lp_pname, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetDoublev,"gl-get-doublev",2,0,0,
(SCM pname, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetDoublev
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLdouble* lp_data = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(data);
glGetDoublev(lp_pname, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetError,"gl-get-error",0,0,0,
(void)
"ADD ME LATER")
#define FUNC_NAME s_glGetError
{
GLenum lp_ret;
lp_ret = glGetError();
return scm_from_uint32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetFloatv,"gl-get-floatv",2,0,0,
(SCM pname, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetFloatv
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat* lp_data = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(data);
glGetFloatv(lp_pname, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetIntegerv,"gl-get-integerv",2,0,0,
(SCM pname, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetIntegerv
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_data = (GLint*)SCM_BYTEVECTOR_CONTENTS(data);
glGetIntegerv(lp_pname, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetTexImage,"gl-get-tex-image",5,0,0,
(SCM target, SCM level, SCM format, SCM type, SCM pixels)
"ADD ME LATER")
#define FUNC_NAME s_glGetTexImage
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_pixels = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pixels);
glGetTexImage(lp_target, lp_level, lp_format, lp_type, lp_pixels);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetTexParameterfv,"gl-get-tex-parameterfv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetTexParameterfv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat* lp_params = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(params);
glGetTexParameterfv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetTexParameteriv,"gl-get-tex-parameteriv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetTexParameteriv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetTexParameteriv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetTexLevelParameterfv,"gl-get-tex-level-parameterfv",4,0,0,
(SCM target, SCM level, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetTexLevelParameterfv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat* lp_params = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(params);
glGetTexLevelParameterfv(lp_target, lp_level, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetTexLevelParameteriv,"gl-get-tex-level-parameteriv",4,0,0,
(SCM target, SCM level, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetTexLevelParameteriv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetTexLevelParameteriv(lp_target, lp_level, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsEnabled,"gl-is-enabled",1,0,0,
(SCM cap)
"ADD ME LATER")
#define FUNC_NAME s_glIsEnabled
{
GLenum lp_cap = (GLenum)scm_to_uint32(cap);
GLboolean lp_ret;
lp_ret = glIsEnabled(lp_cap);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDepthRange,"gl-depth-range",2,0,0,
(SCM near, SCM far)
"ADD ME LATER")
#define FUNC_NAME s_glDepthRange
{
GLdouble lp_near = (GLdouble)scm_to_double(near);
GLdouble lp_far = (GLdouble)scm_to_double(far);
glDepthRange(lp_near, lp_far);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glViewport,"gl-viewport",4,0,0,
(SCM x, SCM y, SCM width, SCM height)
"ADD ME LATER")
#define FUNC_NAME s_glViewport
{
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
glViewport(lp_x, lp_y, lp_width, lp_height);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawArrays,"gl-draw-arrays",3,0,0,
(SCM mode, SCM first, SCM count)
"ADD ME LATER")
#define FUNC_NAME s_glDrawArrays
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLint lp_first = (GLint)scm_to_int32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
glDrawArrays(lp_mode, lp_first, lp_count);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawElements,"gl-draw-elements",4,0,0,
(SCM mode, SCM count, SCM type, SCM indices)
"ADD ME LATER")
#define FUNC_NAME s_glDrawElements
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_indices = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indices);
glDrawElements(lp_mode, lp_count, lp_type, lp_indices);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPolygonOffset,"gl-polygon-offset",2,0,0,
(SCM factor, SCM units)
"ADD ME LATER")
#define FUNC_NAME s_glPolygonOffset
{
GLfloat lp_factor = (GLfloat)scm_to_double(factor);
GLfloat lp_units = (GLfloat)scm_to_double(units);
glPolygonOffset(lp_factor, lp_units);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCopyTexImage1D,"gl-copy-tex-image-1D",7,0,0,
(SCM target, SCM level, SCM internalformat, SCM x, SCM y, SCM width, SCM border)
"ADD ME LATER")
#define FUNC_NAME s_glCopyTexImage1D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLint lp_border = (GLint)scm_to_int32(border);
glCopyTexImage1D(lp_target, lp_level, lp_internalformat, lp_x, lp_y, lp_width, lp_border);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCopyTexImage2D,"gl-copy-tex-image-2D",8,0,0,
(SCM target, SCM level, SCM internalformat, SCM x, SCM y, SCM width, SCM height, SCM border)
"ADD ME LATER")
#define FUNC_NAME s_glCopyTexImage2D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLint lp_border = (GLint)scm_to_int32(border);
glCopyTexImage2D(lp_target, lp_level, lp_internalformat, lp_x, lp_y, lp_width, lp_height, lp_border);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCopyTexSubImage1D,"gl-copy-tex-sub-image-1D",6,0,0,
(SCM target, SCM level, SCM xoffset, SCM x, SCM y, SCM width)
"ADD ME LATER")
#define FUNC_NAME s_glCopyTexSubImage1D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
glCopyTexSubImage1D(lp_target, lp_level, lp_xoffset, lp_x, lp_y, lp_width);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCopyTexSubImage2D,"gl-copy-tex-sub-image-2D",8,0,0,
(SCM target, SCM level, SCM xoffset, SCM yoffset, SCM x, SCM y, SCM width, SCM height)
"ADD ME LATER")
#define FUNC_NAME s_glCopyTexSubImage2D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLint lp_yoffset = (GLint)scm_to_int32(yoffset);
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
glCopyTexSubImage2D(lp_target, lp_level, lp_xoffset, lp_yoffset, lp_x, lp_y, lp_width, lp_height);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexSubImage1D,"gl-tex-sub-image-1D",7,0,0,
(SCM target, SCM level, SCM xoffset, SCM width, SCM format, SCM type, SCM pixels)
"ADD ME LATER")
#define FUNC_NAME s_glTexSubImage1D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_pixels = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pixels);
glTexSubImage1D(lp_target, lp_level, lp_xoffset, lp_width, lp_format, lp_type, lp_pixels);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexSubImage2D,"gl-tex-sub-image-2D",9,0,0,
(SCM target, SCM level, SCM xoffset, SCM yoffset, SCM width, SCM height, SCM format, SCM type, SCM pixels)
"ADD ME LATER")
#define FUNC_NAME s_glTexSubImage2D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLint lp_yoffset = (GLint)scm_to_int32(yoffset);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_pixels = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pixels);
glTexSubImage2D(lp_target, lp_level, lp_xoffset, lp_yoffset, lp_width, lp_height, lp_format, lp_type, lp_pixels);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindTexture,"gl-bind-texture",2,0,0,
(SCM target, SCM texture)
"ADD ME LATER")
#define FUNC_NAME s_glBindTexture
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
glBindTexture(lp_target, lp_texture);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteTextures,"gl-delete-textures",2,0,0,
(SCM n, SCM textures)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteTextures
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_textures = (GLuint*)SCM_BYTEVECTOR_CONTENTS(textures);
glDeleteTextures(lp_n, lp_textures);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGenTextures,"gl-gen-textures",2,0,0,
(SCM n, SCM textures)
"ADD ME LATER")
#define FUNC_NAME s_glGenTextures
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_textures = (GLuint*)SCM_BYTEVECTOR_CONTENTS(textures);
glGenTextures(lp_n, lp_textures);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsTexture,"gl-is-texture",1,0,0,
(SCM texture)
"ADD ME LATER")
#define FUNC_NAME s_glIsTexture
{
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLboolean lp_ret;
lp_ret = glIsTexture(lp_texture);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawRangeElements,"gl-draw-range-elements",6,0,0,
(SCM mode, SCM start, SCM end, SCM count, SCM type, SCM indices)
"ADD ME LATER")
#define FUNC_NAME s_glDrawRangeElements
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLuint lp_start = (GLuint)scm_to_uint32(start);
GLuint lp_end = (GLuint)scm_to_uint32(end);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_indices = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indices);
glDrawRangeElements(lp_mode, lp_start, lp_end, lp_count, lp_type, lp_indices);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexImage3D,"gl-tex-image-3D",10,0,0,
(SCM target, SCM level, SCM internalformat, SCM width, SCM height, SCM depth, SCM border, SCM format, SCM type, SCM pixels)
"ADD ME LATER")
#define FUNC_NAME s_glTexImage3D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_internalformat = (GLint)scm_to_int32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLsizei lp_depth = (GLsizei)scm_to_uint32(depth);
GLint lp_border = (GLint)scm_to_int32(border);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_pixels = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pixels);
glTexImage3D(lp_target, lp_level, lp_internalformat, lp_width, lp_height, lp_depth, lp_border, lp_format, lp_type, lp_pixels);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexSubImage3D,"gl-tex-sub-image-3D",11,0,0,
(SCM target, SCM level, SCM xoffset, SCM yoffset, SCM zoffset, SCM width, SCM height, SCM depth, SCM format, SCM type, SCM pixels)
"ADD ME LATER")
#define FUNC_NAME s_glTexSubImage3D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLint lp_yoffset = (GLint)scm_to_int32(yoffset);
GLint lp_zoffset = (GLint)scm_to_int32(zoffset);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLsizei lp_depth = (GLsizei)scm_to_uint32(depth);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_pixels = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pixels);
glTexSubImage3D(lp_target, lp_level, lp_xoffset, lp_yoffset, lp_zoffset, lp_width, lp_height, lp_depth, lp_format, lp_type, lp_pixels);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCopyTexSubImage3D,"gl-copy-tex-sub-image-3D",9,0,0,
(SCM target, SCM level, SCM xoffset, SCM yoffset, SCM zoffset, SCM x, SCM y, SCM width, SCM height)
"ADD ME LATER")
#define FUNC_NAME s_glCopyTexSubImage3D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLint lp_yoffset = (GLint)scm_to_int32(yoffset);
GLint lp_zoffset = (GLint)scm_to_int32(zoffset);
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
glCopyTexSubImage3D(lp_target, lp_level, lp_xoffset, lp_yoffset, lp_zoffset, lp_x, lp_y, lp_width, lp_height);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glActiveTexture,"gl-active-texture",1,0,0,
(SCM texture)
"ADD ME LATER")
#define FUNC_NAME s_glActiveTexture
{
GLenum lp_texture = (GLenum)scm_to_uint32(texture);
glActiveTexture(lp_texture);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glSampleCoverage,"gl-sample-coverage",2,0,0,
(SCM value, SCM invert)
"ADD ME LATER")
#define FUNC_NAME s_glSampleCoverage
{
GLfloat lp_value = (GLfloat)scm_to_double(value);
GLboolean lp_invert = (GLboolean)scm_to_bool(invert);
glSampleCoverage(lp_value, lp_invert);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCompressedTexImage3D,"gl-compressed-tex-image-3D",9,0,0,
(SCM target, SCM level, SCM internalformat, SCM width, SCM height, SCM depth, SCM border, SCM imageSize, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glCompressedTexImage3D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLsizei lp_depth = (GLsizei)scm_to_uint32(depth);
GLint lp_border = (GLint)scm_to_int32(border);
GLsizei lp_imageSize = (GLsizei)scm_to_uint32(imageSize);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glCompressedTexImage3D(lp_target, lp_level, lp_internalformat, lp_width, lp_height, lp_depth, lp_border, lp_imageSize, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCompressedTexImage2D,"gl-compressed-tex-image-2D",8,0,0,
(SCM target, SCM level, SCM internalformat, SCM width, SCM height, SCM border, SCM imageSize, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glCompressedTexImage2D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLint lp_border = (GLint)scm_to_int32(border);
GLsizei lp_imageSize = (GLsizei)scm_to_uint32(imageSize);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glCompressedTexImage2D(lp_target, lp_level, lp_internalformat, lp_width, lp_height, lp_border, lp_imageSize, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCompressedTexImage1D,"gl-compressed-tex-image-1D",7,0,0,
(SCM target, SCM level, SCM internalformat, SCM width, SCM border, SCM imageSize, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glCompressedTexImage1D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLint lp_border = (GLint)scm_to_int32(border);
GLsizei lp_imageSize = (GLsizei)scm_to_uint32(imageSize);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glCompressedTexImage1D(lp_target, lp_level, lp_internalformat, lp_width, lp_border, lp_imageSize, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCompressedTexSubImage3D,"gl-compressed-tex-sub-image-3D",11,0,0,
(SCM target, SCM level, SCM xoffset, SCM yoffset, SCM zoffset, SCM width, SCM height, SCM depth, SCM format, SCM imageSize, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glCompressedTexSubImage3D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLint lp_yoffset = (GLint)scm_to_int32(yoffset);
GLint lp_zoffset = (GLint)scm_to_int32(zoffset);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLsizei lp_depth = (GLsizei)scm_to_uint32(depth);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLsizei lp_imageSize = (GLsizei)scm_to_uint32(imageSize);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glCompressedTexSubImage3D(lp_target, lp_level, lp_xoffset, lp_yoffset, lp_zoffset, lp_width, lp_height, lp_depth, lp_format, lp_imageSize, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCompressedTexSubImage2D,"gl-compressed-tex-sub-image-2D",9,0,0,
(SCM target, SCM level, SCM xoffset, SCM yoffset, SCM width, SCM height, SCM format, SCM imageSize, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glCompressedTexSubImage2D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLint lp_yoffset = (GLint)scm_to_int32(yoffset);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLsizei lp_imageSize = (GLsizei)scm_to_uint32(imageSize);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glCompressedTexSubImage2D(lp_target, lp_level, lp_xoffset, lp_yoffset, lp_width, lp_height, lp_format, lp_imageSize, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCompressedTexSubImage1D,"gl-compressed-tex-sub-image-1D",7,0,0,
(SCM target, SCM level, SCM xoffset, SCM width, SCM format, SCM imageSize, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glCompressedTexSubImage1D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLsizei lp_imageSize = (GLsizei)scm_to_uint32(imageSize);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glCompressedTexSubImage1D(lp_target, lp_level, lp_xoffset, lp_width, lp_format, lp_imageSize, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetCompressedTexImage,"gl-get-compressed-tex-image",3,0,0,
(SCM target, SCM level, SCM img)
"ADD ME LATER")
#define FUNC_NAME s_glGetCompressedTexImage
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLint lp_level = (GLint)scm_to_int32(level);
GLvoid* lp_img = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(img);
glGetCompressedTexImage(lp_target, lp_level, lp_img);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBlendFuncSeparate,"gl-blend-func-separate",4,0,0,
(SCM sfactorRGB, SCM dfactorRGB, SCM sfactorAlpha, SCM dfactorAlpha)
"ADD ME LATER")
#define FUNC_NAME s_glBlendFuncSeparate
{
GLenum lp_sfactorRGB = (GLenum)scm_to_uint32(sfactorRGB);
GLenum lp_dfactorRGB = (GLenum)scm_to_uint32(dfactorRGB);
GLenum lp_sfactorAlpha = (GLenum)scm_to_uint32(sfactorAlpha);
GLenum lp_dfactorAlpha = (GLenum)scm_to_uint32(dfactorAlpha);
glBlendFuncSeparate(lp_sfactorRGB, lp_dfactorRGB, lp_sfactorAlpha, lp_dfactorAlpha);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glMultiDrawArrays,"gl-multi-draw-arrays",4,0,0,
(SCM mode, SCM first, SCM count, SCM drawcount)
"ADD ME LATER")
#define FUNC_NAME s_glMultiDrawArrays
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLint* lp_first = (GLint*)SCM_BYTEVECTOR_CONTENTS(first);
GLsizei* lp_count = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(count);
GLsizei lp_drawcount = (GLsizei)scm_to_uint32(drawcount);
glMultiDrawArrays(lp_mode, lp_first, lp_count, lp_drawcount);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPointParameterf,"gl-point-parameterf",2,0,0,
(SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glPointParameterf
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat lp_param = (GLfloat)scm_to_double(param);
glPointParameterf(lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPointParameterfv,"gl-point-parameterfv",2,0,0,
(SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glPointParameterfv
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat* lp_params = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(params);
glPointParameterfv(lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPointParameteri,"gl-point-parameteri",2,0,0,
(SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glPointParameteri
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint lp_param = (GLint)scm_to_int32(param);
glPointParameteri(lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPointParameteriv,"gl-point-parameteriv",2,0,0,
(SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glPointParameteriv
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glPointParameteriv(lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBlendColor,"gl-blend-color",4,0,0,
(SCM red, SCM green, SCM blue, SCM alpha)
"ADD ME LATER")
#define FUNC_NAME s_glBlendColor
{
GLfloat lp_red = (GLfloat)scm_to_double(red);
GLfloat lp_green = (GLfloat)scm_to_double(green);
GLfloat lp_blue = (GLfloat)scm_to_double(blue);
GLfloat lp_alpha = (GLfloat)scm_to_double(alpha);
glBlendColor(lp_red, lp_green, lp_blue, lp_alpha);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBlendEquation,"gl-blend-equation",1,0,0,
(SCM mode)
"ADD ME LATER")
#define FUNC_NAME s_glBlendEquation
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
glBlendEquation(lp_mode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGenQueries,"gl-gen-queries",2,0,0,
(SCM n, SCM ids)
"ADD ME LATER")
#define FUNC_NAME s_glGenQueries
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_ids = (GLuint*)SCM_BYTEVECTOR_CONTENTS(ids);
glGenQueries(lp_n, lp_ids);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteQueries,"gl-delete-queries",2,0,0,
(SCM n, SCM ids)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteQueries
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_ids = (GLuint*)SCM_BYTEVECTOR_CONTENTS(ids);
glDeleteQueries(lp_n, lp_ids);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsQuery,"gl-is-query",1,0,0,
(SCM id)
"ADD ME LATER")
#define FUNC_NAME s_glIsQuery
{
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLboolean lp_ret;
lp_ret = glIsQuery(lp_id);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBeginQuery,"gl-begin-query",2,0,0,
(SCM target, SCM id)
"ADD ME LATER")
#define FUNC_NAME s_glBeginQuery
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_id = (GLuint)scm_to_uint32(id);
glBeginQuery(lp_target, lp_id);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glEndQuery,"gl-end-query",1,0,0,
(SCM target)
"ADD ME LATER")
#define FUNC_NAME s_glEndQuery
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
glEndQuery(lp_target);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetQueryiv,"gl-get-queryiv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetQueryiv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetQueryiv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetQueryObjectiv,"gl-get-query-objectiv",3,0,0,
(SCM id, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetQueryObjectiv
{
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetQueryObjectiv(lp_id, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetQueryObjectuiv,"gl-get-query-objectuiv",3,0,0,
(SCM id, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetQueryObjectuiv
{
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLuint* lp_params = (GLuint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetQueryObjectuiv(lp_id, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindBuffer,"gl-bind-buffer",2,0,0,
(SCM target, SCM buffer)
"ADD ME LATER")
#define FUNC_NAME s_glBindBuffer
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_buffer = (GLuint)scm_to_uint32(buffer);
glBindBuffer(lp_target, lp_buffer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteBuffers,"gl-delete-buffers",2,0,0,
(SCM n, SCM buffers)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteBuffers
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_buffers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(buffers);
glDeleteBuffers(lp_n, lp_buffers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGenBuffers,"gl-gen-buffers",2,0,0,
(SCM n, SCM buffers)
"ADD ME LATER")
#define FUNC_NAME s_glGenBuffers
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_buffers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(buffers);
glGenBuffers(lp_n, lp_buffers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsBuffer,"gl-is-buffer",1,0,0,
(SCM buffer)
"ADD ME LATER")
#define FUNC_NAME s_glIsBuffer
{
GLuint lp_buffer = (GLuint)scm_to_uint32(buffer);
GLboolean lp_ret;
lp_ret = glIsBuffer(lp_buffer);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBufferData,"gl-buffer-data",4,0,0,
(SCM target, SCM size, SCM data, SCM usage)
"ADD ME LATER")
#define FUNC_NAME s_glBufferData
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizeiptr lp_size = (GLsizeiptr)scm_to_uint32(size);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
GLenum lp_usage = (GLenum)scm_to_uint32(usage);
glBufferData(lp_target, lp_size, lp_data, lp_usage);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBufferSubData,"gl-buffer-sub-data",4,0,0,
(SCM target, SCM offset, SCM size, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glBufferSubData
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLintptr lp_offset = (GLintptr)scm_to_uint32(offset);
GLsizeiptr lp_size = (GLsizeiptr)scm_to_uint32(size);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glBufferSubData(lp_target, lp_offset, lp_size, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetBufferSubData,"gl-get-buffer-sub-data",4,0,0,
(SCM target, SCM offset, SCM size, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetBufferSubData
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLintptr lp_offset = (GLintptr)scm_to_uint32(offset);
GLsizeiptr lp_size = (GLsizeiptr)scm_to_uint32(size);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glGetBufferSubData(lp_target, lp_offset, lp_size, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glMapBuffer,"gl-map-buffer",2,0,0,
(SCM target, SCM access)
"ADD ME LATER")
#define FUNC_NAME s_glMapBuffer
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_access = (GLenum)scm_to_uint32(access);
glMapBuffer(lp_target, lp_access);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUnmapBuffer,"gl-unmap-buffer",1,0,0,
(SCM target)
"ADD ME LATER")
#define FUNC_NAME s_glUnmapBuffer
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLboolean lp_ret;
lp_ret = glUnmapBuffer(lp_target);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetBufferParameteriv,"gl-get-buffer-parameteriv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetBufferParameteriv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetBufferParameteriv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBlendEquationSeparate,"gl-blend-equation-separate",2,0,0,
(SCM modeRGB, SCM modeAlpha)
"ADD ME LATER")
#define FUNC_NAME s_glBlendEquationSeparate
{
GLenum lp_modeRGB = (GLenum)scm_to_uint32(modeRGB);
GLenum lp_modeAlpha = (GLenum)scm_to_uint32(modeAlpha);
glBlendEquationSeparate(lp_modeRGB, lp_modeAlpha);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawBuffers,"gl-draw-buffers",2,0,0,
(SCM n, SCM bufs)
"ADD ME LATER")
#define FUNC_NAME s_glDrawBuffers
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLenum* lp_bufs = (GLenum*)SCM_BYTEVECTOR_CONTENTS(bufs);
glDrawBuffers(lp_n, lp_bufs);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glStencilOpSeparate,"gl-stencil-op-separate",4,0,0,
(SCM face, SCM sfail, SCM dpfail, SCM dppass)
"ADD ME LATER")
#define FUNC_NAME s_glStencilOpSeparate
{
GLenum lp_face = (GLenum)scm_to_uint32(face);
GLenum lp_sfail = (GLenum)scm_to_uint32(sfail);
GLenum lp_dpfail = (GLenum)scm_to_uint32(dpfail);
GLenum lp_dppass = (GLenum)scm_to_uint32(dppass);
glStencilOpSeparate(lp_face, lp_sfail, lp_dpfail, lp_dppass);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glStencilFuncSeparate,"gl-stencil-func-separate",4,0,0,
(SCM face, SCM func, SCM ref, SCM mask)
"ADD ME LATER")
#define FUNC_NAME s_glStencilFuncSeparate
{
GLenum lp_face = (GLenum)scm_to_uint32(face);
GLenum lp_func = (GLenum)scm_to_uint32(func);
GLint lp_ref = (GLint)scm_to_int32(ref);
GLuint lp_mask = (GLuint)scm_to_uint32(mask);
glStencilFuncSeparate(lp_face, lp_func, lp_ref, lp_mask);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glStencilMaskSeparate,"gl-stencil-mask-separate",2,0,0,
(SCM face, SCM mask)
"ADD ME LATER")
#define FUNC_NAME s_glStencilMaskSeparate
{
GLenum lp_face = (GLenum)scm_to_uint32(face);
GLuint lp_mask = (GLuint)scm_to_uint32(mask);
glStencilMaskSeparate(lp_face, lp_mask);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glAttachShader,"gl-attach-shader",2,0,0,
(SCM program, SCM shader)
"ADD ME LATER")
#define FUNC_NAME s_glAttachShader
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_shader = (GLuint)scm_to_uint32(shader);
glAttachShader(lp_program, lp_shader);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindAttribLocation,"gl-bind-attrib-location",3,0,0,
(SCM program, SCM index, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glBindAttribLocation
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
glBindAttribLocation(lp_program, lp_index, lp_name);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCompileShader,"gl-compile-shader",1,0,0,
(SCM shader)
"ADD ME LATER")
#define FUNC_NAME s_glCompileShader
{
GLuint lp_shader = (GLuint)scm_to_uint32(shader);
glCompileShader(lp_shader);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCreateProgram,"gl-create-program",0,0,0,
(void)
"ADD ME LATER")
#define FUNC_NAME s_glCreateProgram
{
GLuint lp_ret;
lp_ret = glCreateProgram();
return scm_from_uint32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCreateShader,"gl-create-shader",1,0,0,
(SCM type)
"ADD ME LATER")
#define FUNC_NAME s_glCreateShader
{
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLuint lp_ret;
lp_ret = glCreateShader(lp_type);
return scm_from_uint32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteProgram,"gl-delete-program",1,0,0,
(SCM program)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteProgram
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
glDeleteProgram(lp_program);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteShader,"gl-delete-shader",1,0,0,
(SCM shader)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteShader
{
GLuint lp_shader = (GLuint)scm_to_uint32(shader);
glDeleteShader(lp_shader);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDetachShader,"gl-detach-shader",2,0,0,
(SCM program, SCM shader)
"ADD ME LATER")
#define FUNC_NAME s_glDetachShader
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_shader = (GLuint)scm_to_uint32(shader);
glDetachShader(lp_program, lp_shader);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDisableVertexAttribArray,"gl-disable-vertex-attrib-array",1,0,0,
(SCM index)
"ADD ME LATER")
#define FUNC_NAME s_glDisableVertexAttribArray
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
glDisableVertexAttribArray(lp_index);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glEnableVertexAttribArray,"gl-enable-vertex-attrib-array",1,0,0,
(SCM index)
"ADD ME LATER")
#define FUNC_NAME s_glEnableVertexAttribArray
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
glEnableVertexAttribArray(lp_index);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetActiveAttrib,"gl-get-active-attrib",7,0,0,
(SCM program, SCM index, SCM bufSize, SCM length, SCM size, SCM type, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetActiveAttrib
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLint* lp_size = (GLint*)SCM_BYTEVECTOR_CONTENTS(size);
GLenum* lp_type = (GLenum*)SCM_BYTEVECTOR_CONTENTS(type);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
glGetActiveAttrib(lp_program, lp_index, lp_bufSize, lp_length, lp_size, lp_type, lp_name);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetActiveUniform,"gl-get-active-uniform",7,0,0,
(SCM program, SCM index, SCM bufSize, SCM length, SCM size, SCM type, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetActiveUniform
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLint* lp_size = (GLint*)SCM_BYTEVECTOR_CONTENTS(size);
GLenum* lp_type = (GLenum*)SCM_BYTEVECTOR_CONTENTS(type);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
glGetActiveUniform(lp_program, lp_index, lp_bufSize, lp_length, lp_size, lp_type, lp_name);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetAttachedShaders,"gl-get-attached-shaders",4,0,0,
(SCM program, SCM maxCount, SCM count, SCM shaders)
"ADD ME LATER")
#define FUNC_NAME s_glGetAttachedShaders
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLsizei lp_maxCount = (GLsizei)scm_to_uint32(maxCount);
GLsizei* lp_count = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(count);
GLuint* lp_shaders = (GLuint*)SCM_BYTEVECTOR_CONTENTS(shaders);
glGetAttachedShaders(lp_program, lp_maxCount, lp_count, lp_shaders);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetAttribLocation,"gl-get-attrib-location",2,0,0,
(SCM program, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetAttribLocation
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
GLint lp_ret;
lp_ret = glGetAttribLocation(lp_program, lp_name);
return scm_from_int32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramiv,"gl-get-programiv",3,0,0,
(SCM program, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetProgramiv(lp_program, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramInfoLog,"gl-get-program-info-log",4,0,0,
(SCM program, SCM bufSize, SCM length, SCM infoLog)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramInfoLog
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_infoLog = (GLchar*)SCM_BYTEVECTOR_CONTENTS(infoLog);
glGetProgramInfoLog(lp_program, lp_bufSize, lp_length, lp_infoLog);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetShaderiv,"gl-get-shaderiv",3,0,0,
(SCM shader, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetShaderiv
{
GLuint lp_shader = (GLuint)scm_to_uint32(shader);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetShaderiv(lp_shader, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetShaderInfoLog,"gl-get-shader-info-log",4,0,0,
(SCM shader, SCM bufSize, SCM length, SCM infoLog)
"ADD ME LATER")
#define FUNC_NAME s_glGetShaderInfoLog
{
GLuint lp_shader = (GLuint)scm_to_uint32(shader);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_infoLog = (GLchar*)SCM_BYTEVECTOR_CONTENTS(infoLog);
glGetShaderInfoLog(lp_shader, lp_bufSize, lp_length, lp_infoLog);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetShaderSource,"gl-get-shader-source",4,0,0,
(SCM shader, SCM bufSize, SCM length, SCM source)
"ADD ME LATER")
#define FUNC_NAME s_glGetShaderSource
{
GLuint lp_shader = (GLuint)scm_to_uint32(shader);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_source = (GLchar*)SCM_BYTEVECTOR_CONTENTS(source);
glGetShaderSource(lp_shader, lp_bufSize, lp_length, lp_source);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetUniformLocation,"gl-get-uniform-location",2,0,0,
(SCM program, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetUniformLocation
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
GLint lp_ret;
lp_ret = glGetUniformLocation(lp_program, lp_name);
return scm_from_int32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetUniformfv,"gl-get-uniformfv",3,0,0,
(SCM program, SCM location, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetUniformfv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLfloat* lp_params = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(params);
glGetUniformfv(lp_program, lp_location, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetUniformiv,"gl-get-uniformiv",3,0,0,
(SCM program, SCM location, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetUniformiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetUniformiv(lp_program, lp_location, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetVertexAttribdv,"gl-get-vertex-attribdv",3,0,0,
(SCM index, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetVertexAttribdv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLdouble* lp_params = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(params);
glGetVertexAttribdv(lp_index, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetVertexAttribfv,"gl-get-vertex-attribfv",3,0,0,
(SCM index, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetVertexAttribfv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat* lp_params = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(params);
glGetVertexAttribfv(lp_index, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetVertexAttribiv,"gl-get-vertex-attribiv",3,0,0,
(SCM index, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetVertexAttribiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetVertexAttribiv(lp_index, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsProgram,"gl-is-program",1,0,0,
(SCM program)
"ADD ME LATER")
#define FUNC_NAME s_glIsProgram
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLboolean lp_ret;
lp_ret = glIsProgram(lp_program);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsShader,"gl-is-shader",1,0,0,
(SCM shader)
"ADD ME LATER")
#define FUNC_NAME s_glIsShader
{
GLuint lp_shader = (GLuint)scm_to_uint32(shader);
GLboolean lp_ret;
lp_ret = glIsShader(lp_shader);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glLinkProgram,"gl-link-program",1,0,0,
(SCM program)
"ADD ME LATER")
#define FUNC_NAME s_glLinkProgram
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
glLinkProgram(lp_program);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUseProgram,"gl-use-program",1,0,0,
(SCM program)
"ADD ME LATER")
#define FUNC_NAME s_glUseProgram
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
glUseProgram(lp_program);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform1f,"gl-uniform-1f",2,0,0,
(SCM location, SCM v0)
"ADD ME LATER")
#define FUNC_NAME s_glUniform1f
{
GLint lp_location = (GLint)scm_to_int32(location);
GLfloat lp_v0 = (GLfloat)scm_to_double(v0);
glUniform1f(lp_location, lp_v0);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform2f,"gl-uniform-2f",3,0,0,
(SCM location, SCM v0, SCM v1)
"ADD ME LATER")
#define FUNC_NAME s_glUniform2f
{
GLint lp_location = (GLint)scm_to_int32(location);
GLfloat lp_v0 = (GLfloat)scm_to_double(v0);
GLfloat lp_v1 = (GLfloat)scm_to_double(v1);
glUniform2f(lp_location, lp_v0, lp_v1);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform3f,"gl-uniform-3f",4,0,0,
(SCM location, SCM v0, SCM v1, SCM v2)
"ADD ME LATER")
#define FUNC_NAME s_glUniform3f
{
GLint lp_location = (GLint)scm_to_int32(location);
GLfloat lp_v0 = (GLfloat)scm_to_double(v0);
GLfloat lp_v1 = (GLfloat)scm_to_double(v1);
GLfloat lp_v2 = (GLfloat)scm_to_double(v2);
glUniform3f(lp_location, lp_v0, lp_v1, lp_v2);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform4f,"gl-uniform-4f",5,0,0,
(SCM location, SCM v0, SCM v1, SCM v2, SCM v3)
"ADD ME LATER")
#define FUNC_NAME s_glUniform4f
{
GLint lp_location = (GLint)scm_to_int32(location);
GLfloat lp_v0 = (GLfloat)scm_to_double(v0);
GLfloat lp_v1 = (GLfloat)scm_to_double(v1);
GLfloat lp_v2 = (GLfloat)scm_to_double(v2);
GLfloat lp_v3 = (GLfloat)scm_to_double(v3);
glUniform4f(lp_location, lp_v0, lp_v1, lp_v2, lp_v3);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform1i,"gl-uniform-1i",2,0,0,
(SCM location, SCM v0)
"ADD ME LATER")
#define FUNC_NAME s_glUniform1i
{
GLint lp_location = (GLint)scm_to_int32(location);
GLint lp_v0 = (GLint)scm_to_int32(v0);
glUniform1i(lp_location, lp_v0);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform2i,"gl-uniform-2i",3,0,0,
(SCM location, SCM v0, SCM v1)
"ADD ME LATER")
#define FUNC_NAME s_glUniform2i
{
GLint lp_location = (GLint)scm_to_int32(location);
GLint lp_v0 = (GLint)scm_to_int32(v0);
GLint lp_v1 = (GLint)scm_to_int32(v1);
glUniform2i(lp_location, lp_v0, lp_v1);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform3i,"gl-uniform-3i",4,0,0,
(SCM location, SCM v0, SCM v1, SCM v2)
"ADD ME LATER")
#define FUNC_NAME s_glUniform3i
{
GLint lp_location = (GLint)scm_to_int32(location);
GLint lp_v0 = (GLint)scm_to_int32(v0);
GLint lp_v1 = (GLint)scm_to_int32(v1);
GLint lp_v2 = (GLint)scm_to_int32(v2);
glUniform3i(lp_location, lp_v0, lp_v1, lp_v2);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform4i,"gl-uniform-4i",5,0,0,
(SCM location, SCM v0, SCM v1, SCM v2, SCM v3)
"ADD ME LATER")
#define FUNC_NAME s_glUniform4i
{
GLint lp_location = (GLint)scm_to_int32(location);
GLint lp_v0 = (GLint)scm_to_int32(v0);
GLint lp_v1 = (GLint)scm_to_int32(v1);
GLint lp_v2 = (GLint)scm_to_int32(v2);
GLint lp_v3 = (GLint)scm_to_int32(v3);
glUniform4i(lp_location, lp_v0, lp_v1, lp_v2, lp_v3);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform1fv,"gl-uniform-1fv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform1fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform1fv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform2fv,"gl-uniform-2fv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform2fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform2fv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform3fv,"gl-uniform-3fv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform3fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform3fv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform4fv,"gl-uniform-4fv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform4fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform4fv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform1iv,"gl-uniform-1iv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform1iv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLint* lp_value = (GLint*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform1iv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform2iv,"gl-uniform-2iv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform2iv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLint* lp_value = (GLint*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform2iv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform3iv,"gl-uniform-3iv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform3iv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLint* lp_value = (GLint*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform3iv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform4iv,"gl-uniform-4iv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform4iv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLint* lp_value = (GLint*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform4iv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix2fv,"gl-uniform-matrix-2fv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix2fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix2fv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix3fv,"gl-uniform-matrix-3fv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix3fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix3fv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix4fv,"gl-uniform-matrix-4fv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix4fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix4fv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glValidateProgram,"gl-validate-program",1,0,0,
(SCM program)
"ADD ME LATER")
#define FUNC_NAME s_glValidateProgram
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
glValidateProgram(lp_program);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib1d,"gl-vertex-attrib-1d",2,0,0,
(SCM index, SCM x)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib1d
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble lp_x = (GLdouble)scm_to_double(x);
glVertexAttrib1d(lp_index, lp_x);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib1dv,"gl-vertex-attrib-1dv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib1dv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble* lp_v = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib1dv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib1f,"gl-vertex-attrib-1f",2,0,0,
(SCM index, SCM x)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib1f
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat lp_x = (GLfloat)scm_to_double(x);
glVertexAttrib1f(lp_index, lp_x);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib1fv,"gl-vertex-attrib-1fv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib1fv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat* lp_v = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib1fv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib1s,"gl-vertex-attrib-1s",2,0,0,
(SCM index, SCM x)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib1s
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLshort lp_x = (GLshort)scm_to_int16(x);
glVertexAttrib1s(lp_index, lp_x);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib1sv,"gl-vertex-attrib-1sv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib1sv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLshort* lp_v = (GLshort*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib1sv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib2d,"gl-vertex-attrib-2d",3,0,0,
(SCM index, SCM x, SCM y)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib2d
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble lp_x = (GLdouble)scm_to_double(x);
GLdouble lp_y = (GLdouble)scm_to_double(y);
glVertexAttrib2d(lp_index, lp_x, lp_y);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib2dv,"gl-vertex-attrib-2dv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib2dv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble* lp_v = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib2dv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib2f,"gl-vertex-attrib-2f",3,0,0,
(SCM index, SCM x, SCM y)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib2f
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat lp_x = (GLfloat)scm_to_double(x);
GLfloat lp_y = (GLfloat)scm_to_double(y);
glVertexAttrib2f(lp_index, lp_x, lp_y);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib2fv,"gl-vertex-attrib-2fv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib2fv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat* lp_v = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib2fv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib2s,"gl-vertex-attrib-2s",3,0,0,
(SCM index, SCM x, SCM y)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib2s
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLshort lp_x = (GLshort)scm_to_int16(x);
GLshort lp_y = (GLshort)scm_to_int16(y);
glVertexAttrib2s(lp_index, lp_x, lp_y);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib2sv,"gl-vertex-attrib-2sv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib2sv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLshort* lp_v = (GLshort*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib2sv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib3d,"gl-vertex-attrib-3d",4,0,0,
(SCM index, SCM x, SCM y, SCM z)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib3d
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble lp_x = (GLdouble)scm_to_double(x);
GLdouble lp_y = (GLdouble)scm_to_double(y);
GLdouble lp_z = (GLdouble)scm_to_double(z);
glVertexAttrib3d(lp_index, lp_x, lp_y, lp_z);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib3dv,"gl-vertex-attrib-3dv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib3dv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble* lp_v = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib3dv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib3f,"gl-vertex-attrib-3f",4,0,0,
(SCM index, SCM x, SCM y, SCM z)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib3f
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat lp_x = (GLfloat)scm_to_double(x);
GLfloat lp_y = (GLfloat)scm_to_double(y);
GLfloat lp_z = (GLfloat)scm_to_double(z);
glVertexAttrib3f(lp_index, lp_x, lp_y, lp_z);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib3fv,"gl-vertex-attrib-3fv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib3fv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat* lp_v = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib3fv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib3s,"gl-vertex-attrib-3s",4,0,0,
(SCM index, SCM x, SCM y, SCM z)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib3s
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLshort lp_x = (GLshort)scm_to_int16(x);
GLshort lp_y = (GLshort)scm_to_int16(y);
GLshort lp_z = (GLshort)scm_to_int16(z);
glVertexAttrib3s(lp_index, lp_x, lp_y, lp_z);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib3sv,"gl-vertex-attrib-3sv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib3sv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLshort* lp_v = (GLshort*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib3sv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4Nbv,"gl-vertex-attrib-4Nbv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4Nbv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLbyte* lp_v = (GLbyte*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4Nbv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4Niv,"gl-vertex-attrib-4Niv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4Niv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint* lp_v = (GLint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4Niv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4Nsv,"gl-vertex-attrib-4Nsv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4Nsv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLshort* lp_v = (GLshort*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4Nsv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4Nub,"gl-vertex-attrib-4Nub",5,0,0,
(SCM index, SCM x, SCM y, SCM z, SCM w)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4Nub
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLubyte lp_x = (GLubyte)scm_to_uint8(x);
GLubyte lp_y = (GLubyte)scm_to_uint8(y);
GLubyte lp_z = (GLubyte)scm_to_uint8(z);
GLubyte lp_w = (GLubyte)scm_to_uint8(w);
glVertexAttrib4Nub(lp_index, lp_x, lp_y, lp_z, lp_w);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4Nubv,"gl-vertex-attrib-4Nubv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4Nubv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLubyte* lp_v = (GLubyte*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4Nubv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4Nuiv,"gl-vertex-attrib-4Nuiv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4Nuiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint* lp_v = (GLuint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4Nuiv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4Nusv,"gl-vertex-attrib-4Nusv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4Nusv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLushort* lp_v = (GLushort*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4Nusv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4bv,"gl-vertex-attrib-4bv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4bv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLbyte* lp_v = (GLbyte*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4bv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4d,"gl-vertex-attrib-4d",5,0,0,
(SCM index, SCM x, SCM y, SCM z, SCM w)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4d
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble lp_x = (GLdouble)scm_to_double(x);
GLdouble lp_y = (GLdouble)scm_to_double(y);
GLdouble lp_z = (GLdouble)scm_to_double(z);
GLdouble lp_w = (GLdouble)scm_to_double(w);
glVertexAttrib4d(lp_index, lp_x, lp_y, lp_z, lp_w);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4dv,"gl-vertex-attrib-4dv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4dv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble* lp_v = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4dv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4f,"gl-vertex-attrib-4f",5,0,0,
(SCM index, SCM x, SCM y, SCM z, SCM w)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4f
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat lp_x = (GLfloat)scm_to_double(x);
GLfloat lp_y = (GLfloat)scm_to_double(y);
GLfloat lp_z = (GLfloat)scm_to_double(z);
GLfloat lp_w = (GLfloat)scm_to_double(w);
glVertexAttrib4f(lp_index, lp_x, lp_y, lp_z, lp_w);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4fv,"gl-vertex-attrib-4fv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4fv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat* lp_v = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4fv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4iv,"gl-vertex-attrib-4iv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4iv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint* lp_v = (GLint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4iv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4s,"gl-vertex-attrib-4s",5,0,0,
(SCM index, SCM x, SCM y, SCM z, SCM w)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4s
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLshort lp_x = (GLshort)scm_to_int16(x);
GLshort lp_y = (GLshort)scm_to_int16(y);
GLshort lp_z = (GLshort)scm_to_int16(z);
GLshort lp_w = (GLshort)scm_to_int16(w);
glVertexAttrib4s(lp_index, lp_x, lp_y, lp_z, lp_w);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4sv,"gl-vertex-attrib-4sv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4sv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLshort* lp_v = (GLshort*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4sv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4ubv,"gl-vertex-attrib-4ubv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4ubv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLubyte* lp_v = (GLubyte*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4ubv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4uiv,"gl-vertex-attrib-4uiv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4uiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint* lp_v = (GLuint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4uiv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttrib4usv,"gl-vertex-attrib-4usv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttrib4usv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLushort* lp_v = (GLushort*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttrib4usv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribPointer,"gl-vertex-attrib-pointer",6,0,0,
(SCM index, SCM size, SCM type, SCM normalized, SCM stride, SCM pointer)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribPointer
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint lp_size = (GLint)scm_to_int32(size);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLboolean lp_normalized = (GLboolean)scm_to_bool(normalized);
GLsizei lp_stride = (GLsizei)scm_to_uint32(stride);
GLvoid* lp_pointer = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pointer);
glVertexAttribPointer(lp_index, lp_size, lp_type, lp_normalized, lp_stride, lp_pointer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix2x3fv,"gl-uniform-matrix-2x-3fv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix2x3fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix2x3fv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix3x2fv,"gl-uniform-matrix-3x-2fv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix3x2fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix3x2fv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix2x4fv,"gl-uniform-matrix-2x-4fv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix2x4fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix2x4fv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix4x2fv,"gl-uniform-matrix-4x-2fv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix4x2fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix4x2fv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix3x4fv,"gl-uniform-matrix-3x-4fv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix3x4fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix3x4fv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix4x3fv,"gl-uniform-matrix-4x-3fv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix4x3fv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix4x3fv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glColorMaski,"gl-color-maski",5,0,0,
(SCM index, SCM r, SCM g, SCM b, SCM a)
"ADD ME LATER")
#define FUNC_NAME s_glColorMaski
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLboolean lp_r = (GLboolean)scm_to_bool(r);
GLboolean lp_g = (GLboolean)scm_to_bool(g);
GLboolean lp_b = (GLboolean)scm_to_bool(b);
GLboolean lp_a = (GLboolean)scm_to_bool(a);
glColorMaski(lp_index, lp_r, lp_g, lp_b, lp_a);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetBooleani_v,"gl-get-booleani-_v",3,0,0,
(SCM target, SCM index, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetBooleani_v
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLboolean* lp_data = (GLboolean*)SCM_BYTEVECTOR_CONTENTS(data);
glGetBooleani_v(lp_target, lp_index, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetIntegeri_v,"gl-get-integeri-_v",3,0,0,
(SCM target, SCM index, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetIntegeri_v
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint* lp_data = (GLint*)SCM_BYTEVECTOR_CONTENTS(data);
glGetIntegeri_v(lp_target, lp_index, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glEnablei,"gl-enablei",2,0,0,
(SCM target, SCM index)
"ADD ME LATER")
#define FUNC_NAME s_glEnablei
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
glEnablei(lp_target, lp_index);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDisablei,"gl-disablei",2,0,0,
(SCM target, SCM index)
"ADD ME LATER")
#define FUNC_NAME s_glDisablei
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
glDisablei(lp_target, lp_index);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsEnabledi,"gl-is-enabledi",2,0,0,
(SCM target, SCM index)
"ADD ME LATER")
#define FUNC_NAME s_glIsEnabledi
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLboolean lp_ret;
lp_ret = glIsEnabledi(lp_target, lp_index);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBeginTransformFeedback,"gl-begin-transform-feedback",1,0,0,
(SCM primitiveMode)
"ADD ME LATER")
#define FUNC_NAME s_glBeginTransformFeedback
{
GLenum lp_primitiveMode = (GLenum)scm_to_uint32(primitiveMode);
glBeginTransformFeedback(lp_primitiveMode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glEndTransformFeedback,"gl-end-transform-feedback",0,0,0,
(void)
"ADD ME LATER")
#define FUNC_NAME s_glEndTransformFeedback
{
glEndTransformFeedback();
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindBufferRange,"gl-bind-buffer-range",5,0,0,
(SCM target, SCM index, SCM buffer, SCM offset, SCM size)
"ADD ME LATER")
#define FUNC_NAME s_glBindBufferRange
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint lp_buffer = (GLuint)scm_to_uint32(buffer);
GLintptr lp_offset = (GLintptr)scm_to_uint32(offset);
GLsizeiptr lp_size = (GLsizeiptr)scm_to_uint32(size);
glBindBufferRange(lp_target, lp_index, lp_buffer, lp_offset, lp_size);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindBufferBase,"gl-bind-buffer-base",3,0,0,
(SCM target, SCM index, SCM buffer)
"ADD ME LATER")
#define FUNC_NAME s_glBindBufferBase
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint lp_buffer = (GLuint)scm_to_uint32(buffer);
glBindBufferBase(lp_target, lp_index, lp_buffer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetTransformFeedbackVarying,"gl-get-transform-feedback-varying",7,0,0,
(SCM program, SCM index, SCM bufSize, SCM length, SCM size, SCM type, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetTransformFeedbackVarying
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLsizei* lp_size = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(size);
GLenum* lp_type = (GLenum*)SCM_BYTEVECTOR_CONTENTS(type);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
glGetTransformFeedbackVarying(lp_program, lp_index, lp_bufSize, lp_length, lp_size, lp_type, lp_name);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClampColor,"gl-clamp-color",2,0,0,
(SCM target, SCM clamp)
"ADD ME LATER")
#define FUNC_NAME s_glClampColor
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_clamp = (GLenum)scm_to_uint32(clamp);
glClampColor(lp_target, lp_clamp);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBeginConditionalRender,"gl-begin-conditional-render",2,0,0,
(SCM id, SCM mode)
"ADD ME LATER")
#define FUNC_NAME s_glBeginConditionalRender
{
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
glBeginConditionalRender(lp_id, lp_mode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glEndConditionalRender,"gl-end-conditional-render",0,0,0,
(void)
"ADD ME LATER")
#define FUNC_NAME s_glEndConditionalRender
{
glEndConditionalRender();
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribIPointer,"gl-vertex-attrib-iPointer",5,0,0,
(SCM index, SCM size, SCM type, SCM stride, SCM pointer)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribIPointer
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint lp_size = (GLint)scm_to_int32(size);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLsizei lp_stride = (GLsizei)scm_to_uint32(stride);
GLvoid* lp_pointer = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pointer);
glVertexAttribIPointer(lp_index, lp_size, lp_type, lp_stride, lp_pointer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetVertexAttribIiv,"gl-get-vertex-attrib-iiv",3,0,0,
(SCM index, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetVertexAttribIiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetVertexAttribIiv(lp_index, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetVertexAttribIuiv,"gl-get-vertex-attrib-iuiv",3,0,0,
(SCM index, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetVertexAttribIuiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLuint* lp_params = (GLuint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetVertexAttribIuiv(lp_index, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI1i,"gl-vertex-attrib-i1i",2,0,0,
(SCM index, SCM x)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI1i
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint lp_x = (GLint)scm_to_int32(x);
glVertexAttribI1i(lp_index, lp_x);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI2i,"gl-vertex-attrib-i2i",3,0,0,
(SCM index, SCM x, SCM y)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI2i
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
glVertexAttribI2i(lp_index, lp_x, lp_y);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI3i,"gl-vertex-attrib-i3i",4,0,0,
(SCM index, SCM x, SCM y, SCM z)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI3i
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLint lp_z = (GLint)scm_to_int32(z);
glVertexAttribI3i(lp_index, lp_x, lp_y, lp_z);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI4i,"gl-vertex-attrib-i4i",5,0,0,
(SCM index, SCM x, SCM y, SCM z, SCM w)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI4i
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLint lp_z = (GLint)scm_to_int32(z);
GLint lp_w = (GLint)scm_to_int32(w);
glVertexAttribI4i(lp_index, lp_x, lp_y, lp_z, lp_w);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI1ui,"gl-vertex-attrib-i1ui",2,0,0,
(SCM index, SCM x)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI1ui
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint lp_x = (GLuint)scm_to_uint32(x);
glVertexAttribI1ui(lp_index, lp_x);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI2ui,"gl-vertex-attrib-i2ui",3,0,0,
(SCM index, SCM x, SCM y)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI2ui
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint lp_x = (GLuint)scm_to_uint32(x);
GLuint lp_y = (GLuint)scm_to_uint32(y);
glVertexAttribI2ui(lp_index, lp_x, lp_y);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI3ui,"gl-vertex-attrib-i3ui",4,0,0,
(SCM index, SCM x, SCM y, SCM z)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI3ui
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint lp_x = (GLuint)scm_to_uint32(x);
GLuint lp_y = (GLuint)scm_to_uint32(y);
GLuint lp_z = (GLuint)scm_to_uint32(z);
glVertexAttribI3ui(lp_index, lp_x, lp_y, lp_z);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI4ui,"gl-vertex-attrib-i4ui",5,0,0,
(SCM index, SCM x, SCM y, SCM z, SCM w)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI4ui
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint lp_x = (GLuint)scm_to_uint32(x);
GLuint lp_y = (GLuint)scm_to_uint32(y);
GLuint lp_z = (GLuint)scm_to_uint32(z);
GLuint lp_w = (GLuint)scm_to_uint32(w);
glVertexAttribI4ui(lp_index, lp_x, lp_y, lp_z, lp_w);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI1iv,"gl-vertex-attrib-i1iv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI1iv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint* lp_v = (GLint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI1iv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI2iv,"gl-vertex-attrib-i2iv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI2iv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint* lp_v = (GLint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI2iv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI3iv,"gl-vertex-attrib-i3iv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI3iv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint* lp_v = (GLint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI3iv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI4iv,"gl-vertex-attrib-i4iv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI4iv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint* lp_v = (GLint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI4iv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI1uiv,"gl-vertex-attrib-i1uiv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI1uiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint* lp_v = (GLuint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI1uiv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI2uiv,"gl-vertex-attrib-i2uiv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI2uiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint* lp_v = (GLuint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI2uiv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI3uiv,"gl-vertex-attrib-i3uiv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI3uiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint* lp_v = (GLuint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI3uiv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI4uiv,"gl-vertex-attrib-i4uiv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI4uiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint* lp_v = (GLuint*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI4uiv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI4bv,"gl-vertex-attrib-i4bv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI4bv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLbyte* lp_v = (GLbyte*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI4bv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI4sv,"gl-vertex-attrib-i4sv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI4sv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLshort* lp_v = (GLshort*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI4sv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI4ubv,"gl-vertex-attrib-i4ubv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI4ubv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLubyte* lp_v = (GLubyte*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI4ubv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribI4usv,"gl-vertex-attrib-i4usv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribI4usv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLushort* lp_v = (GLushort*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribI4usv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetUniformuiv,"gl-get-uniformuiv",3,0,0,
(SCM program, SCM location, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetUniformuiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLuint* lp_params = (GLuint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetUniformuiv(lp_program, lp_location, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindFragDataLocation,"gl-bind-frag-data-location",3,0,0,
(SCM program, SCM color, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glBindFragDataLocation
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_color = (GLuint)scm_to_uint32(color);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
glBindFragDataLocation(lp_program, lp_color, lp_name);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetFragDataLocation,"gl-get-frag-data-location",2,0,0,
(SCM program, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetFragDataLocation
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
GLint lp_ret;
lp_ret = glGetFragDataLocation(lp_program, lp_name);
return scm_from_int32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform1ui,"gl-uniform-1ui",2,0,0,
(SCM location, SCM v0)
"ADD ME LATER")
#define FUNC_NAME s_glUniform1ui
{
GLint lp_location = (GLint)scm_to_int32(location);
GLuint lp_v0 = (GLuint)scm_to_uint32(v0);
glUniform1ui(lp_location, lp_v0);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform2ui,"gl-uniform-2ui",3,0,0,
(SCM location, SCM v0, SCM v1)
"ADD ME LATER")
#define FUNC_NAME s_glUniform2ui
{
GLint lp_location = (GLint)scm_to_int32(location);
GLuint lp_v0 = (GLuint)scm_to_uint32(v0);
GLuint lp_v1 = (GLuint)scm_to_uint32(v1);
glUniform2ui(lp_location, lp_v0, lp_v1);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform3ui,"gl-uniform-3ui",4,0,0,
(SCM location, SCM v0, SCM v1, SCM v2)
"ADD ME LATER")
#define FUNC_NAME s_glUniform3ui
{
GLint lp_location = (GLint)scm_to_int32(location);
GLuint lp_v0 = (GLuint)scm_to_uint32(v0);
GLuint lp_v1 = (GLuint)scm_to_uint32(v1);
GLuint lp_v2 = (GLuint)scm_to_uint32(v2);
glUniform3ui(lp_location, lp_v0, lp_v1, lp_v2);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform4ui,"gl-uniform-4ui",5,0,0,
(SCM location, SCM v0, SCM v1, SCM v2, SCM v3)
"ADD ME LATER")
#define FUNC_NAME s_glUniform4ui
{
GLint lp_location = (GLint)scm_to_int32(location);
GLuint lp_v0 = (GLuint)scm_to_uint32(v0);
GLuint lp_v1 = (GLuint)scm_to_uint32(v1);
GLuint lp_v2 = (GLuint)scm_to_uint32(v2);
GLuint lp_v3 = (GLuint)scm_to_uint32(v3);
glUniform4ui(lp_location, lp_v0, lp_v1, lp_v2, lp_v3);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform1uiv,"gl-uniform-1uiv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform1uiv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform1uiv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform2uiv,"gl-uniform-2uiv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform2uiv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform2uiv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform3uiv,"gl-uniform-3uiv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform3uiv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform3uiv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform4uiv,"gl-uniform-4uiv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform4uiv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform4uiv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexParameterIiv,"gl-tex-parameter-iiv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glTexParameterIiv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glTexParameterIiv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexParameterIuiv,"gl-tex-parameter-iuiv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glTexParameterIuiv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLuint* lp_params = (GLuint*)SCM_BYTEVECTOR_CONTENTS(params);
glTexParameterIuiv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetTexParameterIiv,"gl-get-tex-parameter-iiv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetTexParameterIiv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetTexParameterIiv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetTexParameterIuiv,"gl-get-tex-parameter-iuiv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetTexParameterIuiv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLuint* lp_params = (GLuint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetTexParameterIuiv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearBufferiv,"gl-clear-bufferiv",3,0,0,
(SCM buffer, SCM drawbuffer, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glClearBufferiv
{
GLenum lp_buffer = (GLenum)scm_to_uint32(buffer);
GLint lp_drawbuffer = (GLint)scm_to_int32(drawbuffer);
GLint* lp_value = (GLint*)SCM_BYTEVECTOR_CONTENTS(value);
glClearBufferiv(lp_buffer, lp_drawbuffer, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearBufferuiv,"gl-clear-bufferuiv",3,0,0,
(SCM buffer, SCM drawbuffer, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glClearBufferuiv
{
GLenum lp_buffer = (GLenum)scm_to_uint32(buffer);
GLint lp_drawbuffer = (GLint)scm_to_int32(drawbuffer);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glClearBufferuiv(lp_buffer, lp_drawbuffer, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearBufferfv,"gl-clear-bufferfv",3,0,0,
(SCM buffer, SCM drawbuffer, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glClearBufferfv
{
GLenum lp_buffer = (GLenum)scm_to_uint32(buffer);
GLint lp_drawbuffer = (GLint)scm_to_int32(drawbuffer);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glClearBufferfv(lp_buffer, lp_drawbuffer, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearBufferfi,"gl-clear-bufferfi",4,0,0,
(SCM buffer, SCM drawbuffer, SCM depth, SCM stencil)
"ADD ME LATER")
#define FUNC_NAME s_glClearBufferfi
{
GLenum lp_buffer = (GLenum)scm_to_uint32(buffer);
GLint lp_drawbuffer = (GLint)scm_to_int32(drawbuffer);
GLfloat lp_depth = (GLfloat)scm_to_double(depth);
GLint lp_stencil = (GLint)scm_to_int32(stencil);
glClearBufferfi(lp_buffer, lp_drawbuffer, lp_depth, lp_stencil);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetStringi,"gl-get-stringi",2,0,0,
(SCM name, SCM index)
"ADD ME LATER")
#define FUNC_NAME s_glGetStringi
{
GLenum lp_name = (GLenum)scm_to_uint32(name);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLubyte lp_ret;
lp_ret = glGetStringi(lp_name, lp_index);
return scm_from_uint8(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsRenderbuffer,"gl-is-renderbuffer",1,0,0,
(SCM renderbuffer)
"ADD ME LATER")
#define FUNC_NAME s_glIsRenderbuffer
{
GLuint lp_renderbuffer = (GLuint)scm_to_uint32(renderbuffer);
GLboolean lp_ret;
lp_ret = glIsRenderbuffer(lp_renderbuffer);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindRenderbuffer,"gl-bind-renderbuffer",2,0,0,
(SCM target, SCM renderbuffer)
"ADD ME LATER")
#define FUNC_NAME s_glBindRenderbuffer
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_renderbuffer = (GLuint)scm_to_uint32(renderbuffer);
glBindRenderbuffer(lp_target, lp_renderbuffer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteRenderbuffers,"gl-delete-renderbuffers",2,0,0,
(SCM n, SCM renderbuffers)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteRenderbuffers
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_renderbuffers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(renderbuffers);
glDeleteRenderbuffers(lp_n, lp_renderbuffers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGenRenderbuffers,"gl-gen-renderbuffers",2,0,0,
(SCM n, SCM renderbuffers)
"ADD ME LATER")
#define FUNC_NAME s_glGenRenderbuffers
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_renderbuffers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(renderbuffers);
glGenRenderbuffers(lp_n, lp_renderbuffers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glRenderbufferStorage,"gl-renderbuffer-storage",4,0,0,
(SCM target, SCM internalformat, SCM width, SCM height)
"ADD ME LATER")
#define FUNC_NAME s_glRenderbufferStorage
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
glRenderbufferStorage(lp_target, lp_internalformat, lp_width, lp_height);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetRenderbufferParameteriv,"gl-get-renderbuffer-parameteriv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetRenderbufferParameteriv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetRenderbufferParameteriv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsFramebuffer,"gl-is-framebuffer",1,0,0,
(SCM framebuffer)
"ADD ME LATER")
#define FUNC_NAME s_glIsFramebuffer
{
GLuint lp_framebuffer = (GLuint)scm_to_uint32(framebuffer);
GLboolean lp_ret;
lp_ret = glIsFramebuffer(lp_framebuffer);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindFramebuffer,"gl-bind-framebuffer",2,0,0,
(SCM target, SCM framebuffer)
"ADD ME LATER")
#define FUNC_NAME s_glBindFramebuffer
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_framebuffer = (GLuint)scm_to_uint32(framebuffer);
glBindFramebuffer(lp_target, lp_framebuffer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteFramebuffers,"gl-delete-framebuffers",2,0,0,
(SCM n, SCM framebuffers)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteFramebuffers
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_framebuffers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(framebuffers);
glDeleteFramebuffers(lp_n, lp_framebuffers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGenFramebuffers,"gl-gen-framebuffers",2,0,0,
(SCM n, SCM framebuffers)
"ADD ME LATER")
#define FUNC_NAME s_glGenFramebuffers
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_framebuffers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(framebuffers);
glGenFramebuffers(lp_n, lp_framebuffers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCheckFramebufferStatus,"gl-check-framebuffer-status",1,0,0,
(SCM target)
"ADD ME LATER")
#define FUNC_NAME s_glCheckFramebufferStatus
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_ret;
lp_ret = glCheckFramebufferStatus(lp_target);
return scm_from_uint32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFramebufferTexture1D,"gl-framebuffer-texture-1D",5,0,0,
(SCM target, SCM attachment, SCM textarget, SCM texture, SCM level)
"ADD ME LATER")
#define FUNC_NAME s_glFramebufferTexture1D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_attachment = (GLenum)scm_to_uint32(attachment);
GLenum lp_textarget = (GLenum)scm_to_uint32(textarget);
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLint lp_level = (GLint)scm_to_int32(level);
glFramebufferTexture1D(lp_target, lp_attachment, lp_textarget, lp_texture, lp_level);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFramebufferTexture2D,"gl-framebuffer-texture-2D",5,0,0,
(SCM target, SCM attachment, SCM textarget, SCM texture, SCM level)
"ADD ME LATER")
#define FUNC_NAME s_glFramebufferTexture2D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_attachment = (GLenum)scm_to_uint32(attachment);
GLenum lp_textarget = (GLenum)scm_to_uint32(textarget);
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLint lp_level = (GLint)scm_to_int32(level);
glFramebufferTexture2D(lp_target, lp_attachment, lp_textarget, lp_texture, lp_level);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFramebufferTexture3D,"gl-framebuffer-texture-3D",6,0,0,
(SCM target, SCM attachment, SCM textarget, SCM texture, SCM level, SCM zoffset)
"ADD ME LATER")
#define FUNC_NAME s_glFramebufferTexture3D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_attachment = (GLenum)scm_to_uint32(attachment);
GLenum lp_textarget = (GLenum)scm_to_uint32(textarget);
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_zoffset = (GLint)scm_to_int32(zoffset);
glFramebufferTexture3D(lp_target, lp_attachment, lp_textarget, lp_texture, lp_level, lp_zoffset);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFramebufferRenderbuffer,"gl-framebuffer-renderbuffer",4,0,0,
(SCM target, SCM attachment, SCM renderbuffertarget, SCM renderbuffer)
"ADD ME LATER")
#define FUNC_NAME s_glFramebufferRenderbuffer
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_attachment = (GLenum)scm_to_uint32(attachment);
GLenum lp_renderbuffertarget = (GLenum)scm_to_uint32(renderbuffertarget);
GLuint lp_renderbuffer = (GLuint)scm_to_uint32(renderbuffer);
glFramebufferRenderbuffer(lp_target, lp_attachment, lp_renderbuffertarget, lp_renderbuffer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetFramebufferAttachmentParameteriv,"gl-get-framebuffer-attachment-parameteriv",4,0,0,
(SCM target, SCM attachment, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetFramebufferAttachmentParameteriv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_attachment = (GLenum)scm_to_uint32(attachment);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetFramebufferAttachmentParameteriv(lp_target, lp_attachment, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGenerateMipmap,"gl-generate-mipmap",1,0,0,
(SCM target)
"ADD ME LATER")
#define FUNC_NAME s_glGenerateMipmap
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
glGenerateMipmap(lp_target);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBlitFramebuffer,"gl-blit-framebuffer",10,0,0,
(SCM srcX0, SCM srcY0, SCM srcX1, SCM srcY1, SCM dstX0, SCM dstY0, SCM dstX1, SCM dstY1, SCM mask, SCM filter)
"ADD ME LATER")
#define FUNC_NAME s_glBlitFramebuffer
{
GLint lp_srcX0 = (GLint)scm_to_int32(srcX0);
GLint lp_srcY0 = (GLint)scm_to_int32(srcY0);
GLint lp_srcX1 = (GLint)scm_to_int32(srcX1);
GLint lp_srcY1 = (GLint)scm_to_int32(srcY1);
GLint lp_dstX0 = (GLint)scm_to_int32(dstX0);
GLint lp_dstY0 = (GLint)scm_to_int32(dstY0);
GLint lp_dstX1 = (GLint)scm_to_int32(dstX1);
GLint lp_dstY1 = (GLint)scm_to_int32(dstY1);
GLbitfield lp_mask = (GLbitfield)scm_to_uint32(mask);
GLenum lp_filter = (GLenum)scm_to_uint32(filter);
glBlitFramebuffer(lp_srcX0, lp_srcY0, lp_srcX1, lp_srcY1, lp_dstX0, lp_dstY0, lp_dstX1, lp_dstY1, lp_mask, lp_filter);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glRenderbufferStorageMultisample,"gl-renderbuffer-storage-multisample",5,0,0,
(SCM target, SCM samples, SCM internalformat, SCM width, SCM height)
"ADD ME LATER")
#define FUNC_NAME s_glRenderbufferStorageMultisample
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizei lp_samples = (GLsizei)scm_to_uint32(samples);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
glRenderbufferStorageMultisample(lp_target, lp_samples, lp_internalformat, lp_width, lp_height);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFramebufferTextureLayer,"gl-framebuffer-texture-layer",5,0,0,
(SCM target, SCM attachment, SCM texture, SCM level, SCM layer)
"ADD ME LATER")
#define FUNC_NAME s_glFramebufferTextureLayer
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_attachment = (GLenum)scm_to_uint32(attachment);
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_layer = (GLint)scm_to_int32(layer);
glFramebufferTextureLayer(lp_target, lp_attachment, lp_texture, lp_level, lp_layer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glMapBufferRange,"gl-map-buffer-range",4,0,0,
(SCM target, SCM offset, SCM length, SCM access)
"ADD ME LATER")
#define FUNC_NAME s_glMapBufferRange
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLintptr lp_offset = (GLintptr)scm_to_uint32(offset);
GLsizeiptr lp_length = (GLsizeiptr)scm_to_uint32(length);
GLbitfield lp_access = (GLbitfield)scm_to_uint32(access);
glMapBufferRange(lp_target, lp_offset, lp_length, lp_access);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFlushMappedBufferRange,"gl-flush-mapped-buffer-range",3,0,0,
(SCM target, SCM offset, SCM length)
"ADD ME LATER")
#define FUNC_NAME s_glFlushMappedBufferRange
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLintptr lp_offset = (GLintptr)scm_to_uint32(offset);
GLsizeiptr lp_length = (GLsizeiptr)scm_to_uint32(length);
glFlushMappedBufferRange(lp_target, lp_offset, lp_length);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindVertexArray,"gl-bind-vertex-array",1,0,0,
(SCM array)
"ADD ME LATER")
#define FUNC_NAME s_glBindVertexArray
{
GLuint lp_array = (GLuint)scm_to_uint32(array);
glBindVertexArray(lp_array);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteVertexArrays,"gl-delete-vertex-arrays",2,0,0,
(SCM n, SCM arrays)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteVertexArrays
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_arrays = (GLuint*)SCM_BYTEVECTOR_CONTENTS(arrays);
glDeleteVertexArrays(lp_n, lp_arrays);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGenVertexArrays,"gl-gen-vertex-arrays",2,0,0,
(SCM n, SCM arrays)
"ADD ME LATER")
#define FUNC_NAME s_glGenVertexArrays
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_arrays = (GLuint*)SCM_BYTEVECTOR_CONTENTS(arrays);
glGenVertexArrays(lp_n, lp_arrays);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsVertexArray,"gl-is-vertex-array",1,0,0,
(SCM array)
"ADD ME LATER")
#define FUNC_NAME s_glIsVertexArray
{
GLuint lp_array = (GLuint)scm_to_uint32(array);
GLboolean lp_ret;
lp_ret = glIsVertexArray(lp_array);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawArraysInstanced,"gl-draw-arrays-instanced",4,0,0,
(SCM mode, SCM first, SCM count, SCM instancecount)
"ADD ME LATER")
#define FUNC_NAME s_glDrawArraysInstanced
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLint lp_first = (GLint)scm_to_int32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLsizei lp_instancecount = (GLsizei)scm_to_uint32(instancecount);
glDrawArraysInstanced(lp_mode, lp_first, lp_count, lp_instancecount);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawElementsInstanced,"gl-draw-elements-instanced",5,0,0,
(SCM mode, SCM count, SCM type, SCM indices, SCM instancecount)
"ADD ME LATER")
#define FUNC_NAME s_glDrawElementsInstanced
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_indices = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indices);
GLsizei lp_instancecount = (GLsizei)scm_to_uint32(instancecount);
glDrawElementsInstanced(lp_mode, lp_count, lp_type, lp_indices, lp_instancecount);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexBuffer,"gl-tex-buffer",3,0,0,
(SCM target, SCM internalformat, SCM buffer)
"ADD ME LATER")
#define FUNC_NAME s_glTexBuffer
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLuint lp_buffer = (GLuint)scm_to_uint32(buffer);
glTexBuffer(lp_target, lp_internalformat, lp_buffer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPrimitiveRestartIndex,"gl-primitive-restart-index",1,0,0,
(SCM index)
"ADD ME LATER")
#define FUNC_NAME s_glPrimitiveRestartIndex
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
glPrimitiveRestartIndex(lp_index);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCopyBufferSubData,"gl-copy-buffer-sub-data",5,0,0,
(SCM readTarget, SCM writeTarget, SCM readOffset, SCM writeOffset, SCM size)
"ADD ME LATER")
#define FUNC_NAME s_glCopyBufferSubData
{
GLenum lp_readTarget = (GLenum)scm_to_uint32(readTarget);
GLenum lp_writeTarget = (GLenum)scm_to_uint32(writeTarget);
GLintptr lp_readOffset = (GLintptr)scm_to_uint32(readOffset);
GLintptr lp_writeOffset = (GLintptr)scm_to_uint32(writeOffset);
GLsizeiptr lp_size = (GLsizeiptr)scm_to_uint32(size);
glCopyBufferSubData(lp_readTarget, lp_writeTarget, lp_readOffset, lp_writeOffset, lp_size);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetActiveUniformsiv,"gl-get-active-uniformsiv",5,0,0,
(SCM program, SCM uniformCount, SCM uniformIndices, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetActiveUniformsiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLsizei lp_uniformCount = (GLsizei)scm_to_uint32(uniformCount);
GLuint* lp_uniformIndices = (GLuint*)SCM_BYTEVECTOR_CONTENTS(uniformIndices);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetActiveUniformsiv(lp_program, lp_uniformCount, lp_uniformIndices, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetActiveUniformName,"gl-get-active-uniform-name",5,0,0,
(SCM program, SCM uniformIndex, SCM bufSize, SCM length, SCM uniformName)
"ADD ME LATER")
#define FUNC_NAME s_glGetActiveUniformName
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_uniformIndex = (GLuint)scm_to_uint32(uniformIndex);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_uniformName = (GLchar*)SCM_BYTEVECTOR_CONTENTS(uniformName);
glGetActiveUniformName(lp_program, lp_uniformIndex, lp_bufSize, lp_length, lp_uniformName);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetUniformBlockIndex,"gl-get-uniform-block-index",2,0,0,
(SCM program, SCM uniformBlockName)
"ADD ME LATER")
#define FUNC_NAME s_glGetUniformBlockIndex
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLchar* lp_uniformBlockName = (GLchar*)SCM_BYTEVECTOR_CONTENTS(uniformBlockName);
GLuint lp_ret;
lp_ret = glGetUniformBlockIndex(lp_program, lp_uniformBlockName);
return scm_from_uint32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetActiveUniformBlockiv,"gl-get-active-uniform-blockiv",4,0,0,
(SCM program, SCM uniformBlockIndex, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetActiveUniformBlockiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_uniformBlockIndex = (GLuint)scm_to_uint32(uniformBlockIndex);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetActiveUniformBlockiv(lp_program, lp_uniformBlockIndex, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetActiveUniformBlockName,"gl-get-active-uniform-block-name",5,0,0,
(SCM program, SCM uniformBlockIndex, SCM bufSize, SCM length, SCM uniformBlockName)
"ADD ME LATER")
#define FUNC_NAME s_glGetActiveUniformBlockName
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_uniformBlockIndex = (GLuint)scm_to_uint32(uniformBlockIndex);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_uniformBlockName = (GLchar*)SCM_BYTEVECTOR_CONTENTS(uniformBlockName);
glGetActiveUniformBlockName(lp_program, lp_uniformBlockIndex, lp_bufSize, lp_length, lp_uniformBlockName);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformBlockBinding,"gl-uniform-block-binding",3,0,0,
(SCM program, SCM uniformBlockIndex, SCM uniformBlockBinding)
"ADD ME LATER")
#define FUNC_NAME s_glUniformBlockBinding
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_uniformBlockIndex = (GLuint)scm_to_uint32(uniformBlockIndex);
GLuint lp_uniformBlockBinding = (GLuint)scm_to_uint32(uniformBlockBinding);
glUniformBlockBinding(lp_program, lp_uniformBlockIndex, lp_uniformBlockBinding);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawElementsBaseVertex,"gl-draw-elements-base-vertex",5,0,0,
(SCM mode, SCM count, SCM type, SCM indices, SCM basevertex)
"ADD ME LATER")
#define FUNC_NAME s_glDrawElementsBaseVertex
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_indices = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indices);
GLint lp_basevertex = (GLint)scm_to_int32(basevertex);
glDrawElementsBaseVertex(lp_mode, lp_count, lp_type, lp_indices, lp_basevertex);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawRangeElementsBaseVertex,"gl-draw-range-elements-base-vertex",7,0,0,
(SCM mode, SCM start, SCM end, SCM count, SCM type, SCM indices, SCM basevertex)
"ADD ME LATER")
#define FUNC_NAME s_glDrawRangeElementsBaseVertex
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLuint lp_start = (GLuint)scm_to_uint32(start);
GLuint lp_end = (GLuint)scm_to_uint32(end);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_indices = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indices);
GLint lp_basevertex = (GLint)scm_to_int32(basevertex);
glDrawRangeElementsBaseVertex(lp_mode, lp_start, lp_end, lp_count, lp_type, lp_indices, lp_basevertex);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawElementsInstancedBaseVertex,"gl-draw-elements-instanced-base-vertex",6,0,0,
(SCM mode, SCM count, SCM type, SCM indices, SCM instancecount, SCM basevertex)
"ADD ME LATER")
#define FUNC_NAME s_glDrawElementsInstancedBaseVertex
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_indices = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indices);
GLsizei lp_instancecount = (GLsizei)scm_to_uint32(instancecount);
GLint lp_basevertex = (GLint)scm_to_int32(basevertex);
glDrawElementsInstancedBaseVertex(lp_mode, lp_count, lp_type, lp_indices, lp_instancecount, lp_basevertex);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProvokingVertex,"gl-provoking-vertex",1,0,0,
(SCM mode)
"ADD ME LATER")
#define FUNC_NAME s_glProvokingVertex
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
glProvokingVertex(lp_mode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetInteger64v,"gl-get-integer-64v",2,0,0,
(SCM pname, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetInteger64v
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint64* lp_data = (GLint64*)SCM_BYTEVECTOR_CONTENTS(data);
glGetInteger64v(lp_pname, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetInteger64i_v,"gl-get-integer-64i-_v",3,0,0,
(SCM target, SCM index, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetInteger64i_v
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint64* lp_data = (GLint64*)SCM_BYTEVECTOR_CONTENTS(data);
glGetInteger64i_v(lp_target, lp_index, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetBufferParameteri64v,"gl-get-buffer-parameteri-64v",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetBufferParameteri64v
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint64* lp_params = (GLint64*)SCM_BYTEVECTOR_CONTENTS(params);
glGetBufferParameteri64v(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFramebufferTexture,"gl-framebuffer-texture",4,0,0,
(SCM target, SCM attachment, SCM texture, SCM level)
"ADD ME LATER")
#define FUNC_NAME s_glFramebufferTexture
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_attachment = (GLenum)scm_to_uint32(attachment);
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLint lp_level = (GLint)scm_to_int32(level);
glFramebufferTexture(lp_target, lp_attachment, lp_texture, lp_level);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexImage2DMultisample,"gl-tex-image-2DMultisample",6,0,0,
(SCM target, SCM samples, SCM internalformat, SCM width, SCM height, SCM fixedsamplelocations)
"ADD ME LATER")
#define FUNC_NAME s_glTexImage2DMultisample
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizei lp_samples = (GLsizei)scm_to_uint32(samples);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLboolean lp_fixedsamplelocations = (GLboolean)scm_to_bool(fixedsamplelocations);
glTexImage2DMultisample(lp_target, lp_samples, lp_internalformat, lp_width, lp_height, lp_fixedsamplelocations);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexImage3DMultisample,"gl-tex-image-3DMultisample",7,0,0,
(SCM target, SCM samples, SCM internalformat, SCM width, SCM height, SCM depth, SCM fixedsamplelocations)
"ADD ME LATER")
#define FUNC_NAME s_glTexImage3DMultisample
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizei lp_samples = (GLsizei)scm_to_uint32(samples);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLsizei lp_depth = (GLsizei)scm_to_uint32(depth);
GLboolean lp_fixedsamplelocations = (GLboolean)scm_to_bool(fixedsamplelocations);
glTexImage3DMultisample(lp_target, lp_samples, lp_internalformat, lp_width, lp_height, lp_depth, lp_fixedsamplelocations);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetMultisamplefv,"gl-get-multisamplefv",3,0,0,
(SCM pname, SCM index, SCM val)
"ADD ME LATER")
#define FUNC_NAME s_glGetMultisamplefv
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat* lp_val = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(val);
glGetMultisamplefv(lp_pname, lp_index, lp_val);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glSampleMaski,"gl-sample-maski",2,0,0,
(SCM maskNumber, SCM mask)
"ADD ME LATER")
#define FUNC_NAME s_glSampleMaski
{
GLuint lp_maskNumber = (GLuint)scm_to_uint32(maskNumber);
GLbitfield lp_mask = (GLbitfield)scm_to_uint32(mask);
glSampleMaski(lp_maskNumber, lp_mask);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindFragDataLocationIndexed,"gl-bind-frag-data-location-indexed",4,0,0,
(SCM program, SCM colorNumber, SCM index, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glBindFragDataLocationIndexed
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_colorNumber = (GLuint)scm_to_uint32(colorNumber);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
glBindFragDataLocationIndexed(lp_program, lp_colorNumber, lp_index, lp_name);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetFragDataIndex,"gl-get-frag-data-index",2,0,0,
(SCM program, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetFragDataIndex
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
GLint lp_ret;
lp_ret = glGetFragDataIndex(lp_program, lp_name);
return scm_from_int32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGenSamplers,"gl-gen-samplers",2,0,0,
(SCM count, SCM samplers)
"ADD ME LATER")
#define FUNC_NAME s_glGenSamplers
{
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_samplers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(samplers);
glGenSamplers(lp_count, lp_samplers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteSamplers,"gl-delete-samplers",2,0,0,
(SCM count, SCM samplers)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteSamplers
{
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_samplers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(samplers);
glDeleteSamplers(lp_count, lp_samplers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsSampler,"gl-is-sampler",1,0,0,
(SCM sampler)
"ADD ME LATER")
#define FUNC_NAME s_glIsSampler
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLboolean lp_ret;
lp_ret = glIsSampler(lp_sampler);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindSampler,"gl-bind-sampler",2,0,0,
(SCM unit, SCM sampler)
"ADD ME LATER")
#define FUNC_NAME s_glBindSampler
{
GLuint lp_unit = (GLuint)scm_to_uint32(unit);
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
glBindSampler(lp_unit, lp_sampler);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glSamplerParameteri,"gl-sampler-parameteri",3,0,0,
(SCM sampler, SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glSamplerParameteri
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint lp_param = (GLint)scm_to_int32(param);
glSamplerParameteri(lp_sampler, lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glSamplerParameteriv,"gl-sampler-parameteriv",3,0,0,
(SCM sampler, SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glSamplerParameteriv
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_param = (GLint*)SCM_BYTEVECTOR_CONTENTS(param);
glSamplerParameteriv(lp_sampler, lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glSamplerParameterf,"gl-sampler-parameterf",3,0,0,
(SCM sampler, SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glSamplerParameterf
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat lp_param = (GLfloat)scm_to_double(param);
glSamplerParameterf(lp_sampler, lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glSamplerParameterfv,"gl-sampler-parameterfv",3,0,0,
(SCM sampler, SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glSamplerParameterfv
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat* lp_param = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(param);
glSamplerParameterfv(lp_sampler, lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glSamplerParameterIiv,"gl-sampler-parameter-iiv",3,0,0,
(SCM sampler, SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glSamplerParameterIiv
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_param = (GLint*)SCM_BYTEVECTOR_CONTENTS(param);
glSamplerParameterIiv(lp_sampler, lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glSamplerParameterIuiv,"gl-sampler-parameter-iuiv",3,0,0,
(SCM sampler, SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glSamplerParameterIuiv
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLuint* lp_param = (GLuint*)SCM_BYTEVECTOR_CONTENTS(param);
glSamplerParameterIuiv(lp_sampler, lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetSamplerParameteriv,"gl-get-sampler-parameteriv",3,0,0,
(SCM sampler, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetSamplerParameteriv
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetSamplerParameteriv(lp_sampler, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetSamplerParameterIiv,"gl-get-sampler-parameter-iiv",3,0,0,
(SCM sampler, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetSamplerParameterIiv
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetSamplerParameterIiv(lp_sampler, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetSamplerParameterfv,"gl-get-sampler-parameterfv",3,0,0,
(SCM sampler, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetSamplerParameterfv
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat* lp_params = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(params);
glGetSamplerParameterfv(lp_sampler, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetSamplerParameterIuiv,"gl-get-sampler-parameter-iuiv",3,0,0,
(SCM sampler, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetSamplerParameterIuiv
{
GLuint lp_sampler = (GLuint)scm_to_uint32(sampler);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLuint* lp_params = (GLuint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetSamplerParameterIuiv(lp_sampler, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glQueryCounter,"gl-query-counter",2,0,0,
(SCM id, SCM target)
"ADD ME LATER")
#define FUNC_NAME s_glQueryCounter
{
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLenum lp_target = (GLenum)scm_to_uint32(target);
glQueryCounter(lp_id, lp_target);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetQueryObjecti64v,"gl-get-query-objecti-64v",3,0,0,
(SCM id, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetQueryObjecti64v
{
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint64* lp_params = (GLint64*)SCM_BYTEVECTOR_CONTENTS(params);
glGetQueryObjecti64v(lp_id, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetQueryObjectui64v,"gl-get-query-objectui-64v",3,0,0,
(SCM id, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetQueryObjectui64v
{
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLuint64* lp_params = (GLuint64*)SCM_BYTEVECTOR_CONTENTS(params);
glGetQueryObjectui64v(lp_id, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribDivisor,"gl-vertex-attrib-divisor",2,0,0,
(SCM index, SCM divisor)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribDivisor
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint lp_divisor = (GLuint)scm_to_uint32(divisor);
glVertexAttribDivisor(lp_index, lp_divisor);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribP1ui,"gl-vertex-attrib-p1ui",4,0,0,
(SCM index, SCM type, SCM normalized, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribP1ui
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLboolean lp_normalized = (GLboolean)scm_to_bool(normalized);
GLuint lp_value = (GLuint)scm_to_uint32(value);
glVertexAttribP1ui(lp_index, lp_type, lp_normalized, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribP1uiv,"gl-vertex-attrib-p1uiv",4,0,0,
(SCM index, SCM type, SCM normalized, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribP1uiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLboolean lp_normalized = (GLboolean)scm_to_bool(normalized);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glVertexAttribP1uiv(lp_index, lp_type, lp_normalized, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribP2ui,"gl-vertex-attrib-p2ui",4,0,0,
(SCM index, SCM type, SCM normalized, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribP2ui
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLboolean lp_normalized = (GLboolean)scm_to_bool(normalized);
GLuint lp_value = (GLuint)scm_to_uint32(value);
glVertexAttribP2ui(lp_index, lp_type, lp_normalized, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribP2uiv,"gl-vertex-attrib-p2uiv",4,0,0,
(SCM index, SCM type, SCM normalized, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribP2uiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLboolean lp_normalized = (GLboolean)scm_to_bool(normalized);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glVertexAttribP2uiv(lp_index, lp_type, lp_normalized, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribP3ui,"gl-vertex-attrib-p3ui",4,0,0,
(SCM index, SCM type, SCM normalized, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribP3ui
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLboolean lp_normalized = (GLboolean)scm_to_bool(normalized);
GLuint lp_value = (GLuint)scm_to_uint32(value);
glVertexAttribP3ui(lp_index, lp_type, lp_normalized, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribP3uiv,"gl-vertex-attrib-p3uiv",4,0,0,
(SCM index, SCM type, SCM normalized, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribP3uiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLboolean lp_normalized = (GLboolean)scm_to_bool(normalized);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glVertexAttribP3uiv(lp_index, lp_type, lp_normalized, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribP4ui,"gl-vertex-attrib-p4ui",4,0,0,
(SCM index, SCM type, SCM normalized, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribP4ui
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLboolean lp_normalized = (GLboolean)scm_to_bool(normalized);
GLuint lp_value = (GLuint)scm_to_uint32(value);
glVertexAttribP4ui(lp_index, lp_type, lp_normalized, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribP4uiv,"gl-vertex-attrib-p4uiv",4,0,0,
(SCM index, SCM type, SCM normalized, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribP4uiv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLboolean lp_normalized = (GLboolean)scm_to_bool(normalized);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glVertexAttribP4uiv(lp_index, lp_type, lp_normalized, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glMinSampleShading,"gl-min-sample-shading",1,0,0,
(SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glMinSampleShading
{
GLfloat lp_value = (GLfloat)scm_to_double(value);
glMinSampleShading(lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBlendEquationi,"gl-blend-equationi",2,0,0,
(SCM buf, SCM mode)
"ADD ME LATER")
#define FUNC_NAME s_glBlendEquationi
{
GLuint lp_buf = (GLuint)scm_to_uint32(buf);
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
glBlendEquationi(lp_buf, lp_mode);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBlendEquationSeparatei,"gl-blend-equation-separatei",3,0,0,
(SCM buf, SCM modeRGB, SCM modeAlpha)
"ADD ME LATER")
#define FUNC_NAME s_glBlendEquationSeparatei
{
GLuint lp_buf = (GLuint)scm_to_uint32(buf);
GLenum lp_modeRGB = (GLenum)scm_to_uint32(modeRGB);
GLenum lp_modeAlpha = (GLenum)scm_to_uint32(modeAlpha);
glBlendEquationSeparatei(lp_buf, lp_modeRGB, lp_modeAlpha);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBlendFunci,"gl-blend-funci",3,0,0,
(SCM buf, SCM src, SCM dst)
"ADD ME LATER")
#define FUNC_NAME s_glBlendFunci
{
GLuint lp_buf = (GLuint)scm_to_uint32(buf);
GLenum lp_src = (GLenum)scm_to_uint32(src);
GLenum lp_dst = (GLenum)scm_to_uint32(dst);
glBlendFunci(lp_buf, lp_src, lp_dst);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBlendFuncSeparatei,"gl-blend-func-separatei",5,0,0,
(SCM buf, SCM srcRGB, SCM dstRGB, SCM srcAlpha, SCM dstAlpha)
"ADD ME LATER")
#define FUNC_NAME s_glBlendFuncSeparatei
{
GLuint lp_buf = (GLuint)scm_to_uint32(buf);
GLenum lp_srcRGB = (GLenum)scm_to_uint32(srcRGB);
GLenum lp_dstRGB = (GLenum)scm_to_uint32(dstRGB);
GLenum lp_srcAlpha = (GLenum)scm_to_uint32(srcAlpha);
GLenum lp_dstAlpha = (GLenum)scm_to_uint32(dstAlpha);
glBlendFuncSeparatei(lp_buf, lp_srcRGB, lp_dstRGB, lp_srcAlpha, lp_dstAlpha);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawArraysIndirect,"gl-draw-arrays-indirect",2,0,0,
(SCM mode, SCM indirect)
"ADD ME LATER")
#define FUNC_NAME s_glDrawArraysIndirect
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLvoid* lp_indirect = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indirect);
glDrawArraysIndirect(lp_mode, lp_indirect);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawElementsIndirect,"gl-draw-elements-indirect",3,0,0,
(SCM mode, SCM type, SCM indirect)
"ADD ME LATER")
#define FUNC_NAME s_glDrawElementsIndirect
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_indirect = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indirect);
glDrawElementsIndirect(lp_mode, lp_type, lp_indirect);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform1d,"gl-uniform-1d",2,0,0,
(SCM location, SCM x)
"ADD ME LATER")
#define FUNC_NAME s_glUniform1d
{
GLint lp_location = (GLint)scm_to_int32(location);
GLdouble lp_x = (GLdouble)scm_to_double(x);
glUniform1d(lp_location, lp_x);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform2d,"gl-uniform-2d",3,0,0,
(SCM location, SCM x, SCM y)
"ADD ME LATER")
#define FUNC_NAME s_glUniform2d
{
GLint lp_location = (GLint)scm_to_int32(location);
GLdouble lp_x = (GLdouble)scm_to_double(x);
GLdouble lp_y = (GLdouble)scm_to_double(y);
glUniform2d(lp_location, lp_x, lp_y);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform3d,"gl-uniform-3d",4,0,0,
(SCM location, SCM x, SCM y, SCM z)
"ADD ME LATER")
#define FUNC_NAME s_glUniform3d
{
GLint lp_location = (GLint)scm_to_int32(location);
GLdouble lp_x = (GLdouble)scm_to_double(x);
GLdouble lp_y = (GLdouble)scm_to_double(y);
GLdouble lp_z = (GLdouble)scm_to_double(z);
glUniform3d(lp_location, lp_x, lp_y, lp_z);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform4d,"gl-uniform-4d",5,0,0,
(SCM location, SCM x, SCM y, SCM z, SCM w)
"ADD ME LATER")
#define FUNC_NAME s_glUniform4d
{
GLint lp_location = (GLint)scm_to_int32(location);
GLdouble lp_x = (GLdouble)scm_to_double(x);
GLdouble lp_y = (GLdouble)scm_to_double(y);
GLdouble lp_z = (GLdouble)scm_to_double(z);
GLdouble lp_w = (GLdouble)scm_to_double(w);
glUniform4d(lp_location, lp_x, lp_y, lp_z, lp_w);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform1dv,"gl-uniform-1dv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform1dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform1dv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform2dv,"gl-uniform-2dv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform2dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform2dv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform3dv,"gl-uniform-3dv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform3dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform3dv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniform4dv,"gl-uniform-4dv",3,0,0,
(SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniform4dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniform4dv(lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix2dv,"gl-uniform-matrix-2dv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix2dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix2dv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix3dv,"gl-uniform-matrix-3dv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix3dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix3dv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix4dv,"gl-uniform-matrix-4dv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix4dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix4dv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix2x3dv,"gl-uniform-matrix-2x-3dv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix2x3dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix2x3dv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix2x4dv,"gl-uniform-matrix-2x-4dv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix2x4dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix2x4dv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix3x2dv,"gl-uniform-matrix-3x-2dv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix3x2dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix3x2dv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix3x4dv,"gl-uniform-matrix-3x-4dv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix3x4dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix3x4dv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix4x2dv,"gl-uniform-matrix-4x-2dv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix4x2dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix4x2dv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformMatrix4x3dv,"gl-uniform-matrix-4x-3dv",4,0,0,
(SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glUniformMatrix4x3dv
{
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glUniformMatrix4x3dv(lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetUniformdv,"gl-get-uniformdv",3,0,0,
(SCM program, SCM location, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetUniformdv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLdouble* lp_params = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(params);
glGetUniformdv(lp_program, lp_location, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetSubroutineUniformLocation,"gl-get-subroutine-uniform-location",3,0,0,
(SCM program, SCM shadertype, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetSubroutineUniformLocation
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_shadertype = (GLenum)scm_to_uint32(shadertype);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
GLint lp_ret;
lp_ret = glGetSubroutineUniformLocation(lp_program, lp_shadertype, lp_name);
return scm_from_int32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetSubroutineIndex,"gl-get-subroutine-index",3,0,0,
(SCM program, SCM shadertype, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetSubroutineIndex
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_shadertype = (GLenum)scm_to_uint32(shadertype);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
GLuint lp_ret;
lp_ret = glGetSubroutineIndex(lp_program, lp_shadertype, lp_name);
return scm_from_uint32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetActiveSubroutineUniformiv,"gl-get-active-subroutine-uniformiv",5,0,0,
(SCM program, SCM shadertype, SCM index, SCM pname, SCM values)
"ADD ME LATER")
#define FUNC_NAME s_glGetActiveSubroutineUniformiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_shadertype = (GLenum)scm_to_uint32(shadertype);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_values = (GLint*)SCM_BYTEVECTOR_CONTENTS(values);
glGetActiveSubroutineUniformiv(lp_program, lp_shadertype, lp_index, lp_pname, lp_values);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetActiveSubroutineUniformName,"gl-get-active-subroutine-uniform-name",6,0,0,
(SCM program, SCM shadertype, SCM index, SCM bufsize, SCM length, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetActiveSubroutineUniformName
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_shadertype = (GLenum)scm_to_uint32(shadertype);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLsizei lp_bufsize = (GLsizei)scm_to_uint32(bufsize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
glGetActiveSubroutineUniformName(lp_program, lp_shadertype, lp_index, lp_bufsize, lp_length, lp_name);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetActiveSubroutineName,"gl-get-active-subroutine-name",6,0,0,
(SCM program, SCM shadertype, SCM index, SCM bufsize, SCM length, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetActiveSubroutineName
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_shadertype = (GLenum)scm_to_uint32(shadertype);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLsizei lp_bufsize = (GLsizei)scm_to_uint32(bufsize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
glGetActiveSubroutineName(lp_program, lp_shadertype, lp_index, lp_bufsize, lp_length, lp_name);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUniformSubroutinesuiv,"gl-uniform-subroutinesuiv",3,0,0,
(SCM shadertype, SCM count, SCM indices)
"ADD ME LATER")
#define FUNC_NAME s_glUniformSubroutinesuiv
{
GLenum lp_shadertype = (GLenum)scm_to_uint32(shadertype);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_indices = (GLuint*)SCM_BYTEVECTOR_CONTENTS(indices);
glUniformSubroutinesuiv(lp_shadertype, lp_count, lp_indices);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetUniformSubroutineuiv,"gl-get-uniform-subroutineuiv",3,0,0,
(SCM shadertype, SCM location, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetUniformSubroutineuiv
{
GLenum lp_shadertype = (GLenum)scm_to_uint32(shadertype);
GLint lp_location = (GLint)scm_to_int32(location);
GLuint* lp_params = (GLuint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetUniformSubroutineuiv(lp_shadertype, lp_location, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramStageiv,"gl-get-program-stageiv",4,0,0,
(SCM program, SCM shadertype, SCM pname, SCM values)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramStageiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_shadertype = (GLenum)scm_to_uint32(shadertype);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_values = (GLint*)SCM_BYTEVECTOR_CONTENTS(values);
glGetProgramStageiv(lp_program, lp_shadertype, lp_pname, lp_values);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPatchParameteri,"gl-patch-parameteri",2,0,0,
(SCM pname, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glPatchParameteri
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint lp_value = (GLint)scm_to_int32(value);
glPatchParameteri(lp_pname, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPatchParameterfv,"gl-patch-parameterfv",2,0,0,
(SCM pname, SCM values)
"ADD ME LATER")
#define FUNC_NAME s_glPatchParameterfv
{
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLfloat* lp_values = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(values);
glPatchParameterfv(lp_pname, lp_values);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindTransformFeedback,"gl-bind-transform-feedback",2,0,0,
(SCM target, SCM id)
"ADD ME LATER")
#define FUNC_NAME s_glBindTransformFeedback
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_id = (GLuint)scm_to_uint32(id);
glBindTransformFeedback(lp_target, lp_id);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteTransformFeedbacks,"gl-delete-transform-feedbacks",2,0,0,
(SCM n, SCM ids)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteTransformFeedbacks
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_ids = (GLuint*)SCM_BYTEVECTOR_CONTENTS(ids);
glDeleteTransformFeedbacks(lp_n, lp_ids);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGenTransformFeedbacks,"gl-gen-transform-feedbacks",2,0,0,
(SCM n, SCM ids)
"ADD ME LATER")
#define FUNC_NAME s_glGenTransformFeedbacks
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_ids = (GLuint*)SCM_BYTEVECTOR_CONTENTS(ids);
glGenTransformFeedbacks(lp_n, lp_ids);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsTransformFeedback,"gl-is-transform-feedback",1,0,0,
(SCM id)
"ADD ME LATER")
#define FUNC_NAME s_glIsTransformFeedback
{
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLboolean lp_ret;
lp_ret = glIsTransformFeedback(lp_id);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPauseTransformFeedback,"gl-pause-transform-feedback",0,0,0,
(void)
"ADD ME LATER")
#define FUNC_NAME s_glPauseTransformFeedback
{
glPauseTransformFeedback();
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glResumeTransformFeedback,"gl-resume-transform-feedback",0,0,0,
(void)
"ADD ME LATER")
#define FUNC_NAME s_glResumeTransformFeedback
{
glResumeTransformFeedback();
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawTransformFeedback,"gl-draw-transform-feedback",2,0,0,
(SCM mode, SCM id)
"ADD ME LATER")
#define FUNC_NAME s_glDrawTransformFeedback
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLuint lp_id = (GLuint)scm_to_uint32(id);
glDrawTransformFeedback(lp_mode, lp_id);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawTransformFeedbackStream,"gl-draw-transform-feedback-stream",3,0,0,
(SCM mode, SCM id, SCM stream)
"ADD ME LATER")
#define FUNC_NAME s_glDrawTransformFeedbackStream
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLuint lp_stream = (GLuint)scm_to_uint32(stream);
glDrawTransformFeedbackStream(lp_mode, lp_id, lp_stream);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBeginQueryIndexed,"gl-begin-query-indexed",3,0,0,
(SCM target, SCM index, SCM id)
"ADD ME LATER")
#define FUNC_NAME s_glBeginQueryIndexed
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLuint lp_id = (GLuint)scm_to_uint32(id);
glBeginQueryIndexed(lp_target, lp_index, lp_id);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glEndQueryIndexed,"gl-end-query-indexed",2,0,0,
(SCM target, SCM index)
"ADD ME LATER")
#define FUNC_NAME s_glEndQueryIndexed
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
glEndQueryIndexed(lp_target, lp_index);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetQueryIndexediv,"gl-get-query-indexediv",4,0,0,
(SCM target, SCM index, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetQueryIndexediv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetQueryIndexediv(lp_target, lp_index, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glReleaseShaderCompiler,"gl-release-shader-compiler",0,0,0,
(void)
"ADD ME LATER")
#define FUNC_NAME s_glReleaseShaderCompiler
{
glReleaseShaderCompiler();
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glShaderBinary,"gl-shader-binary",5,0,0,
(SCM count, SCM shaders, SCM binaryformat, SCM binary, SCM length)
"ADD ME LATER")
#define FUNC_NAME s_glShaderBinary
{
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_shaders = (GLuint*)SCM_BYTEVECTOR_CONTENTS(shaders);
GLenum lp_binaryformat = (GLenum)scm_to_uint32(binaryformat);
GLvoid* lp_binary = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(binary);
GLsizei lp_length = (GLsizei)scm_to_uint32(length);
glShaderBinary(lp_count, lp_shaders, lp_binaryformat, lp_binary, lp_length);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetShaderPrecisionFormat,"gl-get-shader-precision-format",4,0,0,
(SCM shadertype, SCM precisiontype, SCM range, SCM precision)
"ADD ME LATER")
#define FUNC_NAME s_glGetShaderPrecisionFormat
{
GLenum lp_shadertype = (GLenum)scm_to_uint32(shadertype);
GLenum lp_precisiontype = (GLenum)scm_to_uint32(precisiontype);
GLint* lp_range = (GLint*)SCM_BYTEVECTOR_CONTENTS(range);
GLint* lp_precision = (GLint*)SCM_BYTEVECTOR_CONTENTS(precision);
glGetShaderPrecisionFormat(lp_shadertype, lp_precisiontype, lp_range, lp_precision);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDepthRangef,"gl-depth-rangef",2,0,0,
(SCM n, SCM f)
"ADD ME LATER")
#define FUNC_NAME s_glDepthRangef
{
GLfloat lp_n = (GLfloat)scm_to_double(n);
GLfloat lp_f = (GLfloat)scm_to_double(f);
glDepthRangef(lp_n, lp_f);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearDepthf,"gl-clear-depthf",1,0,0,
(SCM d)
"ADD ME LATER")
#define FUNC_NAME s_glClearDepthf
{
GLfloat lp_d = (GLfloat)scm_to_double(d);
glClearDepthf(lp_d);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramBinary,"gl-get-program-binary",5,0,0,
(SCM program, SCM bufSize, SCM length, SCM binaryFormat, SCM binary)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramBinary
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLenum* lp_binaryFormat = (GLenum*)SCM_BYTEVECTOR_CONTENTS(binaryFormat);
GLvoid* lp_binary = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(binary);
glGetProgramBinary(lp_program, lp_bufSize, lp_length, lp_binaryFormat, lp_binary);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramBinary,"gl-program-binary",4,0,0,
(SCM program, SCM binaryFormat, SCM binary, SCM length)
"ADD ME LATER")
#define FUNC_NAME s_glProgramBinary
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_binaryFormat = (GLenum)scm_to_uint32(binaryFormat);
GLvoid* lp_binary = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(binary);
GLsizei lp_length = (GLsizei)scm_to_uint32(length);
glProgramBinary(lp_program, lp_binaryFormat, lp_binary, lp_length);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramParameteri,"gl-program-parameteri",3,0,0,
(SCM program, SCM pname, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramParameteri
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint lp_value = (GLint)scm_to_int32(value);
glProgramParameteri(lp_program, lp_pname, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glUseProgramStages,"gl-use-program-stages",3,0,0,
(SCM pipeline, SCM stages, SCM program)
"ADD ME LATER")
#define FUNC_NAME s_glUseProgramStages
{
GLuint lp_pipeline = (GLuint)scm_to_uint32(pipeline);
GLbitfield lp_stages = (GLbitfield)scm_to_uint32(stages);
GLuint lp_program = (GLuint)scm_to_uint32(program);
glUseProgramStages(lp_pipeline, lp_stages, lp_program);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glActiveShaderProgram,"gl-active-shader-program",2,0,0,
(SCM pipeline, SCM program)
"ADD ME LATER")
#define FUNC_NAME s_glActiveShaderProgram
{
GLuint lp_pipeline = (GLuint)scm_to_uint32(pipeline);
GLuint lp_program = (GLuint)scm_to_uint32(program);
glActiveShaderProgram(lp_pipeline, lp_program);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindProgramPipeline,"gl-bind-program-pipeline",1,0,0,
(SCM pipeline)
"ADD ME LATER")
#define FUNC_NAME s_glBindProgramPipeline
{
GLuint lp_pipeline = (GLuint)scm_to_uint32(pipeline);
glBindProgramPipeline(lp_pipeline);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDeleteProgramPipelines,"gl-delete-program-pipelines",2,0,0,
(SCM n, SCM pipelines)
"ADD ME LATER")
#define FUNC_NAME s_glDeleteProgramPipelines
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_pipelines = (GLuint*)SCM_BYTEVECTOR_CONTENTS(pipelines);
glDeleteProgramPipelines(lp_n, lp_pipelines);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGenProgramPipelines,"gl-gen-program-pipelines",2,0,0,
(SCM n, SCM pipelines)
"ADD ME LATER")
#define FUNC_NAME s_glGenProgramPipelines
{
GLsizei lp_n = (GLsizei)scm_to_uint32(n);
GLuint* lp_pipelines = (GLuint*)SCM_BYTEVECTOR_CONTENTS(pipelines);
glGenProgramPipelines(lp_n, lp_pipelines);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glIsProgramPipeline,"gl-is-program-pipeline",1,0,0,
(SCM pipeline)
"ADD ME LATER")
#define FUNC_NAME s_glIsProgramPipeline
{
GLuint lp_pipeline = (GLuint)scm_to_uint32(pipeline);
GLboolean lp_ret;
lp_ret = glIsProgramPipeline(lp_pipeline);
return scm_from_bool(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramPipelineiv,"gl-get-program-pipelineiv",3,0,0,
(SCM pipeline, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramPipelineiv
{
GLuint lp_pipeline = (GLuint)scm_to_uint32(pipeline);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetProgramPipelineiv(lp_pipeline, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform1i,"gl-program-uniform-1i",3,0,0,
(SCM program, SCM location, SCM v0)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform1i
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLint lp_v0 = (GLint)scm_to_int32(v0);
glProgramUniform1i(lp_program, lp_location, lp_v0);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform1iv,"gl-program-uniform-1iv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform1iv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLint* lp_value = (GLint*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform1iv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform1f,"gl-program-uniform-1f",3,0,0,
(SCM program, SCM location, SCM v0)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform1f
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLfloat lp_v0 = (GLfloat)scm_to_double(v0);
glProgramUniform1f(lp_program, lp_location, lp_v0);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform1fv,"gl-program-uniform-1fv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform1fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform1fv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform1d,"gl-program-uniform-1d",3,0,0,
(SCM program, SCM location, SCM v0)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform1d
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLdouble lp_v0 = (GLdouble)scm_to_double(v0);
glProgramUniform1d(lp_program, lp_location, lp_v0);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform1dv,"gl-program-uniform-1dv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform1dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform1dv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform1ui,"gl-program-uniform-1ui",3,0,0,
(SCM program, SCM location, SCM v0)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform1ui
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLuint lp_v0 = (GLuint)scm_to_uint32(v0);
glProgramUniform1ui(lp_program, lp_location, lp_v0);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform1uiv,"gl-program-uniform-1uiv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform1uiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform1uiv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform2i,"gl-program-uniform-2i",4,0,0,
(SCM program, SCM location, SCM v0, SCM v1)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform2i
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLint lp_v0 = (GLint)scm_to_int32(v0);
GLint lp_v1 = (GLint)scm_to_int32(v1);
glProgramUniform2i(lp_program, lp_location, lp_v0, lp_v1);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform2iv,"gl-program-uniform-2iv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform2iv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLint* lp_value = (GLint*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform2iv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform2f,"gl-program-uniform-2f",4,0,0,
(SCM program, SCM location, SCM v0, SCM v1)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform2f
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLfloat lp_v0 = (GLfloat)scm_to_double(v0);
GLfloat lp_v1 = (GLfloat)scm_to_double(v1);
glProgramUniform2f(lp_program, lp_location, lp_v0, lp_v1);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform2fv,"gl-program-uniform-2fv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform2fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform2fv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform2d,"gl-program-uniform-2d",4,0,0,
(SCM program, SCM location, SCM v0, SCM v1)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform2d
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLdouble lp_v0 = (GLdouble)scm_to_double(v0);
GLdouble lp_v1 = (GLdouble)scm_to_double(v1);
glProgramUniform2d(lp_program, lp_location, lp_v0, lp_v1);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform2dv,"gl-program-uniform-2dv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform2dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform2dv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform2ui,"gl-program-uniform-2ui",4,0,0,
(SCM program, SCM location, SCM v0, SCM v1)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform2ui
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLuint lp_v0 = (GLuint)scm_to_uint32(v0);
GLuint lp_v1 = (GLuint)scm_to_uint32(v1);
glProgramUniform2ui(lp_program, lp_location, lp_v0, lp_v1);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform2uiv,"gl-program-uniform-2uiv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform2uiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform2uiv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform3i,"gl-program-uniform-3i",5,0,0,
(SCM program, SCM location, SCM v0, SCM v1, SCM v2)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform3i
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLint lp_v0 = (GLint)scm_to_int32(v0);
GLint lp_v1 = (GLint)scm_to_int32(v1);
GLint lp_v2 = (GLint)scm_to_int32(v2);
glProgramUniform3i(lp_program, lp_location, lp_v0, lp_v1, lp_v2);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform3iv,"gl-program-uniform-3iv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform3iv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLint* lp_value = (GLint*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform3iv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform3f,"gl-program-uniform-3f",5,0,0,
(SCM program, SCM location, SCM v0, SCM v1, SCM v2)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform3f
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLfloat lp_v0 = (GLfloat)scm_to_double(v0);
GLfloat lp_v1 = (GLfloat)scm_to_double(v1);
GLfloat lp_v2 = (GLfloat)scm_to_double(v2);
glProgramUniform3f(lp_program, lp_location, lp_v0, lp_v1, lp_v2);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform3fv,"gl-program-uniform-3fv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform3fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform3fv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform3d,"gl-program-uniform-3d",5,0,0,
(SCM program, SCM location, SCM v0, SCM v1, SCM v2)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform3d
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLdouble lp_v0 = (GLdouble)scm_to_double(v0);
GLdouble lp_v1 = (GLdouble)scm_to_double(v1);
GLdouble lp_v2 = (GLdouble)scm_to_double(v2);
glProgramUniform3d(lp_program, lp_location, lp_v0, lp_v1, lp_v2);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform3dv,"gl-program-uniform-3dv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform3dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform3dv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform3ui,"gl-program-uniform-3ui",5,0,0,
(SCM program, SCM location, SCM v0, SCM v1, SCM v2)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform3ui
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLuint lp_v0 = (GLuint)scm_to_uint32(v0);
GLuint lp_v1 = (GLuint)scm_to_uint32(v1);
GLuint lp_v2 = (GLuint)scm_to_uint32(v2);
glProgramUniform3ui(lp_program, lp_location, lp_v0, lp_v1, lp_v2);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform3uiv,"gl-program-uniform-3uiv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform3uiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform3uiv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform4i,"gl-program-uniform-4i",6,0,0,
(SCM program, SCM location, SCM v0, SCM v1, SCM v2, SCM v3)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform4i
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLint lp_v0 = (GLint)scm_to_int32(v0);
GLint lp_v1 = (GLint)scm_to_int32(v1);
GLint lp_v2 = (GLint)scm_to_int32(v2);
GLint lp_v3 = (GLint)scm_to_int32(v3);
glProgramUniform4i(lp_program, lp_location, lp_v0, lp_v1, lp_v2, lp_v3);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform4iv,"gl-program-uniform-4iv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform4iv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLint* lp_value = (GLint*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform4iv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform4f,"gl-program-uniform-4f",6,0,0,
(SCM program, SCM location, SCM v0, SCM v1, SCM v2, SCM v3)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform4f
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLfloat lp_v0 = (GLfloat)scm_to_double(v0);
GLfloat lp_v1 = (GLfloat)scm_to_double(v1);
GLfloat lp_v2 = (GLfloat)scm_to_double(v2);
GLfloat lp_v3 = (GLfloat)scm_to_double(v3);
glProgramUniform4f(lp_program, lp_location, lp_v0, lp_v1, lp_v2, lp_v3);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform4fv,"gl-program-uniform-4fv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform4fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform4fv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform4d,"gl-program-uniform-4d",6,0,0,
(SCM program, SCM location, SCM v0, SCM v1, SCM v2, SCM v3)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform4d
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLdouble lp_v0 = (GLdouble)scm_to_double(v0);
GLdouble lp_v1 = (GLdouble)scm_to_double(v1);
GLdouble lp_v2 = (GLdouble)scm_to_double(v2);
GLdouble lp_v3 = (GLdouble)scm_to_double(v3);
glProgramUniform4d(lp_program, lp_location, lp_v0, lp_v1, lp_v2, lp_v3);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform4dv,"gl-program-uniform-4dv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform4dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform4dv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform4ui,"gl-program-uniform-4ui",6,0,0,
(SCM program, SCM location, SCM v0, SCM v1, SCM v2, SCM v3)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform4ui
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLuint lp_v0 = (GLuint)scm_to_uint32(v0);
GLuint lp_v1 = (GLuint)scm_to_uint32(v1);
GLuint lp_v2 = (GLuint)scm_to_uint32(v2);
GLuint lp_v3 = (GLuint)scm_to_uint32(v3);
glProgramUniform4ui(lp_program, lp_location, lp_v0, lp_v1, lp_v2, lp_v3);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniform4uiv,"gl-program-uniform-4uiv",4,0,0,
(SCM program, SCM location, SCM count, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniform4uiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_value = (GLuint*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniform4uiv(lp_program, lp_location, lp_count, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix2fv,"gl-program-uniform-matrix-2fv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix2fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix2fv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix3fv,"gl-program-uniform-matrix-3fv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix3fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix3fv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix4fv,"gl-program-uniform-matrix-4fv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix4fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix4fv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix2dv,"gl-program-uniform-matrix-2dv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix2dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix2dv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix3dv,"gl-program-uniform-matrix-3dv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix3dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix3dv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix4dv,"gl-program-uniform-matrix-4dv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix4dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix4dv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix2x3fv,"gl-program-uniform-matrix-2x-3fv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix2x3fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix2x3fv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix3x2fv,"gl-program-uniform-matrix-3x-2fv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix3x2fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix3x2fv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix2x4fv,"gl-program-uniform-matrix-2x-4fv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix2x4fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix2x4fv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix4x2fv,"gl-program-uniform-matrix-4x-2fv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix4x2fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix4x2fv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix3x4fv,"gl-program-uniform-matrix-3x-4fv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix3x4fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix3x4fv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix4x3fv,"gl-program-uniform-matrix-4x-3fv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix4x3fv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLfloat* lp_value = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix4x3fv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix2x3dv,"gl-program-uniform-matrix-2x-3dv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix2x3dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix2x3dv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix3x2dv,"gl-program-uniform-matrix-3x-2dv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix3x2dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix3x2dv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix2x4dv,"gl-program-uniform-matrix-2x-4dv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix2x4dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix2x4dv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix4x2dv,"gl-program-uniform-matrix-4x-2dv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix4x2dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix4x2dv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix3x4dv,"gl-program-uniform-matrix-3x-4dv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix3x4dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix3x4dv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glProgramUniformMatrix4x3dv,"gl-program-uniform-matrix-4x-3dv",5,0,0,
(SCM program, SCM location, SCM count, SCM transpose, SCM value)
"ADD ME LATER")
#define FUNC_NAME s_glProgramUniformMatrix4x3dv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLint lp_location = (GLint)scm_to_int32(location);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLboolean lp_transpose = (GLboolean)scm_to_bool(transpose);
GLdouble* lp_value = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(value);
glProgramUniformMatrix4x3dv(lp_program, lp_location, lp_count, lp_transpose, lp_value);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glValidateProgramPipeline,"gl-validate-program-pipeline",1,0,0,
(SCM pipeline)
"ADD ME LATER")
#define FUNC_NAME s_glValidateProgramPipeline
{
GLuint lp_pipeline = (GLuint)scm_to_uint32(pipeline);
glValidateProgramPipeline(lp_pipeline);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramPipelineInfoLog,"gl-get-program-pipeline-info-log",4,0,0,
(SCM pipeline, SCM bufSize, SCM length, SCM infoLog)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramPipelineInfoLog
{
GLuint lp_pipeline = (GLuint)scm_to_uint32(pipeline);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_infoLog = (GLchar*)SCM_BYTEVECTOR_CONTENTS(infoLog);
glGetProgramPipelineInfoLog(lp_pipeline, lp_bufSize, lp_length, lp_infoLog);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribL1d,"gl-vertex-attrib-l1d",2,0,0,
(SCM index, SCM x)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribL1d
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble lp_x = (GLdouble)scm_to_double(x);
glVertexAttribL1d(lp_index, lp_x);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribL2d,"gl-vertex-attrib-l2d",3,0,0,
(SCM index, SCM x, SCM y)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribL2d
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble lp_x = (GLdouble)scm_to_double(x);
GLdouble lp_y = (GLdouble)scm_to_double(y);
glVertexAttribL2d(lp_index, lp_x, lp_y);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribL3d,"gl-vertex-attrib-l3d",4,0,0,
(SCM index, SCM x, SCM y, SCM z)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribL3d
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble lp_x = (GLdouble)scm_to_double(x);
GLdouble lp_y = (GLdouble)scm_to_double(y);
GLdouble lp_z = (GLdouble)scm_to_double(z);
glVertexAttribL3d(lp_index, lp_x, lp_y, lp_z);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribL4d,"gl-vertex-attrib-l4d",5,0,0,
(SCM index, SCM x, SCM y, SCM z, SCM w)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribL4d
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble lp_x = (GLdouble)scm_to_double(x);
GLdouble lp_y = (GLdouble)scm_to_double(y);
GLdouble lp_z = (GLdouble)scm_to_double(z);
GLdouble lp_w = (GLdouble)scm_to_double(w);
glVertexAttribL4d(lp_index, lp_x, lp_y, lp_z, lp_w);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribL1dv,"gl-vertex-attrib-l1dv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribL1dv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble* lp_v = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribL1dv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribL2dv,"gl-vertex-attrib-l2dv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribL2dv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble* lp_v = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribL2dv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribL3dv,"gl-vertex-attrib-l3dv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribL3dv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble* lp_v = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribL3dv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribL4dv,"gl-vertex-attrib-l4dv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribL4dv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble* lp_v = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(v);
glVertexAttribL4dv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribLPointer,"gl-vertex-attrib-lPointer",5,0,0,
(SCM index, SCM size, SCM type, SCM stride, SCM pointer)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribLPointer
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint lp_size = (GLint)scm_to_int32(size);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLsizei lp_stride = (GLsizei)scm_to_uint32(stride);
GLvoid* lp_pointer = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(pointer);
glVertexAttribLPointer(lp_index, lp_size, lp_type, lp_stride, lp_pointer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetVertexAttribLdv,"gl-get-vertex-attrib-ldv",3,0,0,
(SCM index, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetVertexAttribLdv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLdouble* lp_params = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(params);
glGetVertexAttribLdv(lp_index, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glViewportArrayv,"gl-viewport-arrayv",3,0,0,
(SCM first, SCM count, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glViewportArrayv
{
GLuint lp_first = (GLuint)scm_to_uint32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLfloat* lp_v = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(v);
glViewportArrayv(lp_first, lp_count, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glViewportIndexedf,"gl-viewport-indexedf",5,0,0,
(SCM index, SCM x, SCM y, SCM w, SCM h)
"ADD ME LATER")
#define FUNC_NAME s_glViewportIndexedf
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat lp_x = (GLfloat)scm_to_double(x);
GLfloat lp_y = (GLfloat)scm_to_double(y);
GLfloat lp_w = (GLfloat)scm_to_double(w);
GLfloat lp_h = (GLfloat)scm_to_double(h);
glViewportIndexedf(lp_index, lp_x, lp_y, lp_w, lp_h);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glViewportIndexedfv,"gl-viewport-indexedfv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glViewportIndexedfv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat* lp_v = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(v);
glViewportIndexedfv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glScissorArrayv,"gl-scissor-arrayv",3,0,0,
(SCM first, SCM count, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glScissorArrayv
{
GLuint lp_first = (GLuint)scm_to_uint32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLint* lp_v = (GLint*)SCM_BYTEVECTOR_CONTENTS(v);
glScissorArrayv(lp_first, lp_count, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glScissorIndexed,"gl-scissor-indexed",5,0,0,
(SCM index, SCM left, SCM bottom, SCM width, SCM height)
"ADD ME LATER")
#define FUNC_NAME s_glScissorIndexed
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint lp_left = (GLint)scm_to_int32(left);
GLint lp_bottom = (GLint)scm_to_int32(bottom);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
glScissorIndexed(lp_index, lp_left, lp_bottom, lp_width, lp_height);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glScissorIndexedv,"gl-scissor-indexedv",2,0,0,
(SCM index, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glScissorIndexedv
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLint* lp_v = (GLint*)SCM_BYTEVECTOR_CONTENTS(v);
glScissorIndexedv(lp_index, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDepthRangeArrayv,"gl-depth-range-arrayv",3,0,0,
(SCM first, SCM count, SCM v)
"ADD ME LATER")
#define FUNC_NAME s_glDepthRangeArrayv
{
GLuint lp_first = (GLuint)scm_to_uint32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLdouble* lp_v = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(v);
glDepthRangeArrayv(lp_first, lp_count, lp_v);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDepthRangeIndexed,"gl-depth-range-indexed",3,0,0,
(SCM index, SCM n, SCM f)
"ADD ME LATER")
#define FUNC_NAME s_glDepthRangeIndexed
{
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble lp_n = (GLdouble)scm_to_double(n);
GLdouble lp_f = (GLdouble)scm_to_double(f);
glDepthRangeIndexed(lp_index, lp_n, lp_f);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetFloati_v,"gl-get-floati-_v",3,0,0,
(SCM target, SCM index, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetFloati_v
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLfloat* lp_data = (GLfloat*)SCM_BYTEVECTOR_CONTENTS(data);
glGetFloati_v(lp_target, lp_index, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetDoublei_v,"gl-get-doublei-_v",3,0,0,
(SCM target, SCM index, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glGetDoublei_v
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLdouble* lp_data = (GLdouble*)SCM_BYTEVECTOR_CONTENTS(data);
glGetDoublei_v(lp_target, lp_index, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawArraysInstancedBaseInstance,"gl-draw-arrays-instanced-base-instance",5,0,0,
(SCM mode, SCM first, SCM count, SCM instancecount, SCM baseinstance)
"ADD ME LATER")
#define FUNC_NAME s_glDrawArraysInstancedBaseInstance
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLint lp_first = (GLint)scm_to_int32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLsizei lp_instancecount = (GLsizei)scm_to_uint32(instancecount);
GLuint lp_baseinstance = (GLuint)scm_to_uint32(baseinstance);
glDrawArraysInstancedBaseInstance(lp_mode, lp_first, lp_count, lp_instancecount, lp_baseinstance);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawElementsInstancedBaseInstance,"gl-draw-elements-instanced-base-instance",6,0,0,
(SCM mode, SCM count, SCM type, SCM indices, SCM instancecount, SCM baseinstance)
"ADD ME LATER")
#define FUNC_NAME s_glDrawElementsInstancedBaseInstance
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_indices = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indices);
GLsizei lp_instancecount = (GLsizei)scm_to_uint32(instancecount);
GLuint lp_baseinstance = (GLuint)scm_to_uint32(baseinstance);
glDrawElementsInstancedBaseInstance(lp_mode, lp_count, lp_type, lp_indices, lp_instancecount, lp_baseinstance);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawElementsInstancedBaseVertexBaseInstance,"gl-draw-elements-instanced-base-vertex-base-instance",7,0,0,
(SCM mode, SCM count, SCM type, SCM indices, SCM instancecount, SCM basevertex, SCM baseinstance)
"ADD ME LATER")
#define FUNC_NAME s_glDrawElementsInstancedBaseVertexBaseInstance
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_indices = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indices);
GLsizei lp_instancecount = (GLsizei)scm_to_uint32(instancecount);
GLint lp_basevertex = (GLint)scm_to_int32(basevertex);
GLuint lp_baseinstance = (GLuint)scm_to_uint32(baseinstance);
glDrawElementsInstancedBaseVertexBaseInstance(lp_mode, lp_count, lp_type, lp_indices, lp_instancecount, lp_basevertex, lp_baseinstance);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetInternalformativ,"gl-get-internalformativ",5,0,0,
(SCM target, SCM internalformat, SCM pname, SCM bufSize, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetInternalformativ
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetInternalformativ(lp_target, lp_internalformat, lp_pname, lp_bufSize, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetActiveAtomicCounterBufferiv,"gl-get-active-atomic-counter-bufferiv",4,0,0,
(SCM program, SCM bufferIndex, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetActiveAtomicCounterBufferiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_bufferIndex = (GLuint)scm_to_uint32(bufferIndex);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetActiveAtomicCounterBufferiv(lp_program, lp_bufferIndex, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindImageTexture,"gl-bind-image-texture",7,0,0,
(SCM unit, SCM texture, SCM level, SCM layered, SCM layer, SCM access, SCM format)
"ADD ME LATER")
#define FUNC_NAME s_glBindImageTexture
{
GLuint lp_unit = (GLuint)scm_to_uint32(unit);
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLint lp_level = (GLint)scm_to_int32(level);
GLboolean lp_layered = (GLboolean)scm_to_bool(layered);
GLint lp_layer = (GLint)scm_to_int32(layer);
GLenum lp_access = (GLenum)scm_to_uint32(access);
GLenum lp_format = (GLenum)scm_to_uint32(format);
glBindImageTexture(lp_unit, lp_texture, lp_level, lp_layered, lp_layer, lp_access, lp_format);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glMemoryBarrier,"gl-memory-barrier",1,0,0,
(SCM barriers)
"ADD ME LATER")
#define FUNC_NAME s_glMemoryBarrier
{
GLbitfield lp_barriers = (GLbitfield)scm_to_uint32(barriers);
glMemoryBarrier(lp_barriers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexStorage1D,"gl-tex-storage-1D",4,0,0,
(SCM target, SCM levels, SCM internalformat, SCM width)
"ADD ME LATER")
#define FUNC_NAME s_glTexStorage1D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizei lp_levels = (GLsizei)scm_to_uint32(levels);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
glTexStorage1D(lp_target, lp_levels, lp_internalformat, lp_width);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexStorage2D,"gl-tex-storage-2D",5,0,0,
(SCM target, SCM levels, SCM internalformat, SCM width, SCM height)
"ADD ME LATER")
#define FUNC_NAME s_glTexStorage2D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizei lp_levels = (GLsizei)scm_to_uint32(levels);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
glTexStorage2D(lp_target, lp_levels, lp_internalformat, lp_width, lp_height);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexStorage3D,"gl-tex-storage-3D",6,0,0,
(SCM target, SCM levels, SCM internalformat, SCM width, SCM height, SCM depth)
"ADD ME LATER")
#define FUNC_NAME s_glTexStorage3D
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizei lp_levels = (GLsizei)scm_to_uint32(levels);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLsizei lp_depth = (GLsizei)scm_to_uint32(depth);
glTexStorage3D(lp_target, lp_levels, lp_internalformat, lp_width, lp_height, lp_depth);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawTransformFeedbackInstanced,"gl-draw-transform-feedback-instanced",3,0,0,
(SCM mode, SCM id, SCM instancecount)
"ADD ME LATER")
#define FUNC_NAME s_glDrawTransformFeedbackInstanced
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLsizei lp_instancecount = (GLsizei)scm_to_uint32(instancecount);
glDrawTransformFeedbackInstanced(lp_mode, lp_id, lp_instancecount);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDrawTransformFeedbackStreamInstanced,"gl-draw-transform-feedback-stream-instanced",4,0,0,
(SCM mode, SCM id, SCM stream, SCM instancecount)
"ADD ME LATER")
#define FUNC_NAME s_glDrawTransformFeedbackStreamInstanced
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLuint lp_stream = (GLuint)scm_to_uint32(stream);
GLsizei lp_instancecount = (GLsizei)scm_to_uint32(instancecount);
glDrawTransformFeedbackStreamInstanced(lp_mode, lp_id, lp_stream, lp_instancecount);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearBufferData,"gl-clear-buffer-data",5,0,0,
(SCM target, SCM internalformat, SCM format, SCM type, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glClearBufferData
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glClearBufferData(lp_target, lp_internalformat, lp_format, lp_type, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearBufferSubData,"gl-clear-buffer-sub-data",7,0,0,
(SCM target, SCM internalformat, SCM offset, SCM size, SCM format, SCM type, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glClearBufferSubData
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLintptr lp_offset = (GLintptr)scm_to_uint32(offset);
GLsizeiptr lp_size = (GLsizeiptr)scm_to_uint32(size);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glClearBufferSubData(lp_target, lp_internalformat, lp_offset, lp_size, lp_format, lp_type, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDispatchCompute,"gl-dispatch-compute",3,0,0,
(SCM num_groups_x, SCM num_groups_y, SCM num_groups_z)
"ADD ME LATER")
#define FUNC_NAME s_glDispatchCompute
{
GLuint lp_num_groups_x = (GLuint)scm_to_uint32(num_groups_x);
GLuint lp_num_groups_y = (GLuint)scm_to_uint32(num_groups_y);
GLuint lp_num_groups_z = (GLuint)scm_to_uint32(num_groups_z);
glDispatchCompute(lp_num_groups_x, lp_num_groups_y, lp_num_groups_z);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDispatchComputeIndirect,"gl-dispatch-compute-indirect",1,0,0,
(SCM indirect)
"ADD ME LATER")
#define FUNC_NAME s_glDispatchComputeIndirect
{
GLintptr lp_indirect = (GLintptr)scm_to_uint32(indirect);
glDispatchComputeIndirect(lp_indirect);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glCopyImageSubData,"gl-copy-image-sub-data",15,0,0,
(SCM srcName, SCM srcTarget, SCM srcLevel, SCM srcX, SCM srcY, SCM srcZ, SCM dstName, SCM dstTarget, SCM dstLevel, SCM dstX, SCM dstY, SCM dstZ, SCM srcWidth, SCM srcHeight, SCM srcDepth)
"ADD ME LATER")
#define FUNC_NAME s_glCopyImageSubData
{
GLuint lp_srcName = (GLuint)scm_to_uint32(srcName);
GLenum lp_srcTarget = (GLenum)scm_to_uint32(srcTarget);
GLint lp_srcLevel = (GLint)scm_to_int32(srcLevel);
GLint lp_srcX = (GLint)scm_to_int32(srcX);
GLint lp_srcY = (GLint)scm_to_int32(srcY);
GLint lp_srcZ = (GLint)scm_to_int32(srcZ);
GLuint lp_dstName = (GLuint)scm_to_uint32(dstName);
GLenum lp_dstTarget = (GLenum)scm_to_uint32(dstTarget);
GLint lp_dstLevel = (GLint)scm_to_int32(dstLevel);
GLint lp_dstX = (GLint)scm_to_int32(dstX);
GLint lp_dstY = (GLint)scm_to_int32(dstY);
GLint lp_dstZ = (GLint)scm_to_int32(dstZ);
GLsizei lp_srcWidth = (GLsizei)scm_to_uint32(srcWidth);
GLsizei lp_srcHeight = (GLsizei)scm_to_uint32(srcHeight);
GLsizei lp_srcDepth = (GLsizei)scm_to_uint32(srcDepth);
glCopyImageSubData(lp_srcName, lp_srcTarget, lp_srcLevel, lp_srcX, lp_srcY, lp_srcZ, lp_dstName, lp_dstTarget, lp_dstLevel, lp_dstX, lp_dstY, lp_dstZ, lp_srcWidth, lp_srcHeight, lp_srcDepth);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glFramebufferParameteri,"gl-framebuffer-parameteri",3,0,0,
(SCM target, SCM pname, SCM param)
"ADD ME LATER")
#define FUNC_NAME s_glFramebufferParameteri
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint lp_param = (GLint)scm_to_int32(param);
glFramebufferParameteri(lp_target, lp_pname, lp_param);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetFramebufferParameteriv,"gl-get-framebuffer-parameteriv",3,0,0,
(SCM target, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetFramebufferParameteriv
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetFramebufferParameteriv(lp_target, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetInternalformati64v,"gl-get-internalformati-64v",5,0,0,
(SCM target, SCM internalformat, SCM pname, SCM bufSize, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetInternalformati64v
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLint64* lp_params = (GLint64*)SCM_BYTEVECTOR_CONTENTS(params);
glGetInternalformati64v(lp_target, lp_internalformat, lp_pname, lp_bufSize, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glInvalidateTexSubImage,"gl-invalidate-tex-sub-image",8,0,0,
(SCM texture, SCM level, SCM xoffset, SCM yoffset, SCM zoffset, SCM width, SCM height, SCM depth)
"ADD ME LATER")
#define FUNC_NAME s_glInvalidateTexSubImage
{
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLint lp_yoffset = (GLint)scm_to_int32(yoffset);
GLint lp_zoffset = (GLint)scm_to_int32(zoffset);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLsizei lp_depth = (GLsizei)scm_to_uint32(depth);
glInvalidateTexSubImage(lp_texture, lp_level, lp_xoffset, lp_yoffset, lp_zoffset, lp_width, lp_height, lp_depth);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glInvalidateTexImage,"gl-invalidate-tex-image",2,0,0,
(SCM texture, SCM level)
"ADD ME LATER")
#define FUNC_NAME s_glInvalidateTexImage
{
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLint lp_level = (GLint)scm_to_int32(level);
glInvalidateTexImage(lp_texture, lp_level);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glInvalidateBufferSubData,"gl-invalidate-buffer-sub-data",3,0,0,
(SCM buffer, SCM offset, SCM length)
"ADD ME LATER")
#define FUNC_NAME s_glInvalidateBufferSubData
{
GLuint lp_buffer = (GLuint)scm_to_uint32(buffer);
GLintptr lp_offset = (GLintptr)scm_to_uint32(offset);
GLsizeiptr lp_length = (GLsizeiptr)scm_to_uint32(length);
glInvalidateBufferSubData(lp_buffer, lp_offset, lp_length);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glInvalidateBufferData,"gl-invalidate-buffer-data",1,0,0,
(SCM buffer)
"ADD ME LATER")
#define FUNC_NAME s_glInvalidateBufferData
{
GLuint lp_buffer = (GLuint)scm_to_uint32(buffer);
glInvalidateBufferData(lp_buffer);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glInvalidateFramebuffer,"gl-invalidate-framebuffer",3,0,0,
(SCM target, SCM numAttachments, SCM attachments)
"ADD ME LATER")
#define FUNC_NAME s_glInvalidateFramebuffer
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizei lp_numAttachments = (GLsizei)scm_to_uint32(numAttachments);
GLenum* lp_attachments = (GLenum*)SCM_BYTEVECTOR_CONTENTS(attachments);
glInvalidateFramebuffer(lp_target, lp_numAttachments, lp_attachments);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glInvalidateSubFramebuffer,"gl-invalidate-sub-framebuffer",7,0,0,
(SCM target, SCM numAttachments, SCM attachments, SCM x, SCM y, SCM width, SCM height)
"ADD ME LATER")
#define FUNC_NAME s_glInvalidateSubFramebuffer
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizei lp_numAttachments = (GLsizei)scm_to_uint32(numAttachments);
GLenum* lp_attachments = (GLenum*)SCM_BYTEVECTOR_CONTENTS(attachments);
GLint lp_x = (GLint)scm_to_int32(x);
GLint lp_y = (GLint)scm_to_int32(y);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
glInvalidateSubFramebuffer(lp_target, lp_numAttachments, lp_attachments, lp_x, lp_y, lp_width, lp_height);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glMultiDrawArraysIndirect,"gl-multi-draw-arrays-indirect",4,0,0,
(SCM mode, SCM indirect, SCM drawcount, SCM stride)
"ADD ME LATER")
#define FUNC_NAME s_glMultiDrawArraysIndirect
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLvoid* lp_indirect = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indirect);
GLsizei lp_drawcount = (GLsizei)scm_to_uint32(drawcount);
GLsizei lp_stride = (GLsizei)scm_to_uint32(stride);
glMultiDrawArraysIndirect(lp_mode, lp_indirect, lp_drawcount, lp_stride);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glMultiDrawElementsIndirect,"gl-multi-draw-elements-indirect",5,0,0,
(SCM mode, SCM type, SCM indirect, SCM drawcount, SCM stride)
"ADD ME LATER")
#define FUNC_NAME s_glMultiDrawElementsIndirect
{
GLenum lp_mode = (GLenum)scm_to_uint32(mode);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_indirect = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(indirect);
GLsizei lp_drawcount = (GLsizei)scm_to_uint32(drawcount);
GLsizei lp_stride = (GLsizei)scm_to_uint32(stride);
glMultiDrawElementsIndirect(lp_mode, lp_type, lp_indirect, lp_drawcount, lp_stride);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramInterfaceiv,"gl-get-program-interfaceiv",4,0,0,
(SCM program, SCM programInterface, SCM pname, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramInterfaceiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_programInterface = (GLenum)scm_to_uint32(programInterface);
GLenum lp_pname = (GLenum)scm_to_uint32(pname);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetProgramInterfaceiv(lp_program, lp_programInterface, lp_pname, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramResourceIndex,"gl-get-program-resource-index",3,0,0,
(SCM program, SCM programInterface, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramResourceIndex
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_programInterface = (GLenum)scm_to_uint32(programInterface);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
GLuint lp_ret;
lp_ret = glGetProgramResourceIndex(lp_program, lp_programInterface, lp_name);
return scm_from_uint32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramResourceName,"gl-get-program-resource-name",6,0,0,
(SCM program, SCM programInterface, SCM index, SCM bufSize, SCM length, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramResourceName
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_programInterface = (GLenum)scm_to_uint32(programInterface);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
glGetProgramResourceName(lp_program, lp_programInterface, lp_index, lp_bufSize, lp_length, lp_name);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramResourceiv,"gl-get-program-resourceiv",8,0,0,
(SCM program, SCM programInterface, SCM index, SCM propCount, SCM props, SCM bufSize, SCM length, SCM params)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramResourceiv
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_programInterface = (GLenum)scm_to_uint32(programInterface);
GLuint lp_index = (GLuint)scm_to_uint32(index);
GLsizei lp_propCount = (GLsizei)scm_to_uint32(propCount);
GLenum* lp_props = (GLenum*)SCM_BYTEVECTOR_CONTENTS(props);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLint* lp_params = (GLint*)SCM_BYTEVECTOR_CONTENTS(params);
glGetProgramResourceiv(lp_program, lp_programInterface, lp_index, lp_propCount, lp_props, lp_bufSize, lp_length, lp_params);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramResourceLocation,"gl-get-program-resource-location",3,0,0,
(SCM program, SCM programInterface, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramResourceLocation
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_programInterface = (GLenum)scm_to_uint32(programInterface);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
GLint lp_ret;
lp_ret = glGetProgramResourceLocation(lp_program, lp_programInterface, lp_name);
return scm_from_int32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetProgramResourceLocationIndex,"gl-get-program-resource-location-index",3,0,0,
(SCM program, SCM programInterface, SCM name)
"ADD ME LATER")
#define FUNC_NAME s_glGetProgramResourceLocationIndex
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLenum lp_programInterface = (GLenum)scm_to_uint32(programInterface);
GLchar* lp_name = (GLchar*)SCM_BYTEVECTOR_CONTENTS(name);
GLint lp_ret;
lp_ret = glGetProgramResourceLocationIndex(lp_program, lp_programInterface, lp_name);
return scm_from_int32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glShaderStorageBlockBinding,"gl-shader-storage-block-binding",3,0,0,
(SCM program, SCM storageBlockIndex, SCM storageBlockBinding)
"ADD ME LATER")
#define FUNC_NAME s_glShaderStorageBlockBinding
{
GLuint lp_program = (GLuint)scm_to_uint32(program);
GLuint lp_storageBlockIndex = (GLuint)scm_to_uint32(storageBlockIndex);
GLuint lp_storageBlockBinding = (GLuint)scm_to_uint32(storageBlockBinding);
glShaderStorageBlockBinding(lp_program, lp_storageBlockIndex, lp_storageBlockBinding);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexBufferRange,"gl-tex-buffer-range",5,0,0,
(SCM target, SCM internalformat, SCM buffer, SCM offset, SCM size)
"ADD ME LATER")
#define FUNC_NAME s_glTexBufferRange
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLuint lp_buffer = (GLuint)scm_to_uint32(buffer);
GLintptr lp_offset = (GLintptr)scm_to_uint32(offset);
GLsizeiptr lp_size = (GLsizeiptr)scm_to_uint32(size);
glTexBufferRange(lp_target, lp_internalformat, lp_buffer, lp_offset, lp_size);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexStorage2DMultisample,"gl-tex-storage-2DMultisample",6,0,0,
(SCM target, SCM samples, SCM internalformat, SCM width, SCM height, SCM fixedsamplelocations)
"ADD ME LATER")
#define FUNC_NAME s_glTexStorage2DMultisample
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizei lp_samples = (GLsizei)scm_to_uint32(samples);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLboolean lp_fixedsamplelocations = (GLboolean)scm_to_bool(fixedsamplelocations);
glTexStorage2DMultisample(lp_target, lp_samples, lp_internalformat, lp_width, lp_height, lp_fixedsamplelocations);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTexStorage3DMultisample,"gl-tex-storage-3DMultisample",7,0,0,
(SCM target, SCM samples, SCM internalformat, SCM width, SCM height, SCM depth, SCM fixedsamplelocations)
"ADD ME LATER")
#define FUNC_NAME s_glTexStorage3DMultisample
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizei lp_samples = (GLsizei)scm_to_uint32(samples);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLsizei lp_depth = (GLsizei)scm_to_uint32(depth);
GLboolean lp_fixedsamplelocations = (GLboolean)scm_to_bool(fixedsamplelocations);
glTexStorage3DMultisample(lp_target, lp_samples, lp_internalformat, lp_width, lp_height, lp_depth, lp_fixedsamplelocations);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glTextureView,"gl-texture-view",8,0,0,
(SCM texture, SCM target, SCM origtexture, SCM internalformat, SCM minlevel, SCM numlevels, SCM minlayer, SCM numlayers)
"ADD ME LATER")
#define FUNC_NAME s_glTextureView
{
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_origtexture = (GLuint)scm_to_uint32(origtexture);
GLenum lp_internalformat = (GLenum)scm_to_uint32(internalformat);
GLuint lp_minlevel = (GLuint)scm_to_uint32(minlevel);
GLuint lp_numlevels = (GLuint)scm_to_uint32(numlevels);
GLuint lp_minlayer = (GLuint)scm_to_uint32(minlayer);
GLuint lp_numlayers = (GLuint)scm_to_uint32(numlayers);
glTextureView(lp_texture, lp_target, lp_origtexture, lp_internalformat, lp_minlevel, lp_numlevels, lp_minlayer, lp_numlayers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindVertexBuffer,"gl-bind-vertex-buffer",4,0,0,
(SCM bindingindex, SCM buffer, SCM offset, SCM stride)
"ADD ME LATER")
#define FUNC_NAME s_glBindVertexBuffer
{
GLuint lp_bindingindex = (GLuint)scm_to_uint32(bindingindex);
GLuint lp_buffer = (GLuint)scm_to_uint32(buffer);
GLintptr lp_offset = (GLintptr)scm_to_uint32(offset);
GLsizei lp_stride = (GLsizei)scm_to_uint32(stride);
glBindVertexBuffer(lp_bindingindex, lp_buffer, lp_offset, lp_stride);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribFormat,"gl-vertex-attrib-format",5,0,0,
(SCM attribindex, SCM size, SCM type, SCM normalized, SCM relativeoffset)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribFormat
{
GLuint lp_attribindex = (GLuint)scm_to_uint32(attribindex);
GLint lp_size = (GLint)scm_to_int32(size);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLboolean lp_normalized = (GLboolean)scm_to_bool(normalized);
GLuint lp_relativeoffset = (GLuint)scm_to_uint32(relativeoffset);
glVertexAttribFormat(lp_attribindex, lp_size, lp_type, lp_normalized, lp_relativeoffset);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribIFormat,"gl-vertex-attrib-iFormat",4,0,0,
(SCM attribindex, SCM size, SCM type, SCM relativeoffset)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribIFormat
{
GLuint lp_attribindex = (GLuint)scm_to_uint32(attribindex);
GLint lp_size = (GLint)scm_to_int32(size);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLuint lp_relativeoffset = (GLuint)scm_to_uint32(relativeoffset);
glVertexAttribIFormat(lp_attribindex, lp_size, lp_type, lp_relativeoffset);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribLFormat,"gl-vertex-attrib-lFormat",4,0,0,
(SCM attribindex, SCM size, SCM type, SCM relativeoffset)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribLFormat
{
GLuint lp_attribindex = (GLuint)scm_to_uint32(attribindex);
GLint lp_size = (GLint)scm_to_int32(size);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLuint lp_relativeoffset = (GLuint)scm_to_uint32(relativeoffset);
glVertexAttribLFormat(lp_attribindex, lp_size, lp_type, lp_relativeoffset);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexAttribBinding,"gl-vertex-attrib-binding",2,0,0,
(SCM attribindex, SCM bindingindex)
"ADD ME LATER")
#define FUNC_NAME s_glVertexAttribBinding
{
GLuint lp_attribindex = (GLuint)scm_to_uint32(attribindex);
GLuint lp_bindingindex = (GLuint)scm_to_uint32(bindingindex);
glVertexAttribBinding(lp_attribindex, lp_bindingindex);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glVertexBindingDivisor,"gl-vertex-binding-divisor",2,0,0,
(SCM bindingindex, SCM divisor)
"ADD ME LATER")
#define FUNC_NAME s_glVertexBindingDivisor
{
GLuint lp_bindingindex = (GLuint)scm_to_uint32(bindingindex);
GLuint lp_divisor = (GLuint)scm_to_uint32(divisor);
glVertexBindingDivisor(lp_bindingindex, lp_divisor);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDebugMessageControl,"gl-debug-message-control",6,0,0,
(SCM source, SCM type, SCM severity, SCM count, SCM ids, SCM enabled)
"ADD ME LATER")
#define FUNC_NAME s_glDebugMessageControl
{
GLenum lp_source = (GLenum)scm_to_uint32(source);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLenum lp_severity = (GLenum)scm_to_uint32(severity);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_ids = (GLuint*)SCM_BYTEVECTOR_CONTENTS(ids);
GLboolean lp_enabled = (GLboolean)scm_to_bool(enabled);
glDebugMessageControl(lp_source, lp_type, lp_severity, lp_count, lp_ids, lp_enabled);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glDebugMessageInsert,"gl-debug-message-insert",6,0,0,
(SCM source, SCM type, SCM id, SCM severity, SCM length, SCM buf)
"ADD ME LATER")
#define FUNC_NAME s_glDebugMessageInsert
{
GLenum lp_source = (GLenum)scm_to_uint32(source);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLenum lp_severity = (GLenum)scm_to_uint32(severity);
GLsizei lp_length = (GLsizei)scm_to_uint32(length);
GLchar* lp_buf = (GLchar*)SCM_BYTEVECTOR_CONTENTS(buf);
glDebugMessageInsert(lp_source, lp_type, lp_id, lp_severity, lp_length, lp_buf);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetDebugMessageLog,"gl-get-debug-message-log",8,0,0,
(SCM count, SCM bufSize, SCM sources, SCM types, SCM ids, SCM severities, SCM lengths, SCM messageLog)
"ADD ME LATER")
#define FUNC_NAME s_glGetDebugMessageLog
{
GLuint lp_count = (GLuint)scm_to_uint32(count);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLenum* lp_sources = (GLenum*)SCM_BYTEVECTOR_CONTENTS(sources);
GLenum* lp_types = (GLenum*)SCM_BYTEVECTOR_CONTENTS(types);
GLuint* lp_ids = (GLuint*)SCM_BYTEVECTOR_CONTENTS(ids);
GLenum* lp_severities = (GLenum*)SCM_BYTEVECTOR_CONTENTS(severities);
GLsizei* lp_lengths = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(lengths);
GLchar* lp_messageLog = (GLchar*)SCM_BYTEVECTOR_CONTENTS(messageLog);
GLuint lp_ret;
lp_ret = glGetDebugMessageLog(lp_count, lp_bufSize, lp_sources, lp_types, lp_ids, lp_severities, lp_lengths, lp_messageLog);
return scm_from_uint32(lp_ret);
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPushDebugGroup,"gl-push-debug-group",4,0,0,
(SCM source, SCM id, SCM length, SCM message)
"ADD ME LATER")
#define FUNC_NAME s_glPushDebugGroup
{
GLenum lp_source = (GLenum)scm_to_uint32(source);
GLuint lp_id = (GLuint)scm_to_uint32(id);
GLsizei lp_length = (GLsizei)scm_to_uint32(length);
GLchar* lp_message = (GLchar*)SCM_BYTEVECTOR_CONTENTS(message);
glPushDebugGroup(lp_source, lp_id, lp_length, lp_message);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glPopDebugGroup,"gl-pop-debug-group",0,0,0,
(void)
"ADD ME LATER")
#define FUNC_NAME s_glPopDebugGroup
{
glPopDebugGroup();
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glObjectLabel,"gl-object-label",4,0,0,
(SCM identifier, SCM name, SCM length, SCM label)
"ADD ME LATER")
#define FUNC_NAME s_glObjectLabel
{
GLenum lp_identifier = (GLenum)scm_to_uint32(identifier);
GLuint lp_name = (GLuint)scm_to_uint32(name);
GLsizei lp_length = (GLsizei)scm_to_uint32(length);
GLchar* lp_label = (GLchar*)SCM_BYTEVECTOR_CONTENTS(label);
glObjectLabel(lp_identifier, lp_name, lp_length, lp_label);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetObjectLabel,"gl-get-object-label",5,0,0,
(SCM identifier, SCM name, SCM bufSize, SCM length, SCM label)
"ADD ME LATER")
#define FUNC_NAME s_glGetObjectLabel
{
GLenum lp_identifier = (GLenum)scm_to_uint32(identifier);
GLuint lp_name = (GLuint)scm_to_uint32(name);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_label = (GLchar*)SCM_BYTEVECTOR_CONTENTS(label);
glGetObjectLabel(lp_identifier, lp_name, lp_bufSize, lp_length, lp_label);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glObjectPtrLabel,"gl-object-ptr-label",3,0,0,
(SCM ptr, SCM length, SCM label)
"ADD ME LATER")
#define FUNC_NAME s_glObjectPtrLabel
{
GLvoid* lp_ptr = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(ptr);
GLsizei lp_length = (GLsizei)scm_to_uint32(length);
GLchar* lp_label = (GLchar*)SCM_BYTEVECTOR_CONTENTS(label);
glObjectPtrLabel(lp_ptr, lp_length, lp_label);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glGetObjectPtrLabel,"gl-get-object-ptr-label",4,0,0,
(SCM ptr, SCM bufSize, SCM length, SCM label)
"ADD ME LATER")
#define FUNC_NAME s_glGetObjectPtrLabel
{
GLvoid* lp_ptr = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(ptr);
GLsizei lp_bufSize = (GLsizei)scm_to_uint32(bufSize);
GLsizei* lp_length = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(length);
GLchar* lp_label = (GLchar*)SCM_BYTEVECTOR_CONTENTS(label);
glGetObjectPtrLabel(lp_ptr, lp_bufSize, lp_length, lp_label);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBufferStorage,"gl-buffer-storage",4,0,0,
(SCM target, SCM size, SCM data, SCM flags)
"ADD ME LATER")
#define FUNC_NAME s_glBufferStorage
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLsizeiptr lp_size = (GLsizeiptr)scm_to_uint32(size);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
GLbitfield lp_flags = (GLbitfield)scm_to_uint32(flags);
glBufferStorage(lp_target, lp_size, lp_data, lp_flags);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearTexImage,"gl-clear-tex-image",5,0,0,
(SCM texture, SCM level, SCM format, SCM type, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glClearTexImage
{
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLint lp_level = (GLint)scm_to_int32(level);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glClearTexImage(lp_texture, lp_level, lp_format, lp_type, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glClearTexSubImage,"gl-clear-tex-sub-image",11,0,0,
(SCM texture, SCM level, SCM xoffset, SCM yoffset, SCM zoffset, SCM width, SCM height, SCM depth, SCM format, SCM type, SCM data)
"ADD ME LATER")
#define FUNC_NAME s_glClearTexSubImage
{
GLuint lp_texture = (GLuint)scm_to_uint32(texture);
GLint lp_level = (GLint)scm_to_int32(level);
GLint lp_xoffset = (GLint)scm_to_int32(xoffset);
GLint lp_yoffset = (GLint)scm_to_int32(yoffset);
GLint lp_zoffset = (GLint)scm_to_int32(zoffset);
GLsizei lp_width = (GLsizei)scm_to_uint32(width);
GLsizei lp_height = (GLsizei)scm_to_uint32(height);
GLsizei lp_depth = (GLsizei)scm_to_uint32(depth);
GLenum lp_format = (GLenum)scm_to_uint32(format);
GLenum lp_type = (GLenum)scm_to_uint32(type);
GLvoid* lp_data = (GLvoid*)SCM_BYTEVECTOR_CONTENTS(data);
glClearTexSubImage(lp_texture, lp_level, lp_xoffset, lp_yoffset, lp_zoffset, lp_width, lp_height, lp_depth, lp_format, lp_type, lp_data);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindBuffersBase,"gl-bind-buffers-base",4,0,0,
(SCM target, SCM first, SCM count, SCM buffers)
"ADD ME LATER")
#define FUNC_NAME s_glBindBuffersBase
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_first = (GLuint)scm_to_uint32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_buffers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(buffers);
glBindBuffersBase(lp_target, lp_first, lp_count, lp_buffers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindBuffersRange,"gl-bind-buffers-range",6,0,0,
(SCM target, SCM first, SCM count, SCM buffers, SCM offsets, SCM sizes)
"ADD ME LATER")
#define FUNC_NAME s_glBindBuffersRange
{
GLenum lp_target = (GLenum)scm_to_uint32(target);
GLuint lp_first = (GLuint)scm_to_uint32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_buffers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(buffers);
GLintptr* lp_offsets = (GLintptr*)SCM_BYTEVECTOR_CONTENTS(offsets);
GLsizeiptr* lp_sizes = (GLsizeiptr*)SCM_BYTEVECTOR_CONTENTS(sizes);
glBindBuffersRange(lp_target, lp_first, lp_count, lp_buffers, lp_offsets, lp_sizes);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindTextures,"gl-bind-textures",3,0,0,
(SCM first, SCM count, SCM textures)
"ADD ME LATER")
#define FUNC_NAME s_glBindTextures
{
GLuint lp_first = (GLuint)scm_to_uint32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_textures = (GLuint*)SCM_BYTEVECTOR_CONTENTS(textures);
glBindTextures(lp_first, lp_count, lp_textures);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindSamplers,"gl-bind-samplers",3,0,0,
(SCM first, SCM count, SCM samplers)
"ADD ME LATER")
#define FUNC_NAME s_glBindSamplers
{
GLuint lp_first = (GLuint)scm_to_uint32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_samplers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(samplers);
glBindSamplers(lp_first, lp_count, lp_samplers);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindImageTextures,"gl-bind-image-textures",3,0,0,
(SCM first, SCM count, SCM textures)
"ADD ME LATER")
#define FUNC_NAME s_glBindImageTextures
{
GLuint lp_first = (GLuint)scm_to_uint32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_textures = (GLuint*)SCM_BYTEVECTOR_CONTENTS(textures);
glBindImageTextures(lp_first, lp_count, lp_textures);
return SCM_UNDEFINED;
}
#undef FUNC_NAME



SCM_DEFINE_PUBLIC(glBindVertexBuffers,"gl-bind-vertex-buffers",5,0,0,
(SCM first, SCM count, SCM buffers, SCM offsets, SCM strides)
"ADD ME LATER")
#define FUNC_NAME s_glBindVertexBuffers
{
GLuint lp_first = (GLuint)scm_to_uint32(first);
GLsizei lp_count = (GLsizei)scm_to_uint32(count);
GLuint* lp_buffers = (GLuint*)SCM_BYTEVECTOR_CONTENTS(buffers);
GLintptr* lp_offsets = (GLintptr*)SCM_BYTEVECTOR_CONTENTS(offsets);
GLsizei* lp_strides = (GLsizei*)SCM_BYTEVECTOR_CONTENTS(strides);
glBindVertexBuffers(lp_first, lp_count, lp_buffers, lp_offsets, lp_strides);
return SCM_UNDEFINED;
}
#undef FUNC_NAME