path: root/src/opengl/bind/v.bind

int glValidateProgram_bind(lua_State *L)
{
	GLuint program = luaL_checkinteger(L, 1);
	glValidateProgram(program);
	return 0;
}


int glValidateProgramPipeline_bind(lua_State *L)
{
	GLuint pipeline = luaL_checkinteger(L, 1);
	glValidateProgramPipeline(pipeline);
	return 0;
}


int glVertexAttrib1f_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLfloat v0 = luaL_checknumber(L, 2);
	glVertexAttrib1f(index, v0);
	return 0;
}


int glVertexAttrib1s_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLshort v0 = luaL_checkinteger(L, 2);
	glVertexAttrib1s(index, v0);
	return 0;
}


int glVertexAttrib1d_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLdouble v0 = luaL_checknumber(L, 2);
	glVertexAttrib1d(index, v0);
	return 0;
}


int glVertexAttribI1i_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLint v0 = luaL_checkinteger(L, 2);
	glVertexAttribI1i(index, v0);
	return 0;
}


int glVertexAttribI1ui_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLuint v0 = luaL_checkinteger(L, 2);
	glVertexAttribI1ui(index, v0);
	return 0;
}


int glVertexAttrib2f_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLfloat v0 = luaL_checknumber(L, 2);
	GLfloat v1 = luaL_checknumber(L, 3);
	glVertexAttrib2f(index, v0, v1);
	return 0;
}


int glVertexAttrib2s_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLshort v0 = luaL_checkinteger(L, 2);
	GLshort v1 = luaL_checkinteger(L, 3);
	glVertexAttrib2s(index, v0, v1);
	return 0;
}


int glVertexAttrib2d_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLdouble v0 = luaL_checknumber(L, 2);
	GLdouble v1 = luaL_checknumber(L, 3);
	glVertexAttrib2d(index, v0, v1);
	return 0;
}


int glVertexAttribI2i_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLint v0 = luaL_checkinteger(L, 2);
	GLint v1 = luaL_checkinteger(L, 3);
	glVertexAttribI2i(index, v0, v1);
	return 0;
}


int glVertexAttribI2ui_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLuint v0 = luaL_checkinteger(L, 2);
	GLuint v1 = luaL_checkinteger(L, 3);
	glVertexAttribI2ui(index, v0, v1);
	return 0;
}


int glVertexAttrib3f_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLfloat v0 = luaL_checknumber(L, 2);
	GLfloat v1 = luaL_checknumber(L, 3);
	GLfloat v2 = luaL_checknumber(L, 4);
	glVertexAttrib3f(index, v0, v1, v2);
	return 0;
}


int glVertexAttrib3s_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLshort v0 = luaL_checkinteger(L, 2);
	GLshort v1 = luaL_checkinteger(L, 3);
	GLshort v2 = luaL_checkinteger(L, 4);
	glVertexAttrib3s(index, v0, v1, v2);
	return 0;
}


int glVertexAttrib3d_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLdouble v0 = luaL_checknumber(L, 2);
	GLdouble v1 = luaL_checknumber(L, 3);
	GLdouble v2 = luaL_checknumber(L, 4);
	glVertexAttrib3d(index, v0, v1, v2);
	return 0;
}


int glVertexAttribI3i_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLint v0 = luaL_checkinteger(L, 2);
	GLint v1 = luaL_checkinteger(L, 3);
	GLint v2 = luaL_checkinteger(L, 4);
	glVertexAttribI3i(index, v0, v1, v2);
	return 0;
}


int glVertexAttribI3ui_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLuint v0 = luaL_checkinteger(L, 2);
	GLuint v1 = luaL_checkinteger(L, 3);
	GLuint v2 = luaL_checkinteger(L, 4);
	glVertexAttribI3ui(index, v0, v1, v2);
	return 0;
}


int glVertexAttrib4f_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLfloat v0 = luaL_checknumber(L, 2);
	GLfloat v1 = luaL_checknumber(L, 3);
	GLfloat v2 = luaL_checknumber(L, 4);
	GLfloat v3 = luaL_checknumber(L, 5);
	glVertexAttrib4f(index, v0, v1, v2, v3);
	return 0;
}


int glVertexAttrib4s_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLshort v0 = luaL_checkinteger(L, 2);
	GLshort v1 = luaL_checkinteger(L, 3);
	GLshort v2 = luaL_checkinteger(L, 4);
	GLshort v3 = luaL_checkinteger(L, 5);
	glVertexAttrib4s(index, v0, v1, v2, v3);
	return 0;
}


int glVertexAttrib4d_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLdouble v0 = luaL_checknumber(L, 2);
	GLdouble v1 = luaL_checknumber(L, 3);
	GLdouble v2 = luaL_checknumber(L, 4);
	GLdouble v3 = luaL_checknumber(L, 5);
	glVertexAttrib4d(index, v0, v1, v2, v3);
	return 0;
}


int glVertexAttrib4Nub_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLubyte v0 = luaL_checkinteger(L, 2);
	GLubyte v1 = luaL_checkinteger(L, 3);
	GLubyte v2 = luaL_checkinteger(L, 4);
	GLubyte v3 = luaL_checkinteger(L, 5);
	glVertexAttrib4Nub(index, v0, v1, v2, v3);
	return 0;
}


int glVertexAttribI4i_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLint v0 = luaL_checkinteger(L, 2);
	GLint v1 = luaL_checkinteger(L, 3);
	GLint v2 = luaL_checkinteger(L, 4);
	GLint v3 = luaL_checkinteger(L, 5);
	glVertexAttribI4i(index, v0, v1, v2, v3);
	return 0;
}


int glVertexAttribI4ui_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLuint v0 = luaL_checkinteger(L, 2);
	GLuint v1 = luaL_checkinteger(L, 3);
	GLuint v2 = luaL_checkinteger(L, 4);
	GLuint v3 = luaL_checkinteger(L, 5);
	glVertexAttribI4ui(index, v0, v1, v2, v3);
	return 0;
}


int glVertexAttribL1d_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLdouble v0 = luaL_checknumber(L, 2);
	glVertexAttribL1d(index, v0);
	return 0;
}


int glVertexAttribL2d_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLdouble v0 = luaL_checknumber(L, 2);
	GLdouble v1 = luaL_checknumber(L, 3);
	glVertexAttribL2d(index, v0, v1);
	return 0;
}


int glVertexAttribL3d_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLdouble v0 = luaL_checknumber(L, 2);
	GLdouble v1 = luaL_checknumber(L, 3);
	GLdouble v2 = luaL_checknumber(L, 4);
	glVertexAttribL3d(index, v0, v1, v2);
	return 0;
}


int glVertexAttribL4d_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLdouble v0 = luaL_checknumber(L, 2);
	GLdouble v1 = luaL_checknumber(L, 3);
	GLdouble v2 = luaL_checknumber(L, 4);
	GLdouble v3 = luaL_checknumber(L, 5);
	glVertexAttribL4d(index, v0, v1, v2, v3);
	return 0;
}


int glVertexAttrib1fv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLfloat * v = get: const GLfloat *
	glVertexAttrib1fv(index, v);
	return 0;
}


int glVertexAttrib1sv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLshort * v = get: const GLshort *
	glVertexAttrib1sv(index, v);
	return 0;
}


int glVertexAttrib1dv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLdouble * v = get: const GLdouble *
	glVertexAttrib1dv(index, v);
	return 0;
}


int glVertexAttribI1iv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLint * v = get: const GLint *
	glVertexAttribI1iv(index, v);
	return 0;
}


int glVertexAttribI1uiv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLuint * v = get: const GLuint *
	glVertexAttribI1uiv(index, v);
	return 0;
}


int glVertexAttrib2fv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLfloat * v = get: const GLfloat *
	glVertexAttrib2fv(index, v);
	return 0;
}


int glVertexAttrib2sv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLshort * v = get: const GLshort *
	glVertexAttrib2sv(index, v);
	return 0;
}


int glVertexAttrib2dv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLdouble * v = get: const GLdouble *
	glVertexAttrib2dv(index, v);
	return 0;
}


int glVertexAttribI2iv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLint * v = get: const GLint *
	glVertexAttribI2iv(index, v);
	return 0;
}


int glVertexAttribI2uiv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLuint * v = get: const GLuint *
	glVertexAttribI2uiv(index, v);
	return 0;
}


int glVertexAttrib3fv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLfloat * v = get: const GLfloat *
	glVertexAttrib3fv(index, v);
	return 0;
}


int glVertexAttrib3sv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLshort * v = get: const GLshort *
	glVertexAttrib3sv(index, v);
	return 0;
}


int glVertexAttrib3dv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLdouble * v = get: const GLdouble *
	glVertexAttrib3dv(index, v);
	return 0;
}


int glVertexAttribI3iv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLint * v = get: const GLint *
	glVertexAttribI3iv(index, v);
	return 0;
}


int glVertexAttribI3uiv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLuint * v = get: const GLuint *
	glVertexAttribI3uiv(index, v);
	return 0;
}


int glVertexAttrib4fv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLfloat * v = get: const GLfloat *
	glVertexAttrib4fv(index, v);
	return 0;
}


int glVertexAttrib4sv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLshort * v = get: const GLshort *
	glVertexAttrib4sv(index, v);
	return 0;
}


int glVertexAttrib4dv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLdouble * v = get: const GLdouble *
	glVertexAttrib4dv(index, v);
	return 0;
}


int glVertexAttrib4iv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLint * v = get: const GLint *
	glVertexAttrib4iv(index, v);
	return 0;
}


int glVertexAttrib4bv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLbyte * v = get: const GLbyte *
	glVertexAttrib4bv(index, v);
	return 0;
}


int glVertexAttrib4ubv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLubyte * v = get: const GLubyte *
	glVertexAttrib4ubv(index, v);
	return 0;
}


int glVertexAttrib4usv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLushort * v = get: const GLushort *
	glVertexAttrib4usv(index, v);
	return 0;
}


int glVertexAttrib4uiv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLuint * v = get: const GLuint *
	glVertexAttrib4uiv(index, v);
	return 0;
}


int glVertexAttrib4Nbv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLbyte * v = get: const GLbyte *
	glVertexAttrib4Nbv(index, v);
	return 0;
}


int glVertexAttrib4Nsv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLshort * v = get: const GLshort *
	glVertexAttrib4Nsv(index, v);
	return 0;
}


int glVertexAttrib4Niv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLint * v = get: const GLint *
	glVertexAttrib4Niv(index, v);
	return 0;
}


int glVertexAttrib4Nubv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLubyte * v = get: const GLubyte *
	glVertexAttrib4Nubv(index, v);
	return 0;
}


int glVertexAttrib4Nusv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLushort * v = get: const GLushort *
	glVertexAttrib4Nusv(index, v);
	return 0;
}


int glVertexAttrib4Nuiv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLuint * v = get: const GLuint *
	glVertexAttrib4Nuiv(index, v);
	return 0;
}


int glVertexAttribI4bv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLbyte * v = get: const GLbyte *
	glVertexAttribI4bv(index, v);
	return 0;
}


int glVertexAttribI4ubv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLubyte * v = get: const GLubyte *
	glVertexAttribI4ubv(index, v);
	return 0;
}


int glVertexAttribI4sv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLshort * v = get: const GLshort *
	glVertexAttribI4sv(index, v);
	return 0;
}


int glVertexAttribI4usv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLushort * v = get: const GLushort *
	glVertexAttribI4usv(index, v);
	return 0;
}


int glVertexAttribI4iv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLint * v = get: const GLint *
	glVertexAttribI4iv(index, v);
	return 0;
}


int glVertexAttribI4uiv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLuint * v = get: const GLuint *
	glVertexAttribI4uiv(index, v);
	return 0;
}


int glVertexAttribL1dv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLdouble * v = get: const GLdouble *
	glVertexAttribL1dv(index, v);
	return 0;
}


int glVertexAttribL2dv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLdouble * v = get: const GLdouble *
	glVertexAttribL2dv(index, v);
	return 0;
}


int glVertexAttribL3dv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLdouble * v = get: const GLdouble *
	glVertexAttribL3dv(index, v);
	return 0;
}


int glVertexAttribL4dv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLdouble * v = get: const GLdouble *
	glVertexAttribL4dv(index, v);
	return 0;
}


int glVertexAttribP1ui_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLenum type = luaL_checkinteger(L, 2);
	GLboolean normalized = get: GLboolean
	GLuint value = luaL_checkinteger(L, 4);
	glVertexAttribP1ui(index, type, normalized, value);
	return 0;
}


int glVertexAttribP2ui_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLenum type = luaL_checkinteger(L, 2);
	GLboolean normalized = get: GLboolean
	GLuint value = luaL_checkinteger(L, 4);
	glVertexAttribP2ui(index, type, normalized, value);
	return 0;
}


int glVertexAttribP3ui_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLenum type = luaL_checkinteger(L, 2);
	GLboolean normalized = get: GLboolean
	GLuint value = luaL_checkinteger(L, 4);
	glVertexAttribP3ui(index, type, normalized, value);
	return 0;
}


int glVertexAttribP4ui_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLenum type = luaL_checkinteger(L, 2);
	GLboolean normalized = get: GLboolean
	GLuint value = luaL_checkinteger(L, 4);
	glVertexAttribP4ui(index, type, normalized, value);
	return 0;
}


int glVertexAttribPointer_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLint size = luaL_checkinteger(L, 2);
	GLenum type = luaL_checkinteger(L, 3);
	GLboolean normalized = get: GLboolean
	GLsizei stride = luaL_checkinteger(L, 5);
	const void * pointer = get: const void *
	glVertexAttribPointer(index, size, type, normalized, stride, pointer);
	return 0;
}


int glVertexAttribIPointer_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLint size = luaL_checkinteger(L, 2);
	GLenum type = luaL_checkinteger(L, 3);
	GLsizei stride = luaL_checkinteger(L, 4);
	const void * pointer = get: const void *
	glVertexAttribIPointer(index, size, type, stride, pointer);
	return 0;
}


int glViewport_bind(lua_State *L)
{
	GLint x = luaL_checkinteger(L, 1);
	GLint y = luaL_checkinteger(L, 2);
	GLsizei width = luaL_checkinteger(L, 3);
	GLsizei height = luaL_checkinteger(L, 4);
	glViewport(x, y, width, height);
	return 0;
}


int glViewportArrayv_bind(lua_State *L)
{
	GLuint first = luaL_checkinteger(L, 1);
	GLsizei count = luaL_checkinteger(L, 2);
	const GLfloat * v = get: const GLfloat *
	glViewportArrayv(first, count, v);
	return 0;
}


int glViewportIndexedf_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	GLfloat x = luaL_checknumber(L, 2);
	GLfloat y = luaL_checknumber(L, 3);
	GLfloat w = luaL_checknumber(L, 4);
	GLfloat h = luaL_checknumber(L, 5);
	glViewportIndexedf(index, x, y, w, h);
	return 0;
}


int glViewportIndexedfv_bind(lua_State *L)
{
	GLuint index = luaL_checkinteger(L, 1);
	const GLfloat * v = get: const GLfloat *
	glViewportIndexedfv(index, v);
	return 0;
}