indirect_window_pos.c \
indirect_transpose_matrix.c \
indirect_vertex_array.c \
+ indirect_vertex_program.c \
pixel.c \
pixelstore.c \
render2.c \
static const struct extension_info known_gl_extensions[] = {
{ GL(ARB_depth_texture), VER(1,4), Y, N, N, N },
- { GL(ARB_fragment_program), VER(0,0), N, N, N, N },
+ { GL(ARB_fragment_program), VER(0,0), Y, N, N, N },
+ { GL(ARB_fragment_program_shadow), VER(0,0), Y, N, N, N },
{ GL(ARB_imaging), VER(0,0), Y, N, N, N },
{ GL(ARB_multisample), VER(1,3), Y, N, N, N },
{ GL(ARB_multitexture), VER(1,3), Y, N, N, N },
{ GL(ARB_texture_rectangle), VER(0,0), Y, N, N, N },
{ GL(ARB_transpose_matrix), VER(1,3), Y, N, Y, N },
{ GL(ARB_vertex_buffer_object), VER(1,5), N, N, N, N },
+ { GL(ARB_vertex_program), VER(0,0), Y, N, N, N },
{ GL(ARB_window_pos), VER(1,4), Y, N, N, N },
{ GL(EXT_abgr), VER(0,0), Y, N, N, N },
{ GL(EXT_bgra), VER(1,2), Y, N, N, N },
{ GL(3DFX_texture_compression_FXT1), VER(0,0), Y, N, N, N },
{ GL(APPLE_packed_pixels), VER(1,2), Y, N, N, N },
{ GL(APPLE_ycbcr_422), VER(0,0), Y, N, N, N },
+ { GL(ATI_text_fragment_shader), VER(0,0), Y, N, N, N },
{ GL(ATI_texture_env_combine3), VER(0,0), Y, N, N, N },
{ GL(ATI_texture_float), VER(0,0), Y, N, N, N },
{ GL(ATI_texture_mirror_once), VER(0,0), Y, N, N, N },
{ GL(NV_copy_depth_to_color), VER(0,0), Y, N, N, N },
{ GL(NV_depth_clamp), VER(0,0), Y, N, N, N },
{ GL(NV_fog_distance), VER(0,0), Y, N, N, N },
+ { GL(NV_fragment_program), VER(0,0), Y, N, N, N },
+ { GL(NV_fragment_program_option), VER(0,0), Y, N, N, N },
+ { GL(NV_fragment_program2), VER(0,0), Y, N, N, N },
{ GL(NV_light_max_exponent), VER(0,0), Y, N, N, N },
{ GL(NV_multisample_filter_hint), VER(0,0), Y, N, N, N },
{ GL(NV_point_sprite), VER(0,0), Y, N, N, N },
{ GL(NV_texture_compression_vtc), VER(0,0), Y, N, N, N },
{ GL(NV_texture_env_combine4), VER(0,0), Y, N, N, N },
{ GL(NV_texture_rectangle), VER(0,0), Y, N, N, N },
+ { GL(NV_vertex_program), VER(0,0), Y, N, N, N },
+ { GL(NV_vertex_program1_1), VER(0,0), Y, N, N, N },
+ { GL(NV_vertex_program2), VER(0,0), Y, N, N, N },
+ { GL(NV_vertex_program2_option), VER(0,0), Y, N, N, N },
+ { GL(NV_vertex_program3), VER(0,0), Y, N, N, N },
{ GL(OES_read_format), VER(0,0), Y, N, N, N },
{ GL(OES_compressed_paletted_texture),VER(0,0), Y, N, N, N },
{ GL(SGI_color_matrix), VER(0,0), Y, N, N, N },
enum {
GL_ARB_depth_texture_bit = 0,
GL_ARB_fragment_program_bit,
+ GL_ARB_fragment_program_shadow_bit,
GL_ARB_imaging_bit,
GL_ARB_multisample_bit,
GL_ARB_multitexture_bit,
GL_3DFX_texture_compression_FXT1_bit,
GL_APPLE_packed_pixels_bit,
GL_APPLE_ycbcr_422_bit,
+ GL_ATI_text_fragment_shader_bit,
GL_ATI_texture_env_combine3_bit,
GL_ATI_texture_float_bit,
GL_ATI_texture_mirror_once_bit,
GL_NV_copy_depth_to_color_bit,
GL_NV_depth_clamp_bit,
GL_NV_fog_distance_bit,
+ GL_NV_fragment_program_bit,
+ GL_NV_fragment_program_option_bit,
+ GL_NV_fragment_program2_bit,
GL_NV_light_max_exponent_bit,
GL_NV_multisample_filter_hint_bit,
GL_NV_point_sprite_bit,
GL_NV_texgen_reflection_bit,
GL_NV_texture_compression_vtc_bit,
GL_NV_texture_env_combine4_bit,
+ GL_NV_vertex_program_bit,
+ GL_NV_vertex_program1_1_bit,
+ GL_NV_vertex_program2_bit,
+ GL_NV_vertex_program2_option_bit,
+ GL_NV_vertex_program3_bit,
GL_OES_compressed_paletted_texture_bit,
GL_OES_read_format_bit,
GL_SGI_color_matrix_bit,
generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
}
-#define X_GLrop_PointParameteriNV 4221
+#define X_GLvop_AreProgramsResidentNV 1293
+GLboolean
+__indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ GLboolean retval = (GLboolean) 0;
+ const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreProgramsResidentNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
+ retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return retval;
+}
+
+#define X_GLrop_BindProgramNV 4180
void
-__indirect_glPointParameteriNV(GLenum pname, GLint params)
+__indirect_glBindProgramNV(GLenum target, GLuint id)
{
__GLXcontext * const gc = __glXGetCurrentContext();
const GLuint cmdlen = 12;
- emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(¶ms), 4);
+ emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
gc->pc += cmdlen;
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
-#define X_GLrop_PointParameterivNV 4222
+#define X_GLvop_DeleteProgramsNV 1294
void
-__indirect_glPointParameterivNV(GLenum pname, const GLint * params)
+__indirect_glDeleteProgramsNV(GLsizei n, const GLuint * ids)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- const GLuint compsize = __glPointParameterivNV_size(pname);
- const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
- emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteProgramsNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLrop_ExecuteProgramNV 4181
+void
+__indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
gc->pc += cmdlen;
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
-#define X_GLrop_ActiveStencilFaceEXT 4220
+#define X_GLvop_GenProgramsNV 1295
void
-__indirect_glActiveStencilFaceEXT(GLenum face)
+__indirect_glGenProgramsNV(GLsizei n, GLuint * ids)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenProgramsNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+ (void) __glXReadReply(dpy, 4, ids, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramParameterdvNV 1297
+void
+__indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 12;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterdvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 8, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramParameterfvNV 1296
+void
+__indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 12;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterfvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramivNV 1298
+void
+__indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramStringNV 1299
+void
+__indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 1, program, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetTrackMatrixivNV 1300
+void
+__indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 12;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetTrackMatrixivNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&address), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_IsProgramNV 1304
+GLboolean
+__indirect_glIsProgramNV(GLuint id)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ GLboolean retval = (GLboolean) 0;
+ const GLuint cmdlen = 4;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsProgramNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return retval;
+}
+
+#define X_GLrop_LoadProgramNV 4183
+void
+__indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16 + __GLX_PAD((len * 1));
+ if (__builtin_expect(len >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(program), (len * 1));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_ProgramParameter4dvNV 4185
+void
+__indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4dvNV 4185
+void
+__indirect_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4fvNV 4184
+void
+__indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4fvNV 4184
+void
+__indirect_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameters4dvNV 4187
+void
+__indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num, const GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(params), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&num), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameters4fvNV 4186
+void
+__indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16 + __GLX_PAD((num * 4));
+ if (__builtin_expect(num >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_RequestResidentProgramsNV 4182
+void
+__indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(ids), (n * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_TrackMatrixNV 4188
+void
+__indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&address), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&matrix), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&transform), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvARB 4197
+void
+__indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvARB 4197
+void
+__indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvARB 4193
+void
+__indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvARB 4193
+void
+__indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svARB 4189
+void
+__indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svARB 4189
+void
+__indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvARB 4198
+void
+__indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvARB 4198
+void
+__indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvARB 4194
+void
+__indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvARB 4194
+void
+__indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svARB 4190
+void
+__indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svARB 4190
+void
+__indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvARB 4199
+void
+__indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 32;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvARB 4199
+void
+__indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 32;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvARB 4195
+void
+__indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvARB 4195
+void
+__indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svARB 4191
+void
+__indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svARB 4191
+void
+__indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvARB 4200
+void
+__indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 40;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvARB 4200
+void
+__indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 40;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvARB 4196
+void
+__indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvARB 4196
+void
+__indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svARB 4192
+void
+__indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+ (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svARB 4192
+void
+__indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NubvARB 4201
+void
+__indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
+ (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
+ (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NubvARB 4201
+void
+__indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs1dvNV 4210
+void
+__indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs1fvNV 4206
+void
+__indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs1svNV 4202
+void
+__indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_VertexAttribs2dvNV 4211
+void
+__indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&n), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs2fvNV 4207
+void
+__indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs2svNV 4203
+void
+__indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs3dvNV 4212
+void
+__indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&n), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs3fvNV 4208
+void
+__indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs3svNV 4204
+void
+__indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs4dvNV 4213
+void
+__indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&n), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs4fvNV 4209
+void
+__indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs4svNV 4205
+void
+__indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs4ubvNV 4214
+void
+__indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), 1);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PointParameteriNV 4221
+void
+__indirect_glPointParameteriNV(GLenum pname, GLint params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(¶ms), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PointParameterivNV 4222
+void
+__indirect_glPointParameterivNV(GLenum pname, const GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = __glPointParameterivNV_size(pname);
+ const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
+ emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ActiveStencilFaceEXT 4220
+void
+__indirect_glActiveStencilFaceEXT(GLenum face)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 8;
+ emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ivARB 4231
+void
+__indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvARB 4232
+void
+__indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4usvARB 4233
+void
+__indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4uivARB 4234
+void
+__indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NbvARB 4235
+void
+__indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NsvARB 4236
+void
+__indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NivARB 4237
+void
+__indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NusvARB 4238
+void
+__indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NuivARB 4239
+void
+__indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramStringARB 4217
+void
+__indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16 + __GLX_PAD((len * 1));
+ if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(string), (len * 1));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_ProgramStringARB;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 12), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 16), (void *)(&len), 4);
+ __glXSendLargeCommand(gc, pc, 20, string, (len * 1));
+ }
+ }
+}
+
+#define X_GLrop_ProgramEnvParameter4dvARB 4185
+void
+__indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4dvARB 4185
+void
+__indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4fvARB 4184
+void
+__indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4fvARB 4184
+void
+__indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4dvARB 4216
+void
+__indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4dvARB 4216
+void
+__indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44;
+ emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(params), 32);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4fvARB 4215
+void
+__indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4fvARB 4215
+void
+__indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28;
+ emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_GetProgramivARB 1307
+void
+__indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivARB, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramStringARB 1308
+void
+__indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringARB, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 0, string, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLrop_ProgramNamedParameter4fvNV 4218
+void
+__indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28 + __GLX_PAD((len * 1));
+ if (__builtin_expect(len >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(name), (len * 1));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_ProgramNamedParameter4dvNV 4219
+void
+__indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44 + __GLX_PAD((len * 1));
+ if (__builtin_expect(len >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(name), (len * 1));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_ProgramNamedParameter4fvNV 4218
+void
+__indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 28 + __GLX_PAD((len * 1));
+ if (__builtin_expect(len >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(v), 16);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(name), (len * 1));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLrop_ProgramNamedParameter4dvNV 4219
+void
+__indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 44 + __GLX_PAD((len * 1));
+ if (__builtin_expect(len >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(name), (len * 1));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+#define X_GLvop_GetProgramNamedParameterfvNV 1310
+void
+__indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8 + __GLX_PAD((len * 1));
+ if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterfvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(name), (len * 1));
+ (void) __glXReadReply(dpy, 4, params, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetProgramNamedParameterdvNV 1311
+void
+__indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8 + __GLX_PAD((len * 1));
+ if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterdvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(name), (len * 1));
+ (void) __glXReadReply(dpy, 8, params, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetVertexAttribdvNV 1301
+void
+__indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribdvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 8, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetVertexAttribfvNV 1302
+void
+__indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribfvNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLvop_GetVertexAttribivNV 1303
+void
+__indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 8;
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribivNV, cmdlen);
+ (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+ (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+#define X_GLrop_VertexAttrib1dvNV 4197
+void
+__indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvNV 4197
+void
+__indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvNV 4193
+void
+__indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvNV 4193
+void
+__indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svNV 4189
+void
+__indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svNV 4189
+void
+__indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvNV 4198
+void
+__indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvNV 4198
+void
+__indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvNV 4194
+void
+__indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvNV 4194
+void
+__indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svNV 4190
+void
+__indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svNV 4190
+void
+__indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvNV 4199
+void
+__indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 32;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvNV 4199
+void
+__indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 32;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvNV 4195
+void
+__indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvNV 4195
+void
+__indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 20;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svNV 4191
+void
+__indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svNV 4191
+void
+__indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvNV 4200
+void
+__indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 40;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvNV 4200
+void
+__indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 40;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvNV 4196
+void
+__indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+ (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+ (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvNV 4196
+void
+__indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 24;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svNV 4192
+void
+__indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+ (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svNV 4192
+void
+__indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 16;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvNV 4201
+void
+__indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
+ (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
+ (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
+ (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvNV 4201
+void
+__indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint cmdlen = 12;
+ emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
gc->pc += cmdlen;
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
extern HIDDEN void __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue);
extern HIDDEN void __indirect_glSecondaryColor3usvEXT(const GLushort * v);
extern HIDDEN void __indirect_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN GLboolean __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences);
+extern HIDDEN void __indirect_glBindProgramNV(GLenum target, GLuint id);
+extern HIDDEN void __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * ids);
+extern HIDDEN void __indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params);
+extern HIDDEN void __indirect_glGenProgramsNV(GLsizei n, GLuint * ids);
+extern HIDDEN void __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params);
+extern HIDDEN void __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program);
+extern HIDDEN void __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble * params);
+extern HIDDEN void __indirect_glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetVertexAttribivARB(GLuint index, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid ** pointer);
+extern HIDDEN GLboolean __indirect_glIsProgramNV(GLuint id);
+extern HIDDEN void __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program);
+extern HIDDEN void __indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * params);
+extern HIDDEN void __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params);
+extern HIDDEN void __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids);
+extern HIDDEN void __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform);
+extern HIDDEN void __indirect_glVertexAttribPointerNV(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x);
+extern HIDDEN void __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x);
+extern HIDDEN void __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib1sARB(GLuint index, GLshort x);
+extern HIDDEN void __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y);
+extern HIDDEN void __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y);
+extern HIDDEN void __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y);
+extern HIDDEN void __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z);
+extern HIDDEN void __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+extern HIDDEN void __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+extern HIDDEN void __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v);
+extern HIDDEN void __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v);
extern HIDDEN void __indirect_glPointParameteriNV(GLenum pname, GLint params);
extern HIDDEN void __indirect_glPointParameterivNV(GLenum pname, const GLint * params);
extern HIDDEN void __indirect_glMultiDrawArraysEXT(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount);
extern HIDDEN void __indirect_glMultiDrawElementsEXT(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount);
extern HIDDEN void __indirect_glActiveStencilFaceEXT(GLenum face);
+extern HIDDEN void __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v);
+extern HIDDEN void __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v);
+extern HIDDEN void __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v);
+extern HIDDEN void __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v);
+extern HIDDEN void __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v);
+extern HIDDEN void __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v);
+extern HIDDEN void __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v);
+extern HIDDEN void __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v);
+extern HIDDEN void __indirect_glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glEnableVertexAttribArrayARB(GLuint index);
+extern HIDDEN void __indirect_glDisableVertexAttribArrayARB(GLuint index);
+extern HIDDEN void __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string);
+extern HIDDEN void __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params);
+extern HIDDEN void __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble * params);
+extern HIDDEN void __indirect_glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble * params);
+extern HIDDEN void __indirect_glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string);
+extern HIDDEN void __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v);
+extern HIDDEN void __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v);
+extern HIDDEN void __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params);
+extern HIDDEN void __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params);
+extern HIDDEN void __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x);
+extern HIDDEN void __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x);
+extern HIDDEN void __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib1sNV(GLuint index, GLshort x);
+extern HIDDEN void __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y);
+extern HIDDEN void __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y);
+extern HIDDEN void __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y);
+extern HIDDEN void __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z);
+extern HIDDEN void __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+extern HIDDEN void __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+extern HIDDEN void __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v);
# undef HIDDEN
# undef FASTCALL
glAPI->SecondaryColor3usvEXT = __indirect_glSecondaryColor3usvEXT;
glAPI->SecondaryColorPointerEXT = __indirect_glSecondaryColorPointerEXT;
+ /* GL_NV_vertex_program */
+
+ glAPI->AreProgramsResidentNV = __indirect_glAreProgramsResidentNV;
+ glAPI->BindProgramNV = __indirect_glBindProgramNV;
+ glAPI->DeleteProgramsNV = __indirect_glDeleteProgramsNV;
+ glAPI->ExecuteProgramNV = __indirect_glExecuteProgramNV;
+ glAPI->GenProgramsNV = __indirect_glGenProgramsNV;
+ glAPI->GetProgramParameterdvNV = __indirect_glGetProgramParameterdvNV;
+ glAPI->GetProgramParameterfvNV = __indirect_glGetProgramParameterfvNV;
+ glAPI->GetProgramivNV = __indirect_glGetProgramivNV;
+ glAPI->GetProgramStringNV = __indirect_glGetProgramStringNV;
+ glAPI->GetTrackMatrixivNV = __indirect_glGetTrackMatrixivNV;
+
+ /* GL_ARB_vertex_program */
+
+ glAPI->GetVertexAttribdvARB = __indirect_glGetVertexAttribdvARB;
+ glAPI->GetVertexAttribfvARB = __indirect_glGetVertexAttribfvARB;
+ glAPI->GetVertexAttribivARB = __indirect_glGetVertexAttribivARB;
+
+ /* GL_NV_vertex_program */
+
+ glAPI->GetVertexAttribPointervNV = __indirect_glGetVertexAttribPointervNV;
+ glAPI->IsProgramNV = __indirect_glIsProgramNV;
+ glAPI->LoadProgramNV = __indirect_glLoadProgramNV;
+ glAPI->ProgramParameter4dNV = __indirect_glProgramParameter4dNV;
+ glAPI->ProgramParameter4dvNV = __indirect_glProgramParameter4dvNV;
+ glAPI->ProgramParameter4fNV = __indirect_glProgramParameter4fNV;
+ glAPI->ProgramParameter4fvNV = __indirect_glProgramParameter4fvNV;
+ glAPI->ProgramParameters4dvNV = __indirect_glProgramParameters4dvNV;
+ glAPI->ProgramParameters4fvNV = __indirect_glProgramParameters4fvNV;
+ glAPI->RequestResidentProgramsNV = __indirect_glRequestResidentProgramsNV;
+ glAPI->TrackMatrixNV = __indirect_glTrackMatrixNV;
+ glAPI->VertexAttribPointerNV = __indirect_glVertexAttribPointerNV;
+
+ /* GL_ARB_vertex_program */
+
+ glAPI->VertexAttrib1dARB = __indirect_glVertexAttrib1dARB;
+ glAPI->VertexAttrib1dvARB = __indirect_glVertexAttrib1dvARB;
+ glAPI->VertexAttrib1fARB = __indirect_glVertexAttrib1fARB;
+ glAPI->VertexAttrib1fvARB = __indirect_glVertexAttrib1fvARB;
+ glAPI->VertexAttrib1sARB = __indirect_glVertexAttrib1sARB;
+ glAPI->VertexAttrib1svARB = __indirect_glVertexAttrib1svARB;
+ glAPI->VertexAttrib2dARB = __indirect_glVertexAttrib2dARB;
+ glAPI->VertexAttrib2dvARB = __indirect_glVertexAttrib2dvARB;
+ glAPI->VertexAttrib2fARB = __indirect_glVertexAttrib2fARB;
+ glAPI->VertexAttrib2fvARB = __indirect_glVertexAttrib2fvARB;
+ glAPI->VertexAttrib2sARB = __indirect_glVertexAttrib2sARB;
+ glAPI->VertexAttrib2svARB = __indirect_glVertexAttrib2svARB;
+ glAPI->VertexAttrib3dARB = __indirect_glVertexAttrib3dARB;
+ glAPI->VertexAttrib3dvARB = __indirect_glVertexAttrib3dvARB;
+ glAPI->VertexAttrib3fARB = __indirect_glVertexAttrib3fARB;
+ glAPI->VertexAttrib3fvARB = __indirect_glVertexAttrib3fvARB;
+ glAPI->VertexAttrib3sARB = __indirect_glVertexAttrib3sARB;
+ glAPI->VertexAttrib3svARB = __indirect_glVertexAttrib3svARB;
+ glAPI->VertexAttrib4dARB = __indirect_glVertexAttrib4dARB;
+ glAPI->VertexAttrib4dvARB = __indirect_glVertexAttrib4dvARB;
+ glAPI->VertexAttrib4fARB = __indirect_glVertexAttrib4fARB;
+ glAPI->VertexAttrib4fvARB = __indirect_glVertexAttrib4fvARB;
+ glAPI->VertexAttrib4sARB = __indirect_glVertexAttrib4sARB;
+ glAPI->VertexAttrib4svARB = __indirect_glVertexAttrib4svARB;
+ glAPI->VertexAttrib4NubARB = __indirect_glVertexAttrib4NubARB;
+ glAPI->VertexAttrib4NubvARB = __indirect_glVertexAttrib4NubvARB;
+
+ /* GL_NV_vertex_program */
+
+ glAPI->VertexAttribs1dvNV = __indirect_glVertexAttribs1dvNV;
+ glAPI->VertexAttribs1fvNV = __indirect_glVertexAttribs1fvNV;
+ glAPI->VertexAttribs1svNV = __indirect_glVertexAttribs1svNV;
+ glAPI->VertexAttribs2dvNV = __indirect_glVertexAttribs2dvNV;
+ glAPI->VertexAttribs2fvNV = __indirect_glVertexAttribs2fvNV;
+ glAPI->VertexAttribs2svNV = __indirect_glVertexAttribs2svNV;
+ glAPI->VertexAttribs3dvNV = __indirect_glVertexAttribs3dvNV;
+ glAPI->VertexAttribs3fvNV = __indirect_glVertexAttribs3fvNV;
+ glAPI->VertexAttribs3svNV = __indirect_glVertexAttribs3svNV;
+ glAPI->VertexAttribs4dvNV = __indirect_glVertexAttribs4dvNV;
+ glAPI->VertexAttribs4fvNV = __indirect_glVertexAttribs4fvNV;
+ glAPI->VertexAttribs4svNV = __indirect_glVertexAttribs4svNV;
+ glAPI->VertexAttribs4ubvNV = __indirect_glVertexAttribs4ubvNV;
+
/* GL_NV_point_sprite */
glAPI->PointParameteriNV = __indirect_glPointParameteriNV;
glAPI->ActiveStencilFaceEXT = __indirect_glActiveStencilFaceEXT;
+ /* GL_ARB_vertex_program */
+
+ glAPI->VertexAttrib4ivARB = __indirect_glVertexAttrib4ivARB;
+ glAPI->VertexAttrib4ubvARB = __indirect_glVertexAttrib4ubvARB;
+ glAPI->VertexAttrib4usvARB = __indirect_glVertexAttrib4usvARB;
+ glAPI->VertexAttrib4uivARB = __indirect_glVertexAttrib4uivARB;
+ glAPI->VertexAttrib4NbvARB = __indirect_glVertexAttrib4NbvARB;
+ glAPI->VertexAttrib4NsvARB = __indirect_glVertexAttrib4NsvARB;
+ glAPI->VertexAttrib4NivARB = __indirect_glVertexAttrib4NivARB;
+ glAPI->VertexAttrib4NusvARB = __indirect_glVertexAttrib4NusvARB;
+ glAPI->VertexAttrib4NuivARB = __indirect_glVertexAttrib4NuivARB;
+ glAPI->VertexAttribPointerARB = __indirect_glVertexAttribPointerARB;
+ glAPI->EnableVertexAttribArrayARB = __indirect_glEnableVertexAttribArrayARB;
+ glAPI->DisableVertexAttribArrayARB = __indirect_glDisableVertexAttribArrayARB;
+ glAPI->ProgramStringARB = __indirect_glProgramStringARB;
+ glAPI->ProgramEnvParameter4dARB = __indirect_glProgramEnvParameter4dARB;
+ glAPI->ProgramEnvParameter4dvARB = __indirect_glProgramEnvParameter4dvARB;
+ glAPI->ProgramEnvParameter4fARB = __indirect_glProgramEnvParameter4fARB;
+ glAPI->ProgramEnvParameter4fvARB = __indirect_glProgramEnvParameter4fvARB;
+ glAPI->ProgramLocalParameter4dARB = __indirect_glProgramLocalParameter4dARB;
+ glAPI->ProgramLocalParameter4dvARB = __indirect_glProgramLocalParameter4dvARB;
+ glAPI->ProgramLocalParameter4fARB = __indirect_glProgramLocalParameter4fARB;
+ glAPI->ProgramLocalParameter4fvARB = __indirect_glProgramLocalParameter4fvARB;
+ glAPI->GetProgramEnvParameterdvARB = __indirect_glGetProgramEnvParameterdvARB;
+ glAPI->GetProgramEnvParameterfvARB = __indirect_glGetProgramEnvParameterfvARB;
+ glAPI->GetProgramLocalParameterdvARB = __indirect_glGetProgramLocalParameterdvARB;
+ glAPI->GetProgramLocalParameterfvARB = __indirect_glGetProgramLocalParameterfvARB;
+ glAPI->GetProgramivARB = __indirect_glGetProgramivARB;
+ glAPI->GetProgramStringARB = __indirect_glGetProgramStringARB;
+
+ /* GL_NV_fragment_program */
+
+ glAPI->ProgramNamedParameter4fNV = __indirect_glProgramNamedParameter4fNV;
+ glAPI->ProgramNamedParameter4dNV = __indirect_glProgramNamedParameter4dNV;
+ glAPI->ProgramNamedParameter4fvNV = __indirect_glProgramNamedParameter4fvNV;
+ glAPI->ProgramNamedParameter4dvNV = __indirect_glProgramNamedParameter4dvNV;
+ glAPI->GetProgramNamedParameterfvNV = __indirect_glGetProgramNamedParameterfvNV;
+ glAPI->GetProgramNamedParameterdvNV = __indirect_glGetProgramNamedParameterdvNV;
+
+ /* GL_NV_vertex_program */
+
+ glAPI->GetVertexAttribdvNV = __indirect_glGetVertexAttribdvNV;
+ glAPI->GetVertexAttribfvNV = __indirect_glGetVertexAttribfvNV;
+ glAPI->GetVertexAttribivNV = __indirect_glGetVertexAttribivNV;
+ glAPI->VertexAttrib1dNV = __indirect_glVertexAttrib1dNV;
+ glAPI->VertexAttrib1dvNV = __indirect_glVertexAttrib1dvNV;
+ glAPI->VertexAttrib1fNV = __indirect_glVertexAttrib1fNV;
+ glAPI->VertexAttrib1fvNV = __indirect_glVertexAttrib1fvNV;
+ glAPI->VertexAttrib1sNV = __indirect_glVertexAttrib1sNV;
+ glAPI->VertexAttrib1svNV = __indirect_glVertexAttrib1svNV;
+ glAPI->VertexAttrib2dNV = __indirect_glVertexAttrib2dNV;
+ glAPI->VertexAttrib2dvNV = __indirect_glVertexAttrib2dvNV;
+ glAPI->VertexAttrib2fNV = __indirect_glVertexAttrib2fNV;
+ glAPI->VertexAttrib2fvNV = __indirect_glVertexAttrib2fvNV;
+ glAPI->VertexAttrib2sNV = __indirect_glVertexAttrib2sNV;
+ glAPI->VertexAttrib2svNV = __indirect_glVertexAttrib2svNV;
+ glAPI->VertexAttrib3dNV = __indirect_glVertexAttrib3dNV;
+ glAPI->VertexAttrib3dvNV = __indirect_glVertexAttrib3dvNV;
+ glAPI->VertexAttrib3fNV = __indirect_glVertexAttrib3fNV;
+ glAPI->VertexAttrib3fvNV = __indirect_glVertexAttrib3fvNV;
+ glAPI->VertexAttrib3sNV = __indirect_glVertexAttrib3sNV;
+ glAPI->VertexAttrib3svNV = __indirect_glVertexAttrib3svNV;
+ glAPI->VertexAttrib4dNV = __indirect_glVertexAttrib4dNV;
+ glAPI->VertexAttrib4dvNV = __indirect_glVertexAttrib4dvNV;
+ glAPI->VertexAttrib4fNV = __indirect_glVertexAttrib4fNV;
+ glAPI->VertexAttrib4fvNV = __indirect_glVertexAttrib4fvNV;
+ glAPI->VertexAttrib4sNV = __indirect_glVertexAttrib4sNV;
+ glAPI->VertexAttrib4svNV = __indirect_glVertexAttrib4svNV;
+ glAPI->VertexAttrib4ubNV = __indirect_glVertexAttrib4ubNV;
+ glAPI->VertexAttrib4ubvNV = __indirect_glVertexAttrib4ubvNV;
+
return glAPI;
}
GLint count;
/**
+ * "Normalized" data is on the range [0,1] (unsigned) or [-1,1] (signed).
+ * This is used for mapping integral types to floating point types.
+ */
+ GLboolean normalized;
+
+ /**
* Pre-calculated GLX protocol command header.
*/
uint32_t header[2];
unsigned num_texture_units;
/**
+ * Number of generic vertex program attribs. If GL_ARB_vertex_program
+ * is not supported, this will be zero. Otherwise it will be the value
+ * queries by calling \c glGetProgramiv with \c GL_VERTEX_PROGRAM_ARB
+ * and \c GL_MAX_PROGRAM_ATTRIBS_ARB.
+ */
+ unsigned num_vertex_program_attribs;
+
+ /**
* \n Methods for implementing various GL functions.
*
* These method pointers are only valid \c array_info_cache_valid is set.
static struct array_state * get_array_entry(
const struct array_state_vector * arrays, GLenum key, unsigned index );
static void fill_array_info_cache( struct array_state_vector * arrays );
-static GLboolean glx_validate_array_args(__GLXcontext *gc, GLenum mode,
- GLsizei count);
+static GLboolean validate_mode(__GLXcontext *gc, GLenum mode);
+static GLboolean validate_count(__GLXcontext *gc, GLsizei count);
/**
unsigned array_count;
unsigned texture_units = 1;
unsigned i;
+ unsigned j;
+ unsigned vertex_program_attribs;
GLboolean got_fog = GL_FALSE;
GLboolean got_secondary_color = GL_FALSE;
texture_units = 1;
}
+ if ( __glExtensionBitIsEnabled( gc, GL_ARB_vertex_program_bit ) ) {
+ glGetProgramivARB( GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ATTRIBS_ARB,
+ & vertex_program_attribs );
+ }
+
arrays->num_texture_units = texture_units;
- array_count += texture_units;
+ arrays->num_vertex_program_attribs = vertex_program_attribs;
+ array_count += texture_units + vertex_program_attribs;
arrays->num_arrays = array_count;
arrays->arrays = malloc( sizeof( struct array_state ) * array_count );
arrays->arrays[0].data_type = GL_FLOAT;
arrays->arrays[0].count = 3;
arrays->arrays[0].key = GL_NORMAL_ARRAY;
+ arrays->arrays[0].normalized = GL_TRUE;
arrays->arrays[0].old_DrawArrays_possible = GL_TRUE;
arrays->arrays[1].data_type = GL_FLOAT;
arrays->arrays[1].count = 4;
arrays->arrays[1].key = GL_COLOR_ARRAY;
+ arrays->arrays[1].normalized = GL_TRUE;
arrays->arrays[1].old_DrawArrays_possible = GL_TRUE;
arrays->arrays[2].data_type = GL_FLOAT;
arrays->arrays[4 + i].data_type = GL_FLOAT;
arrays->arrays[4 + i].count = 4;
arrays->arrays[4 + i].key = GL_TEXTURE_COORD_ARRAY;
-
+
arrays->arrays[4 + i].old_DrawArrays_possible = (i == 0);
arrays->arrays[4 + i].index = i;
arrays->arrays[i].count = 3;
arrays->arrays[i].key = GL_SECONDARY_COLOR_ARRAY;
arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
+ arrays->arrays[i].normalized = GL_TRUE;
i++;
}
+ for ( j = 0 ; j < vertex_program_attribs ; j++ ) {
+ const unsigned idx = (vertex_program_attribs - (j + 1));
+
+
+ arrays->arrays[idx + i].data_type = GL_FLOAT;
+ arrays->arrays[idx + i].count = 4;
+ arrays->arrays[idx + i].key = GL_VERTEX_ATTRIB_ARRAY_POINTER;
+
+ arrays->arrays[idx + i].old_DrawArrays_possible = 0;
+ arrays->arrays[idx + i].index = idx;
+
+ arrays->arrays[idx + i].header[1] = idx;
+ }
+
+ i += vertex_program_attribs;
+
+
/* Vertex array *must* be last becuase of the way that
* emit_DrawArrays_none works.
*/
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
if ( arrays->arrays[i].enabled ) {
- single_vertex_size += __GLX_PAD(arrays->arrays[i].element_size)
- + arrays->arrays[i].header_size;
+ single_vertex_size += ((uint16_t *)arrays->arrays[i].header)[0];
}
}
if ( arrays->arrays[i].enabled ) {
const size_t offset = index * arrays->arrays[i].true_stride;
+ /* The generic attributes can have more data than is in the
+ * elements. This is because a vertex array can be a 2 element,
+ * normalized, unsigned short, but the "closest" immediate mode
+ * protocol is for a 4Nus. Since the sizes are small, the
+ * performance impact on modern processors should be negligible.
+ */
+ (void) memset( dst, 0,
+ ((uint16_t *)arrays->arrays[i].header)[0] );
+
(void) memcpy( dst, arrays->arrays[i].header,
arrays->arrays[i].header_size );
}
+void __indirect_glVertexAttribPointerARB(GLuint index, GLint size,
+ GLenum type, GLboolean normalized,
+ GLsizei stride,
+ const GLvoid * pointer)
+{
+ static const uint16_t short_ops[5] = { 0, 4189, 4190, 4191, 4192 };
+ static const uint16_t float_ops[5] = { 0, 4193, 4194, 4195, 4196 };
+ static const uint16_t double_ops[5] = { 0, 4197, 4198, 4199, 4200 };
+
+ uint16_t opcode;
+ __GLXcontext *gc = __glXGetCurrentContext();
+ __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+ struct array_state_vector * arrays = state->array_state;
+ struct array_state * a;
+ unsigned true_immediate_count;
+ unsigned true_immediate_size;
+
+
+ if ( (size < 1) || (size > 4) || (stride < 0)
+ || (index > arrays->num_vertex_program_attribs) ){
+ __glXSetError(gc, GL_INVALID_VALUE);
+ return;
+ }
+
+ if ( normalized && (type != GL_FLOAT) && (type != GL_DOUBLE)) {
+ switch( type ) {
+ case GL_BYTE: opcode = X_GLrop_VertexAttrib4NbvARB; break;
+ case GL_UNSIGNED_BYTE: opcode = X_GLrop_VertexAttrib4NubvARB; break;
+ case GL_SHORT: opcode = X_GLrop_VertexAttrib4NsvARB; break;
+ case GL_UNSIGNED_SHORT: opcode = X_GLrop_VertexAttrib4NusvARB; break;
+ case GL_INT: opcode = X_GLrop_VertexAttrib4NivARB; break;
+ case GL_UNSIGNED_INT: opcode = X_GLrop_VertexAttrib4NuivARB; break;
+ default:
+ __glXSetError(gc, GL_INVALID_ENUM);
+ return;
+ }
+
+ true_immediate_count = 4;
+ }
+ else {
+ switch( type ) {
+ case GL_BYTE:
+ opcode = X_GLrop_VertexAttrib4bvARB;
+ true_immediate_count = 4;
+ break;
+ case GL_UNSIGNED_BYTE:
+ opcode = X_GLrop_VertexAttrib4ubvARB;
+ true_immediate_count = 4;
+ break;
+ case GL_SHORT:
+ opcode = short_ops[size];
+ break;
+ case GL_UNSIGNED_SHORT:
+ opcode = X_GLrop_VertexAttrib4usvARB;
+ true_immediate_count = 4;
+ break;
+ case GL_INT:
+ opcode = X_GLrop_VertexAttrib4ivARB;
+ true_immediate_count = 4;
+ break;
+ case GL_UNSIGNED_INT:
+ opcode = X_GLrop_VertexAttrib4uivARB;
+ true_immediate_count = 4;
+ break;
+ case GL_FLOAT:
+ opcode = float_ops[size];
+ break;
+ case GL_DOUBLE:
+ opcode = double_ops[size];
+ break;
+ default:
+ __glXSetError(gc, GL_INVALID_ENUM);
+ return;
+ }
+ }
+
+ a = get_array_entry( arrays, GL_VERTEX_ATTRIB_ARRAY_POINTER, index );
+ if ( a == NULL ) {
+ __glXSetError(gc, GL_INVALID_OPERATION);
+ return;
+ }
+
+ COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, 8, opcode );
+
+ true_immediate_size = __glXTypeSize(type) * true_immediate_count;
+ ((uint16_t *) (a)->header)[0] = __GLX_PAD(a->header_size
+ + true_immediate_size);
+
+ if ( a->enabled ) {
+ arrays->array_info_cache_valid = GL_FALSE;
+ }
+}
+
+
+/**
+ * I don't have 100% confidence that this is correct. The different rules
+ * about whether or not generic vertex attributes alias "classic" vertex
+ * attributes (i.e., attrib1 ?= primary color) between ARB_vertex_program,
+ * ARB_vertex_shader, and NV_vertex_program are a bit confusing. My
+ * feeling is that the client-side doesn't have to worry about it. The
+ * client just sends all the data to the server and lets the server deal
+ * with it.
+ */
+void __indirect_glVertexAttribPointerNV( GLuint index, GLint size,
+ GLenum type, GLsizei stride,
+ const GLvoid * pointer)
+{
+ __GLXcontext *gc = __glXGetCurrentContext();
+ GLboolean normalized = GL_FALSE;
+
+
+ switch( type ) {
+ case GL_UNSIGNED_BYTE:
+ if ( size != 4 ) {
+ __glXSetError(gc, GL_INVALID_VALUE);
+ return;
+ }
+ normalized = GL_TRUE;
+
+ case GL_SHORT:
+ case GL_FLOAT:
+ case GL_DOUBLE:
+ __indirect_glVertexAttribPointerARB(index, size, type,
+ normalized,
+ stride, pointer);
+ return;
+ default:
+ __glXSetError(gc, GL_INVALID_ENUM);
+ return;
+ }
+}
+
+
void __indirect_glClientActiveTextureARB(GLenum texture)
{
__GLXcontext * const gc = __glXGetCurrentContext();
if ( a != NULL ) {
- *dest = a->data;
+ *dest = (void *) (a->data);
+ }
+
+ return (a != NULL);
+}
+
+
+/**
+ */
+GLboolean
+__glXGetArrayNormalized( const __GLXattribute * const state,
+ GLenum key, unsigned index, GLintptr * dest )
+{
+ const struct array_state_vector * arrays = state->array_state;
+ const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
+ key, index );
+
+
+ if ( a != NULL ) {
+ *dest = (GLintptr) a->normalized;
}
return (a != NULL);
GLenum key, unsigned index, GLintptr * dest );
extern GLboolean __glXGetArrayPointer( const __GLXattribute * const state,
GLenum key, unsigned index, void ** dest );
+extern GLboolean __glXGetArrayNormalized( const __GLXattribute * const state,
+ GLenum key, unsigned index, GLintptr * dest );
extern void __glXPushArrayState( __GLXattribute * state );
extern void __glXPopArrayState( __GLXattribute * state );
--- /dev/null
+/*
+ * (C) Copyright IBM Corporation 2005
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <inttypes.h>
+#include <GL/gl.h>
+#include "indirect.h"
+#include "glxclient.h"
+#include "indirect_vertex_array.h"
+#include <GL/glxproto.h>
+
+void do_vertex_attrib_enable( GLuint index, GLboolean val )
+{
+ __GLXcontext *gc = __glXGetCurrentContext();
+ __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+
+ if ( ! __glXSetArrayEnable( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
+ index, val ) ) {
+ __glXSetError(gc, GL_INVALID_ENUM);
+ }
+}
+
+
+void __indirect_glEnableVertexAttribArrayARB( GLuint index )
+{
+ do_vertex_attrib_enable( index, GL_TRUE );
+}
+
+
+void __indirect_glDisableVertexAttribArrayARB( GLuint index )
+{
+ do_vertex_attrib_enable( index, GL_FALSE );
+}
+
+
+static void
+get_parameter( unsigned opcode, unsigned size, GLenum target, GLuint index,
+ GLfloat * params )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ const GLuint cmdlen = 12;
+
+ if (__builtin_expect(dpy != NULL, 1)) {
+ GLubyte const * pc = __glXSetupVendorRequest(gc,
+ X_GLXVendorPrivateWithReply,
+ opcode, cmdlen);
+
+ *((GLenum *)(pc + 0)) = target;
+ *((GLuint *)(pc + 4)) = index;
+ *((GLuint *)(pc + 8)) = 0;
+
+ (void) __glXReadReply(dpy, size, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
+ }
+ return;
+}
+
+
+void __indirect_glGetProgramEnvParameterfvARB( GLenum target, GLuint index,
+ GLfloat * params )
+{
+ get_parameter( 1296, 4, target, index, params );
+}
+
+
+void __indirect_glGetProgramEnvParameterdvARB( GLenum target, GLuint index,
+ GLdouble * params )
+{
+ get_parameter( 1297, 8, target, index, params );
+}
+
+
+void __indirect_glGetProgramLocalParameterfvARB( GLenum target, GLuint index,
+ GLfloat * params )
+{
+ get_parameter( 1305, 4, target, index, params );
+}
+
+
+void __indirect_glGetProgramLocalParameterdvARB( GLenum target, GLuint index,
+ GLdouble * params )
+{
+ get_parameter( 1306, 8, target, index, params );
+}
+
+
+void __indirect_glGetVertexAttribPointervNV( GLuint index, GLenum pname,
+ GLvoid ** pointer )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+
+ if ( pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB ) {
+ __glXSetError( gc, GL_INVALID_ENUM );
+ }
+
+ if ( ! __glXGetArrayPointer( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
+ index, pointer ) ) {
+ __glXSetError( gc, GL_INVALID_VALUE );
+ }
+}
+
+
+/**
+ * Get the selected attribute from the vertex array state vector.
+ *
+ * \returns
+ * On success \c GL_TRUE is returned. Otherwise, \c GL_FALSE is returned.
+ */
+static GLboolean
+get_attrib_array_data( __GLXattribute * state, GLuint index, GLenum cap,
+ GLintptr * data )
+{
+ GLboolean retval = GL_FALSE;
+ const GLenum attrib = GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB;
+
+ switch( cap ) {
+ case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
+ retval = __glXGetArrayEnable( state, attrib, index, data );
+ break;
+
+ case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
+ retval = __glXGetArraySize( state, attrib, index, data );
+ break;
+
+ case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
+ retval = __glXGetArrayStride( state, attrib, index, data );
+ break;
+
+ case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
+ retval = __glXGetArrayType( state, attrib, index, data );
+ break;
+
+ case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB:
+ retval = __glXGetArrayNormalized( state, attrib, index, data );
+ break;
+ }
+
+
+ return retval;
+}
+
+
+static void get_vertex_attrib( __GLXcontext * gc, unsigned vop,
+ GLuint index, GLenum pname,
+ xReply * reply )
+{
+ Display * const dpy = gc->currentDpy;
+ GLubyte * const pc = __glXSetupVendorRequest(gc,
+ X_GLXVendorPrivateWithReply,
+ vop, 8);
+
+ *((uint32_t *)(pc + 0)) = index;
+ *((uint32_t *)(pc + 4)) = pname;
+
+ (void) _XReply( dpy, reply, 0, False );
+}
+
+
+void __indirect_glGetVertexAttribivARB( GLuint index, GLenum pname,
+ GLint * params )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+ xGLXSingleReply reply;
+
+
+ get_vertex_attrib( gc, 1303, index, pname, (xReply *) & reply );
+
+ if ( reply.size != 0 ) {
+ if ( ! get_attrib_array_data( state, index, pname, params ) ) {
+ if (reply.size == 1) {
+ *params = (GLint) reply.pad3;
+ }
+ else {
+ _XRead(dpy, (void *) params, 4 * reply.size);
+ }
+ }
+ }
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+
+void __indirect_glGetVertexAttribfvARB( GLuint index, GLenum pname,
+ GLfloat * params )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+ xGLXSingleReply reply;
+
+
+ get_vertex_attrib( gc, 1302, index, pname, (xReply *) & reply );
+
+ if ( reply.size != 0 ) {
+ GLintptr data;
+
+
+ if ( get_attrib_array_data( state, index, pname, & data ) ) {
+ *params = (GLfloat) data;
+ }
+ else {
+ if (reply.size == 1) {
+ (void) memcpy( params, & reply.pad3, sizeof( GLfloat ) );
+ }
+ else {
+ _XRead(dpy, (void *) params, 4 * reply.size);
+ }
+ }
+ }
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
+
+
+void __indirect_glGetVertexAttribdvARB( GLuint index, GLenum pname,
+ GLdouble * params )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ Display * const dpy = gc->currentDpy;
+ __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+ xGLXSingleReply reply;
+
+
+ get_vertex_attrib( gc, 1301, index, pname, (xReply *) & reply );
+
+ if ( reply.size != 0 ) {
+ GLintptr data;
+
+
+ if ( get_attrib_array_data( state, index, pname, & data ) ) {
+ *params = (GLdouble) data;
+ }
+ else {
+ if (reply.size == 1) {
+ (void) memcpy( params, & reply.pad3, sizeof( GLdouble ) );
+ }
+ else {
+ _XRead(dpy, (void *) params, 8 * reply.size);
+ }
+ }
+ }
+
+ UnlockDisplay(dpy);
+ SyncHandle();
+}
<category name="GL_ARB_vertex_program" number="26">
<enum name="COLOR_SUM_ARB" value="0x8458"/>
- <enum name="VERTEX_PROGRAM_ARB" value="0x8620"/>
- <enum name="VERTEX_ATTRIB_ARRAY_ENABLED_ARB" value="0x8622"/>
- <enum name="VERTEX_ATTRIB_ARRAY_SIZE_ARB" value="0x8623"/>
- <enum name="VERTEX_ATTRIB_ARRAY_STRIDE_ARB" value="0x8624"/>
- <enum name="VERTEX_ATTRIB_ARRAY_TYPE_ARB" value="0x8625"/>
- <enum name="CURRENT_VERTEX_ATTRIB_ARB" value="0x8626"/>
- <enum name="PROGRAM_LENGTH_ARB" value="0x8627"/>
+ <enum name="VERTEX_PROGRAM_ARB" count="1" value="0x8620">
+ <size name="GetVertexAttribdvARB" mode="get"/>
+ <size name="GetVertexAttribfvARB" mode="get"/>
+ <size name="GetVertexAttribivARB" mode="get"/>
+ </enum>
+ <enum name="VERTEX_ATTRIB_ARRAY_ENABLED_ARB" count="1" value="0x8622">
+ <size name="GetVertexAttribdvARB" mode="get"/>
+ <size name="GetVertexAttribfvARB" mode="get"/>
+ <size name="GetVertexAttribivARB" mode="get"/>
+ </enum>
+ <enum name="VERTEX_ATTRIB_ARRAY_SIZE_ARB" count="1" value="0x8623">
+ <size name="GetVertexAttribdvARB" mode="get"/>
+ <size name="GetVertexAttribfvARB" mode="get"/>
+ <size name="GetVertexAttribivARB" mode="get"/>
+ </enum>
+ <enum name="VERTEX_ATTRIB_ARRAY_STRIDE_ARB" count="1" value="0x8624">
+ <size name="GetVertexAttribdvARB" mode="get"/>
+ <size name="GetVertexAttribfvARB" mode="get"/>
+ <size name="GetVertexAttribivARB" mode="get"/>
+ </enum>
+ <enum name="VERTEX_ATTRIB_ARRAY_TYPE_ARB" count="1" value="0x8625">
+ <size name="GetVertexAttribdvARB" mode="get"/>
+ <size name="GetVertexAttribfvARB" mode="get"/>
+ <size name="GetVertexAttribivARB" mode="get"/>
+ </enum>
+ <enum name="CURRENT_VERTEX_ATTRIB_ARB" count="1" value="0x8626">
+ <size name="GetVertexAttribdvARB" mode="get"/>
+ <size name="GetVertexAttribfvARB" mode="get"/>
+ <size name="GetVertexAttribivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_LENGTH_ARB" count="1" value="0x8627">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
<enum name="PROGRAM_STRING_ARB" value="0x8628"/>
<enum name="MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB" value="0x862E"/>
<enum name="MAX_PROGRAM_MATRICES_ARB" value="0x862F"/>
<enum name="VERTEX_PROGRAM_TWO_SIDE_ARB" value="0x8643"/>
<enum name="VERTEX_ATTRIB_ARRAY_POINTER_ARB" value="0x8645"/>
<enum name="PROGRAM_ERROR_POSITION_ARB" value="0x864B"/>
- <enum name="PROGRAM_BINDING_ARB" value="0x8677"/>
+ <enum name="PROGRAM_BINDING_ARB" count="1" value="0x8677">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
<enum name="MAX_VERTEX_ATTRIBS_ARB" value="0x8869"/>
<enum name="VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB" value="0x886A"/>
<enum name="PROGRAM_ERROR_STRING_ARB" value="0x8874"/>
<enum name="PROGRAM_FORMAT_ASCII_ARB" value="0x8875"/>
- <enum name="PROGRAM_FORMAT_ARB" value="0x8876"/>
- <enum name="PROGRAM_INSTRUCTIONS_ARB" value="0x88A0"/>
- <enum name="MAX_PROGRAM_INSTRUCTIONS_ARB" value="0x88A1"/>
- <enum name="PROGRAM_NATIVE_INSTRUCTIONS_ARB" value="0x88A2"/>
- <enum name="MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB" value="0x88A3"/>
- <enum name="PROGRAM_TEMPORARIES_ARB" value="0x88A4"/>
- <enum name="MAX_PROGRAM_TEMPORARIES_ARB" value="0x88A5"/>
- <enum name="PROGRAM_NATIVE_TEMPORARIES_ARB" value="0x88A6"/>
- <enum name="MAX_PROGRAM_NATIVE_TEMPORARIES_ARB" value="0x88A7"/>
- <enum name="PROGRAM_PARAMETERS_ARB" value="0x88A8"/>
- <enum name="MAX_PROGRAM_PARAMETERS_ARB" value="0x88A9"/>
- <enum name="PROGRAM_NATIVE_PARAMETERS_ARB" value="0x88AA"/>
- <enum name="MAX_PROGRAM_NATIVE_PARAMETERS_ARB" value="0x88AB"/>
- <enum name="PROGRAM_ATTRIBS_ARB" value="0x88AC"/>
- <enum name="MAX_PROGRAM_ATTRIBS_ARB" value="0x88AD"/>
- <enum name="PROGRAM_NATIVE_ATTRIBS_ARB" value="0x88AE"/>
- <enum name="MAX_PROGRAM_NATIVE_ATTRIBS_ARB" value="0x88AF"/>
- <enum name="PROGRAM_ADDRESS_REGISTERS_ARB" value="0x88B0"/>
- <enum name="MAX_PROGRAM_ADDRESS_REGISTERS_ARB" value="0x88B1"/>
- <enum name="PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" value="0x88B2"/>
- <enum name="MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" value="0x88B3"/>
- <enum name="MAX_PROGRAM_LOCAL_PARAMETERS_ARB" value="0x88B4"/>
- <enum name="MAX_PROGRAM_ENV_PARAMETERS_ARB" value="0x88B5"/>
- <enum name="PROGRAM_UNDER_NATIVE_LIMITS_ARB" value="0x88B6"/>
+ <enum name="PROGRAM_FORMAT_ARB" count="1" value="0x8876">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_INSTRUCTIONS_ARB" count="1" value="0x88A0">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_INSTRUCTIONS_ARB" count="1" value="0x88A1">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_NATIVE_INSTRUCTIONS_ARB" count="1" value="0x88A2">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB" count="1" value="0x88A3">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_TEMPORARIES_ARB" count="1" value="0x88A4">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_TEMPORARIES_ARB" count="1" value="0x88A5">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_NATIVE_TEMPORARIES_ARB" count="1" value="0x88A6">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_NATIVE_TEMPORARIES_ARB" count="1" value="0x88A7">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_PARAMETERS_ARB" count="1" value="0x88A8">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_PARAMETERS_ARB" count="1" value="0x88A9">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_NATIVE_PARAMETERS_ARB" count="1" value="0x88AA">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_NATIVE_PARAMETERS_ARB" count="1" value="0x88AB">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_ATTRIBS_ARB" count="1" value="0x88AC">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_ATTRIBS_ARB" count="1" value="0x88AD">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_NATIVE_ATTRIBS_ARB" count="1" value="0x88AE">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_NATIVE_ATTRIBS_ARB" count="1" value="0x88AF">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_ADDRESS_REGISTERS_ARB" count="1" value="0x88B0">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_ADDRESS_REGISTERS_ARB" count="1" value="0x88B1">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" count="1" value="0x88B2">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" count="1" value="0x88B3">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_LOCAL_PARAMETERS_ARB" count="1" value="0x88B4">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_ENV_PARAMETERS_ARB" count="1" value="0x88B5">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_UNDER_NATIVE_LIMITS_ARB" count="1" value="0x88B6">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
<enum name="TRANSPOSE_CURRENT_MATRIX_ARB" value="0x88B7"/>
<enum name="MATRIX0_ARB" value="0x88C0"/>
<enum name="MATRIX1_ARB" value="0x88C1"/>
<function name="GetVertexAttribdvARB" offset="588">
<param name="index" type="GLuint"/>
<param name="pname" type="GLenum"/>
- <param name="params" type="GLdouble *" output="true"/>
- <glx ignore="true"/>
+ <param name="params" type="GLdouble *" output="true" variable_param="pname"/>
+ <glx handcode="client" vendorpriv="1301"/>
</function>
<function name="GetVertexAttribfvARB" offset="589">
<param name="index" type="GLuint"/>
<param name="pname" type="GLenum"/>
- <param name="params" type="GLfloat *" output="true"/>
- <glx ignore="true"/>
+ <param name="params" type="GLfloat *" output="true" variable_param="pname"/>
+ <glx handcode="client" vendorpriv="1302"/>
</function>
<function name="GetVertexAttribivARB" offset="590">
<param name="index" type="GLuint"/>
<param name="pname" type="GLenum"/>
- <param name="params" type="GLint *" output="true"/>
- <glx ignore="true"/>
+ <param name="params" type="GLint *" output="true" variable_param="pname"/>
+ <glx handcode="client" vendorpriv="1303"/>
</function>
<function name="VertexAttrib1dARB" offset="603" vectorequiv="VertexAttrib1dvARB">
<param name="index" type="GLuint"/>
<param name="x" type="GLdouble"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib1dvARB" offset="604">
<param name="index" type="GLuint"/>
<param name="v" type="const GLdouble *" count="1"/>
- <glx ignore="true"/>
+ <glx rop="4197"/>
</function>
<function name="VertexAttrib1fARB" offset="605" vectorequiv="VertexAttrib1fvARB">
<param name="index" type="GLuint"/>
<param name="x" type="GLfloat"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib1fvARB" offset="606">
<param name="index" type="GLuint"/>
<param name="v" type="const GLfloat *" count="1"/>
- <glx ignore="true"/>
+ <glx rop="4193"/>
</function>
<function name="VertexAttrib1sARB" offset="607" vectorequiv="VertexAttrib1svARB">
<param name="index" type="GLuint"/>
<param name="x" type="GLshort"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib1svARB" offset="608">
<param name="index" type="GLuint"/>
<param name="v" type="const GLshort *" count="1"/>
- <glx ignore="true"/>
+ <glx rop="4189"/>
</function>
<function name="VertexAttrib2dARB" offset="609" vectorequiv="VertexAttrib2dvARB">
<param name="index" type="GLuint"/>
<param name="x" type="GLdouble"/>
<param name="y" type="GLdouble"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib2dvARB" offset="610">
<param name="index" type="GLuint"/>
<param name="v" type="const GLdouble *" count="2"/>
- <glx ignore="true"/>
+ <glx rop="4198"/>
</function>
<function name="VertexAttrib2fARB" offset="611" vectorequiv="VertexAttrib2fvARB">
<param name="index" type="GLuint"/>
<param name="x" type="GLfloat"/>
<param name="y" type="GLfloat"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib2fvARB" offset="612">
<param name="index" type="GLuint"/>
<param name="v" type="const GLfloat *" count="2"/>
- <glx ignore="true"/>
+ <glx rop="4194"/>
</function>
<function name="VertexAttrib2sARB" offset="613" vectorequiv="VertexAttrib2svARB">
<param name="index" type="GLuint"/>
<param name="x" type="GLshort"/>
<param name="y" type="GLshort"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib2svARB" offset="614">
<param name="index" type="GLuint"/>
<param name="v" type="const GLshort *" count="2"/>
- <glx ignore="true"/>
+ <glx rop="4190"/>
</function>
<function name="VertexAttrib3dARB" offset="615" vectorequiv="VertexAttrib3dvARB">
<param name="x" type="GLdouble"/>
<param name="y" type="GLdouble"/>
<param name="z" type="GLdouble"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib3dvARB" offset="616">
<param name="index" type="GLuint"/>
<param name="v" type="const GLdouble *" count="3"/>
- <glx ignore="true"/>
+ <glx rop="4199"/>
</function>
<function name="VertexAttrib3fARB" offset="617" vectorequiv="VertexAttrib3fvARB">
<param name="x" type="GLfloat"/>
<param name="y" type="GLfloat"/>
<param name="z" type="GLfloat"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib3fvARB" offset="618">
<param name="index" type="GLuint"/>
<param name="v" type="const GLfloat *" count="3"/>
- <glx ignore="true"/>
+ <glx rop="4195"/>
</function>
<function name="VertexAttrib3sARB" offset="619" vectorequiv="VertexAttrib3svARB">
<param name="x" type="GLshort"/>
<param name="y" type="GLshort"/>
<param name="z" type="GLshort"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib3svARB" offset="620">
<param name="index" type="GLuint"/>
<param name="v" type="const GLshort *" count="3"/>
- <glx ignore="true"/>
+ <glx rop="4191"/>
</function>
<function name="VertexAttrib4dARB" offset="621" vectorequiv="VertexAttrib4dvARB">
<param name="y" type="GLdouble"/>
<param name="z" type="GLdouble"/>
<param name="w" type="GLdouble"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib4dvARB" offset="622">
<param name="index" type="GLuint"/>
<param name="v" type="const GLdouble *" count="4"/>
- <glx ignore="true"/>
+ <glx rop="4200"/>
</function>
<function name="VertexAttrib4fARB" offset="623" vectorequiv="VertexAttrib4fvARB">
<param name="y" type="GLfloat"/>
<param name="z" type="GLfloat"/>
<param name="w" type="GLfloat"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib4fvARB" offset="624">
<param name="index" type="GLuint"/>
<param name="v" type="const GLfloat *" count="4"/>
- <glx ignore="true"/>
+ <glx rop="4196"/>
</function>
<function name="VertexAttrib4sARB" offset="625" vectorequiv="VertexAttrib4svARB">
<param name="y" type="GLshort"/>
<param name="z" type="GLshort"/>
<param name="w" type="GLshort"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib4svARB" offset="626">
<param name="index" type="GLuint"/>
<param name="v" type="const GLshort *" count="4"/>
- <glx ignore="true"/>
+ <glx rop="4192"/>
</function>
<function name="VertexAttrib4NubARB" offset="627" vectorequiv="VertexAttrib4NubvARB">
<param name="y" type="GLubyte"/>
<param name="z" type="GLubyte"/>
<param name="w" type="GLubyte"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib4NubvARB" offset="628">
<param name="index" type="GLuint"/>
<param name="v" type="const GLubyte *" count="4"/>
- <glx ignore="true"/>
+ <glx rop="4201"/>
</function>
<function name="VertexAttrib4bvARB" offset="654">
<function name="VertexAttrib4ivARB" offset="655">
<param name="index" type="GLuint"/>
<param name="v" type="const GLint *" count="4"/>
- <glx rop="4231" ignore="true"/>
+ <glx rop="4231"/>
</function>
<function name="VertexAttrib4ubvARB" offset="656">
<param name="index" type="GLuint"/>
<param name="v" type="const GLubyte *" count="4"/>
- <glx rop="4232" ignore="true"/>
+ <glx rop="4232"/>
</function>
<function name="VertexAttrib4usvARB" offset="657">
<param name="index" type="GLuint"/>
<param name="v" type="const GLushort *" count="4"/>
- <glx rop="4233" ignore="true"/>
+ <glx rop="4233"/>
</function>
<function name="VertexAttrib4uivARB" offset="658">
<param name="index" type="GLuint"/>
<param name="v" type="const GLuint *" count="4"/>
- <glx rop="4234" ignore="true"/>
+ <glx rop="4234"/>
</function>
<function name="VertexAttrib4NbvARB" offset="659">
<param name="index" type="GLuint"/>
<param name="v" type="const GLbyte *" count="4"/>
- <glx rop="4235" ignore="true"/>
+ <glx rop="4235"/>
</function>
<function name="VertexAttrib4NsvARB" offset="660">
<param name="index" type="GLuint"/>
<param name="v" type="const GLshort *" count="4"/>
- <glx rop="4236" ignore="true"/>
+ <glx rop="4236"/>
</function>
<function name="VertexAttrib4NivARB" offset="661">
<param name="index" type="GLuint"/>
<param name="v" type="const GLint *" count="4"/>
- <glx rop="4237" ignore="true"/>
+ <glx rop="4237"/>
</function>
<function name="VertexAttrib4NusvARB" offset="662">
<param name="index" type="GLuint"/>
<param name="v" type="const GLushort *" count="4"/>
- <glx rop="4238" ignore="true"/>
+ <glx rop="4238"/>
</function>
<function name="VertexAttrib4NuivARB" offset="663">
<param name="index" type="GLuint"/>
<param name="v" type="const GLuint *" count="4"/>
- <glx rop="4239" ignore="true"/>
+ <glx rop="4239"/>
</function>
<function name="VertexAttribPointerARB" offset="664">
<param name="normalized" type="GLboolean"/>
<param name="stride" type="GLsizei"/>
<param name="pointer" type="const GLvoid *"/>
- <glx handcode="true" ignore="true"/>
+ <glx handcode="true"/>
</function>
<function name="EnableVertexAttribArrayARB" offset="665">
<param name="index" type="GLuint"/>
- <glx handcode="true" ignore="true"/>
+ <glx handcode="true"/>
</function>
<function name="DisableVertexAttribArrayARB" offset="666">
<param name="index" type="GLuint"/>
- <glx handcode="true" ignore="true"/>
+ <glx handcode="true"/>
</function>
<function name="ProgramStringARB" offset="667">
<param name="target" type="GLenum"/>
<param name="format" type="GLenum"/>
- <param name="len" type="GLsizei"/>
- <param name="string" type="const GLvoid *"/>
- <glx rop="4217" handcode="true" ignore="true"/>
+ <param name="len" type="GLsizei" counter="true"/>
+ <param name="string" type="const GLvoid *" count="len"/>
+ <glx rop="4217" large="true"/>
</function>
<function name="BindProgramARB" alias="BindProgramNV">
<return type="GLboolean"/>
</function>
- <!-- FIXME: This should alias to ProgramParameter*NV -->
<function name="ProgramEnvParameter4dARB" offset="668" vectorequiv="ProgramEnvParameter4dvARB">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="y" type="GLdouble"/>
<param name="z" type="GLdouble"/>
<param name="w" type="GLdouble"/>
- <glx ignore="true"/>
</function>
- <!-- FIXME: This should alias to ProgramParameter*NV -->
<function name="ProgramEnvParameter4dvARB" offset="669">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="params" type="const GLdouble *" count="4"/>
- <glx rop="4185" doubles_in_order="true" ignore="true"/>
+ <glx rop="4185" doubles_in_order="true"/>
</function>
- <!-- FIXME: This should alias to ProgramParameter*NV -->
<function name="ProgramEnvParameter4fARB" offset="670" vectorequiv="ProgramEnvParameter4fvARB">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="y" type="GLfloat"/>
<param name="z" type="GLfloat"/>
<param name="w" type="GLfloat"/>
- <glx ignore="true"/>
</function>
- <!-- FIXME: This should alias to ProgramParameter*NV -->
<function name="ProgramEnvParameter4fvARB" offset="671">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="params" type="const GLfloat *" count="4"/>
- <glx rop="4184" ignore="true"/>
+ <glx rop="4184"/>
</function>
<function name="ProgramLocalParameter4dARB" offset="672" vectorequiv="ProgramLocalParameter4dvARB">
<param name="y" type="GLdouble"/>
<param name="z" type="GLdouble"/>
<param name="w" type="GLdouble"/>
- <glx ignore="true"/>
</function>
<function name="ProgramLocalParameter4dvARB" offset="673">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="params" type="const GLdouble *" count="4"/>
- <glx rop="4216" doubles_in_order="true" ignore="true"/>
+ <glx rop="4216" doubles_in_order="true"/>
</function>
<function name="ProgramLocalParameter4fARB" offset="674" vectorequiv="ProgramLocalParameter4fvARB">
<param name="y" type="GLfloat"/>
<param name="z" type="GLfloat"/>
<param name="w" type="GLfloat"/>
- <glx ignore="true"/>
</function>
<function name="ProgramLocalParameter4fvARB" offset="675">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="params" type="const GLfloat *" count="4"/>
- <glx rop="4215" ignore="true"/>
+ <glx rop="4215"/>
</function>
- <!-- FIXME: This should alias to GetProgramParameter*NV -->
+ <!-- The GetProgramEnvParameter[df]vARB are handcoded because there
+ is an extra CARD32 of padding after the "index" field. Originally,
+ GetProgranEnvParameter[df]vARB and GetProgramParameter[df]vNV
+ shared the same GLX protocol. The pad field was where the pname
+ parameter was in the NV functions. When this error was discovered
+ and fixed, there was already at least one implementation of
+ GLX protocol for ARB_vertex_program, but there were no
+ implementations of NV_vertex_program. The sollution was to renumber
+ the opcodes for NV_vertex_program and convert the unused field in
+ the ARB_vertex_program protocol to unused padding.
+ -->
+
<function name="GetProgramEnvParameterdvARB" offset="676">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="params" type="GLdouble *" output="true"/>
- <glx vendorpriv="1297" doubles_in_order="true" ignore="true"/>
+ <glx vendorpriv="1297" handcode="true" doubles_in_order="true"/>
</function>
- <!-- FIXME: This should alias to GetProgramParameter*NV -->
<function name="GetProgramEnvParameterfvARB" offset="677">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="params" type="GLfloat *" output="true"/>
- <glx vendorpriv="1296" ignore="true"/>
+ <glx vendorpriv="1296" handcode="true"/>
</function>
<function name="GetProgramLocalParameterdvARB" offset="678">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="params" type="GLdouble *" output="true"/>
- <glx vendorpriv="1306" doubles_in_order="true" ignore="true"/>
+ <glx vendorpriv="1306" handcode="true" doubles_in_order="true"/>
</function>
<function name="GetProgramLocalParameterfvARB" offset="679">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="params" type="GLfloat *" output="true"/>
- <glx vendorpriv="1305" ignore="true"/>
+ <glx vendorpriv="1305" handcode="true"/>
</function>
+
<function name="GetProgramivARB" offset="680">
<param name="target" type="GLenum"/>
<param name="pname" type="GLenum"/>
- <param name="params" type="GLint *" output="true"/>
- <glx vendorpriv="1307" ignore="true"/>
+ <param name="params" type="GLint *" output="true" varaible_param="pname"/>
+ <glx vendorpriv="1307"/>
</function>
<function name="GetProgramStringARB" offset="681">
<param name="target" type="GLenum"/>
<param name="pname" type="GLenum"/>
<param name="string" type="GLvoid *" output="true"/>
- <glx vendorpriv="1308" handcode="true" ignore="true"/>
+ <glx vendorpriv="1308" handcode="server" always_array="true"/>
</function>
<function name="GetVertexAttribPointervARB" alias="GetVertexAttribPointervNV">
</category>
<category name="GL_NV_vertex_program" number="233">
+ <enum name="VERTEX_PROGRAM_NV" value="0x8620"/>
+ <enum name="VERTEX_STATE_PROGRAM_NV" value="0x8621"/>
+ <enum name="ATTRIB_ARRAY_SIZE_NV" count="1" value="0x8623">
+ <size name="GetVertexAttribdvNV" mode="get"/>
+ <size name="GetVertexAttribfvNV" mode="get"/>
+ <size name="GetVertexAttribivNV" mode="get"/>
+ </enum>
+ <enum name="ATTRIB_ARRAY_STRIDE_NV" count="1" value="0x8624">
+ <size name="GetVertexAttribdvNV" mode="get"/>
+ <size name="GetVertexAttribfvNV" mode="get"/>
+ <size name="GetVertexAttribivNV" mode="get"/>
+ </enum>
+ <enum name="ATTRIB_ARRAY_TYPE_NV" count="1" value="0x8625">
+ <size name="GetVertexAttribdvNV" mode="get"/>
+ <size name="GetVertexAttribfvNV" mode="get"/>
+ <size name="GetVertexAttribivNV" mode="get"/>
+ </enum>
+ <enum name="CURRENT_ATTRIB_NV" count="1" value="0x8626">
+ <size name="GetVertexAttribdvNV" mode="get"/>
+ <size name="GetVertexAttribfvNV" mode="get"/>
+ <size name="GetVertexAttribivNV" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_LENGTH_NV" count="1" value="0x8627">
+ <size name="GetProgramivNV" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_STRING_NV" value="0x8628"/>
+ <enum name="MODELVIEW_PROJECTION_NV" value="0x8629"/>
+ <enum name="IDENTITY_NV" value="0x862A"/>
+ <enum name="INVERSE_NV" value="0x862B"/>
+ <enum name="TRANSPOSE_NV" value="0x862C"/>
+ <enum name="INVERSE_TRANSPOSE_NV" value="0x862D"/>
+ <enum name="MAX_TRACK_MATRIX_STACK_DEPTH_NV" value="0x862E"/>
+ <enum name="MAX_TRACK_MATRICES_NV" value="0x862F"/>
+ <enum name="MATRIX0_NV" value="0x8630"/>
+ <enum name="MATRIX1_NV" value="0x8631"/>
+ <enum name="MATRIX2_NV" value="0x8632"/>
+ <enum name="MATRIX3_NV" value="0x8633"/>
+ <enum name="MATRIX4_NV" value="0x8634"/>
+ <enum name="MATRIX5_NV" value="0x8635"/>
+ <enum name="MATRIX6_NV" value="0x8636"/>
+ <enum name="MATRIX7_NV" value="0x8637"/>
+ <enum name="CURRENT_MATRIX_STACK_DEPTH_NV" value="0x8640"/>
+ <enum name="CURRENT_MATRIX_NV" value="0x8641"/>
+ <enum name="VERTEX_PROGRAM_POINT_SIZE_NV" value="0x8642"/>
+ <enum name="VERTEX_PROGRAM_TWO_SIDE_NV" value="0x8643"/>
+ <enum name="PROGRAM_PARAMETER_NV" value="0x8644"/>
+ <enum name="ATTRIB_ARRAY_POINTER_NV" value="0x8645"/>
+ <enum name="PROGRAM_TARGET_NV" count="1" value="0x8646">
+ <size name="GetProgramivNV" mode="get"/>
+ </enum>
+ <enum name="PROGRAM_RESIDENT_NV" count="1" value="0x8647">
+ <size name="GetProgramivNV" mode="get"/>
+ </enum>
+ <enum name="TRACK_MATRIX_NV" value="0x8648"/>
+ <enum name="TRACK_MATRIX_TRANSFORM_NV" value="0x8649"/>
+ <enum name="VERTEX_PROGRAM_BINDING_NV" value="0x864A"/>
+ <enum name="PROGRAM_ERROR_POSITION_NV" value="0x864B"/>
+ <enum name="VERTEX_ATTRIB_ARRAY0_NV" value="0x8650"/>
+ <enum name="VERTEX_ATTRIB_ARRAY1_NV" value="0x8651"/>
+ <enum name="VERTEX_ATTRIB_ARRAY2_NV" value="0x8652"/>
+ <enum name="VERTEX_ATTRIB_ARRAY3_NV" value="0x8653"/>
+ <enum name="VERTEX_ATTRIB_ARRAY4_NV" value="0x8654"/>
+ <enum name="VERTEX_ATTRIB_ARRAY5_NV" value="0x8655"/>
+ <enum name="VERTEX_ATTRIB_ARRAY6_NV" value="0x8656"/>
+ <enum name="VERTEX_ATTRIB_ARRAY7_NV" value="0x8657"/>
+ <enum name="VERTEX_ATTRIB_ARRAY8_NV" value="0x8658"/>
+ <enum name="VERTEX_ATTRIB_ARRAY9_NV" value="0x8659"/>
+ <enum name="VERTEX_ATTRIB_ARRAY10_NV" value="0x865A"/>
+ <enum name="VERTEX_ATTRIB_ARRAY11_NV" value="0x865B"/>
+ <enum name="VERTEX_ATTRIB_ARRAY12_NV" value="0x865C"/>
+ <enum name="VERTEX_ATTRIB_ARRAY13_NV" value="0x865D"/>
+ <enum name="VERTEX_ATTRIB_ARRAY14_NV" value="0x865E"/>
+ <enum name="VERTEX_ATTRIB_ARRAY15_NV" value="0x865F"/>
+ <enum name="MAP1_VERTEX_ATTRIB0_4_NV" value="0x8660"/>
+ <enum name="MAP1_VERTEX_ATTRIB1_4_NV" value="0x8661"/>
+ <enum name="MAP1_VERTEX_ATTRIB2_4_NV" value="0x8662"/>
+ <enum name="MAP1_VERTEX_ATTRIB3_4_NV" value="0x8663"/>
+ <enum name="MAP1_VERTEX_ATTRIB4_4_NV" value="0x8664"/>
+ <enum name="MAP1_VERTEX_ATTRIB5_4_NV" value="0x8665"/>
+ <enum name="MAP1_VERTEX_ATTRIB6_4_NV" value="0x8666"/>
+ <enum name="MAP1_VERTEX_ATTRIB7_4_NV" value="0x8667"/>
+ <enum name="MAP1_VERTEX_ATTRIB8_4_NV" value="0x8668"/>
+ <enum name="MAP1_VERTEX_ATTRIB9_4_NV" value="0x8669"/>
+ <enum name="MAP1_VERTEX_ATTRIB10_4_NV" value="0x866A"/>
+ <enum name="MAP1_VERTEX_ATTRIB11_4_NV" value="0x866B"/>
+ <enum name="MAP1_VERTEX_ATTRIB12_4_NV" value="0x866C"/>
+ <enum name="MAP1_VERTEX_ATTRIB13_4_NV" value="0x866D"/>
+ <enum name="MAP1_VERTEX_ATTRIB14_4_NV" value="0x866E"/>
+ <enum name="MAP1_VERTEX_ATTRIB15_4_NV" value="0x866F"/>
+ <enum name="MAP2_VERTEX_ATTRIB0_4_NV" value="0x8670"/>
+ <enum name="MAP2_VERTEX_ATTRIB1_4_NV" value="0x8671"/>
+ <enum name="MAP2_VERTEX_ATTRIB2_4_NV" value="0x8672"/>
+ <enum name="MAP2_VERTEX_ATTRIB3_4_NV" value="0x8673"/>
+ <enum name="MAP2_VERTEX_ATTRIB4_4_NV" value="0x8674"/>
+ <enum name="MAP2_VERTEX_ATTRIB5_4_NV" value="0x8675"/>
+ <enum name="MAP2_VERTEX_ATTRIB6_4_NV" value="0x8676"/>
+ <enum name="MAP2_VERTEX_ATTRIB7_4_NV" value="0x8677"/>
+ <enum name="MAP2_VERTEX_ATTRIB8_4_NV" value="0x8678"/>
+ <enum name="MAP2_VERTEX_ATTRIB9_4_NV" value="0x8679"/>
+ <enum name="MAP2_VERTEX_ATTRIB10_4_NV" value="0x867A"/>
+ <enum name="MAP2_VERTEX_ATTRIB11_4_NV" value="0x867B"/>
+ <enum name="MAP2_VERTEX_ATTRIB12_4_NV" value="0x867C"/>
+ <enum name="MAP2_VERTEX_ATTRIB13_4_NV" value="0x867D"/>
+ <enum name="MAP2_VERTEX_ATTRIB14_4_NV" value="0x867E"/>
+ <enum name="MAP2_VERTEX_ATTRIB15_4_NV" value="0x867F"/>
+
<function name="AreProgramsResidentNV" offset="578">
<param name="n" type="GLsizei" counter="true"/>
<param name="ids" type="const GLuint *" count="n"/>
<param name="residences" type="GLboolean *" output="true"/>
<return type="GLboolean"/>
- <glx vendorpriv="1293" ignore="true"/>
+ <glx vendorpriv="1293"/>
</function>
<function name="BindProgramNV" offset="579">
<param name="target" type="GLenum"/>
<param name="id" type="GLuint"/>
- <glx rop="4108" ignore="true"/>
+ <glx rop="4180"/>
</function>
<function name="DeleteProgramsNV" offset="580">
<param name="n" type="GLsizei" counter="true"/>
<param name="ids" type="const GLuint *" count="n"/>
- <glx vendorpriv="1294" ignore="true"/>
+ <glx vendorpriv="1294"/>
</function>
<function name="ExecuteProgramNV" offset="581">
<param name="target" type="GLenum"/>
<param name="id" type="GLuint"/>
- <param name="params" type="const GLfloat *" variable_param="target"/>
- <glx rop="4181" ignore="true"/>
+ <param name="params" type="const GLfloat *" count="4"/>
+ <glx rop="4181"/>
</function>
<function name="GenProgramsNV" offset="582">
<param name="n" type="GLsizei" counter="true"/>
- <param name="ids" type="GLuint *" output="true" counter="n"/>
- <glx vendorpriv="1295" ignore="true"/>
+ <param name="ids" type="GLuint *" output="true" count="n"/>
+ <glx vendorpriv="1295"/>
</function>
+ <!-- This isn't 100% correct. Currently, the only valid value of pname
+ is GL_PROGRAM_PARAMETER_NV, and the count for that pname is always
+ 4. This is why the pname parameter was removed in the ARB version
+ of these functions.
+ -->
+
<function name="GetProgramParameterdvNV" offset="583">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="pname" type="GLenum"/>
- <param name="params" type="GLdouble *" output="true"/>
- <glx vendorpriv="1297" ignore="true"/>
+ <param name="params" type="GLdouble *" output="true" count="4"/>
+ <glx vendorpriv="1297"/>
</function>
<function name="GetProgramParameterfvNV" offset="584">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="pname" type="GLenum"/>
- <param name="params" type="GLfloat *" output="true"/>
- <glx vendorpriv="1296" ignore="true"/>
+ <param name="params" type="GLfloat *" output="true" count="4"/>
+ <glx vendorpriv="1296"/>
</function>
<function name="GetProgramivNV" offset="585">
<param name="id" type="GLuint"/>
<param name="pname" type="GLenum"/>
- <param name="params" type="GLint *" output="true"/>
- <glx vendorpriv="1307" ignore="true"/>
+ <param name="params" type="GLint *" output="true" variable_param="pname"/>
+ <glx vendorpriv="1298"/>
</function>
<function name="GetProgramStringNV" offset="586">
<param name="id" type="GLuint"/>
<param name="pname" type="GLenum"/>
<param name="program" type="GLubyte *" output="true"/>
- <glx vendorpriv="1308" handcode="true" ignore="true"/>
+ <glx vendorpriv="1299" handcode="server" always_array="true"/>
</function>
<function name="GetTrackMatrixivNV" offset="587">
<param name="target" type="GLenum"/>
<param name="address" type="GLuint"/>
<param name="pname" type="GLenum"/>
- <param name="params" type="GLint *" output="true"/>
- <glx vendorpriv="1300" ignore="true"/>
+ <param name="params" type="GLint *" output="true" count="1"/>
+ <glx vendorpriv="1300"/>
</function>
<function name="GetVertexAttribdvNV" offset="753">
<param name="index" type="GLuint"/>
<param name="pname" type="GLenum"/>
- <param name="params" type="GLdouble *" output="true"/>
- <glx vendorpriv="1301" ignore="true"/>
+ <param name="params" type="GLdouble *" output="true" variable_param="pname"/>
+ <glx vendorpriv="1301"/>
</function>
<function name="GetVertexAttribfvNV" offset="754">
<param name="index" type="GLuint"/>
<param name="pname" type="GLenum"/>
- <param name="params" type="GLfloat *" output="true"/>
- <glx vendorpriv="1302" ignore="true"/>
+ <param name="params" type="GLfloat *" output="true" variable_param="pname"/>
+ <glx vendorpriv="1302"/>
</function>
<function name="GetVertexAttribivNV" offset="755">
<param name="index" type="GLuint"/>
<param name="pname" type="GLenum"/>
<param name="params" type="GLint *" output="true"/>
- <glx vendorpriv="1303" ignore="true"/>
+ <glx vendorpriv="1303"/>
</function>
<function name="GetVertexAttribPointervNV" offset="591">
<param name="index" type="GLuint"/>
<param name="pname" type="GLenum"/>
<param name="pointer" type="GLvoid **" output="true"/>
- <glx handcode="true" ignore="true"/>
+ <glx handcode="true"/>
</function>
<function name="IsProgramNV" offset="592">
<param name="id" type="GLuint"/>
<return type="GLboolean"/>
- <glx vendorpriv="1304" ignore="true"/>
+ <glx vendorpriv="1304"/>
</function>
<function name="LoadProgramNV" offset="593">
<param name="id" type="GLuint"/>
<param name="len" type="GLsizei" counter="true"/>
<param name="program" type="const GLubyte *" count="len"/>
- <glx rop="4183" ignore="true"/>
+ <glx rop="4183"/>
</function>
<function name="ProgramParameter4dNV" offset="594" vectorequiv="ProgramParameter4dvNV">
<param name="y" type="GLdouble"/>
<param name="z" type="GLdouble"/>
<param name="w" type="GLdouble"/>
- <glx ignore="true"/>
</function>
<function name="ProgramParameter4dvNV" offset="595">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="params" type="const GLdouble *" count="4"/>
- <glx rop="4185" doubles_in_order="true" ignore="true"/>
+ <glx rop="4185" doubles_in_order="true"/>
</function>
<function name="ProgramParameter4fNV" offset="596" vectorequiv="ProgramParameter4fvNV">
<param name="y" type="GLfloat"/>
<param name="z" type="GLfloat"/>
<param name="w" type="GLfloat"/>
- <glx ignore="true"/>
</function>
<function name="ProgramParameter4fvNV" offset="597">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="params" type="const GLfloat *" count="4"/>
- <glx rop="4184" ignore="true"/>
+ <glx rop="4184"/>
</function>
<function name="ProgramParameters4dvNV" offset="598">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="num" type="GLuint"/>
- <param name="params" type="const GLdouble *"/>
-
- <!-- This is hand coded because the number of array elements
- pointed to by 'params' is 4*num.
- -->
- <glx rop="4187" handcode="true" ignore="true"/>
+ <param name="params" type="const GLdouble *" count="num" count_scale="4"/>
+ <glx rop="4187"/>
</function>
<function name="ProgramParameters4fvNV" offset="599">
<param name="target" type="GLenum"/>
<param name="index" type="GLuint"/>
<param name="num" type="GLuint" counter="true"/>
- <param name="params" type="const GLfloat *" count="num"/>
-
- <!-- This is hand coded because the number of array elements
- pointed to by 'params' is 4*num.
- -->
- <glx rop="4186" handcode="true" ignore="true"/>
+ <param name="params" type="const GLfloat *" count="num" count_scale="4"/>
+ <glx rop="4186"/>
</function>
<function name="RequestResidentProgramsNV" offset="600">
- <param name="n" type="GLsizei"/>
- <param name="ids" type="const GLuint *"/>
- <glx rop="4182" handcode="true" ignore="true"/>
+ <param name="n" type="GLsizei" counter="true"/>
+ <param name="ids" type="const GLuint *" count="n"/>
+ <glx rop="4182"/>
</function>
<function name="TrackMatrixNV" offset="601">
<param name="address" type="GLuint"/>
<param name="matrix" type="GLenum"/>
<param name="transform" type="GLenum"/>
- <glx rop="4188" ignore="true"/>
+ <glx rop="4188"/>
</function>
<function name="VertexAttribPointerNV" offset="602">
<param name="type" type="GLenum"/>
<param name="stride" type="GLsizei"/>
<param name="pointer" type="const GLvoid *"/>
- <glx handcode="true" ignore="true"/>
+ <glx handcode="true"/>
</function>
- <function name="VertexAttrib1dNV" offset="756" vectorequiv="VertexAttrib1dvNV">
+ <function name="VertexAttrib1sNV" offset="760" vectorequiv="VertexAttrib1svNV">
<param name="index" type="GLuint"/>
- <param name="x" type="GLdouble"/>
- <glx ignore="true"/>
+ <param name="x" type="GLshort"/>
</function>
- <function name="VertexAttrib1dvNV" offset="757">
+ <function name="VertexAttrib1svNV" offset="761">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLdouble *" count="1"/>
- <glx rop="4197" doubles_in_order="true" ignore="true"/>
+ <param name="v" type="const GLshort *" count="1"/>
+ <glx rop="4189"/>
</function>
- <function name="VertexAttrib1fNV" offset="758" vectorequiv="VertexAttrib1fvNV">
+ <function name="VertexAttrib2sNV" offset="766" vectorequiv="VertexAttrib2svNV">
<param name="index" type="GLuint"/>
- <param name="x" type="GLfloat"/>
- <glx ignore="true"/>
+ <param name="x" type="GLshort"/>
+ <param name="y" type="GLshort"/>
</function>
- <function name="VertexAttrib1fvNV" offset="759">
+ <function name="VertexAttrib2svNV" offset="767">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLfloat *" count="1"/>
- <glx rop="4193" ignore="true"/>
+ <param name="v" type="const GLshort *" count="2"/>
+ <glx rop="4190"/>
</function>
- <function name="VertexAttrib1sNV" offset="760" vectorequiv="VertexAttrib1svNV">
+ <function name="VertexAttrib3sNV" offset="772" vectorequiv="VertexAttrib3svNV">
<param name="index" type="GLuint"/>
<param name="x" type="GLshort"/>
- <glx ignore="true"/>
+ <param name="y" type="GLshort"/>
+ <param name="z" type="GLshort"/>
</function>
- <function name="VertexAttrib1svNV" offset="761">
+ <function name="VertexAttrib3svNV" offset="773">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLshort *" count="1"/>
- <glx rop="4189" ignore="true"/>
+ <param name="v" type="const GLshort *" count="3"/>
+ <glx rop="4191"/>
</function>
- <function name="VertexAttrib2dNV" offset="762" vectorequiv="VertexAttrib2dvNV">
+ <function name="VertexAttrib4sNV" offset="778" vectorequiv="VertexAttrib4svNV">
<param name="index" type="GLuint"/>
- <param name="x" type="GLdouble"/>
- <param name="y" type="GLdouble"/>
- <glx ignore="true"/>
+ <param name="x" type="GLshort"/>
+ <param name="y" type="GLshort"/>
+ <param name="z" type="GLshort"/>
+ <param name="w" type="GLshort"/>
</function>
- <function name="VertexAttrib2dvNV" offset="763">
+ <function name="VertexAttrib4svNV" offset="779">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLdouble *" count="2"/>
- <glx rop="4198" doubles_in_order="true" ignore="true"/>
+ <param name="v" type="const GLshort *" count="4"/>
+ <glx rop="4192"/>
</function>
- <function name="VertexAttrib2fNV" offset="764" vectorequiv="VertexAttrib2fvNV">
+ <function name="VertexAttrib1fNV" offset="758" vectorequiv="VertexAttrib1fvNV">
<param name="index" type="GLuint"/>
<param name="x" type="GLfloat"/>
- <param name="y" type="GLfloat"/>
- <glx ignore="true"/>
</function>
- <function name="VertexAttrib2fvNV" offset="765">
+ <function name="VertexAttrib1fvNV" offset="759">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLfloat *" count="2"/>
- <glx rop="4194" ignore="true"/>
+ <param name="v" type="const GLfloat *" count="1"/>
+ <glx rop="4193"/>
</function>
- <function name="VertexAttrib2sNV" offset="766" vectorequiv="VertexAttrib2svNV">
+ <function name="VertexAttrib2fNV" offset="764" vectorequiv="VertexAttrib2fvNV">
<param name="index" type="GLuint"/>
- <param name="x" type="GLshort"/>
- <param name="y" type="GLshort"/>
- <glx ignore="true"/>
+ <param name="x" type="GLfloat"/>
+ <param name="y" type="GLfloat"/>
</function>
- <function name="VertexAttrib2svNV" offset="767">
+ <function name="VertexAttrib2fvNV" offset="765">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLshort *" count="2"/>
- <glx rop="4190" ignore="true"/>
+ <param name="v" type="const GLfloat *" count="2"/>
+ <glx rop="4194"/>
</function>
- <function name="VertexAttrib3dNV" offset="768" vectorequiv="VertexAttrib3dvNV">
+ <function name="VertexAttrib3fNV" offset="770" vectorequiv="VertexAttrib3fvNV">
<param name="index" type="GLuint"/>
- <param name="x" type="GLdouble"/>
- <param name="y" type="GLdouble"/>
- <param name="z" type="GLdouble"/>
- <glx ignore="true"/>
+ <param name="x" type="GLfloat"/>
+ <param name="y" type="GLfloat"/>
+ <param name="z" type="GLfloat"/>
</function>
- <function name="VertexAttrib3dvNV" offset="769">
+ <function name="VertexAttrib3fvNV" offset="771">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLdouble *" count="3"/>
- <glx rop="4199" doubles_in_order="true" ignore="true"/>
+ <param name="v" type="const GLfloat *" count="3"/>
+ <glx rop="4195"/>
</function>
- <function name="VertexAttrib3fNV" offset="770" vectorequiv="VertexAttrib3fvNV">
+ <function name="VertexAttrib4fNV" offset="776" vectorequiv="VertexAttrib4fvNV">
<param name="index" type="GLuint"/>
<param name="x" type="GLfloat"/>
<param name="y" type="GLfloat"/>
<param name="z" type="GLfloat"/>
- <glx ignore="true"/>
+ <param name="w" type="GLfloat"/>
</function>
- <function name="VertexAttrib3fvNV" offset="771">
+ <function name="VertexAttrib4fvNV" offset="777">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLfloat *" count="3"/>
- <glx rop="4195" ignore="true"/>
+ <param name="v" type="const GLfloat *" count="4"/>
+ <glx rop="4196"/>
</function>
- <function name="VertexAttrib3sNV" offset="772" vectorequiv="VertexAttrib3svNV">
+ <function name="VertexAttrib1dNV" offset="756" vectorequiv="VertexAttrib1dvNV">
<param name="index" type="GLuint"/>
- <param name="x" type="GLshort"/>
- <param name="y" type="GLshort"/>
- <param name="z" type="GLshort"/>
- <glx ignore="true"/>
+ <param name="x" type="GLdouble"/>
</function>
- <function name="VertexAttrib3svNV" offset="773">
+ <function name="VertexAttrib1dvNV" offset="757">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLshort *" count="3"/>
- <glx rop="4191" ignore="true"/>
+ <param name="v" type="const GLdouble *" count="1"/>
+ <glx rop="4197" doubles_in_order="true"/>
</function>
- <function name="VertexAttrib4dNV" offset="774" vectorequiv="VertexAttrib4dvNV">
+ <function name="VertexAttrib2dNV" offset="762" vectorequiv="VertexAttrib2dvNV">
<param name="index" type="GLuint"/>
<param name="x" type="GLdouble"/>
<param name="y" type="GLdouble"/>
- <param name="z" type="GLdouble"/>
- <param name="w" type="GLdouble"/>
- <glx ignore="true"/>
</function>
- <function name="VertexAttrib4dvNV" offset="775">
+ <function name="VertexAttrib2dvNV" offset="763">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLdouble *" count="4"/>
- <glx rop="4200" doubles_in_order="true" ignore="true"/>
+ <param name="v" type="const GLdouble *" count="2"/>
+ <glx rop="4198" doubles_in_order="true"/>
</function>
- <function name="VertexAttrib4fNV" offset="776" vectorequiv="VertexAttrib4fvNV">
+ <function name="VertexAttrib3dNV" offset="768" vectorequiv="VertexAttrib3dvNV">
<param name="index" type="GLuint"/>
- <param name="x" type="GLfloat"/>
- <param name="y" type="GLfloat"/>
- <param name="z" type="GLfloat"/>
- <param name="w" type="GLfloat"/>
- <glx ignore="true"/>
+ <param name="x" type="GLdouble"/>
+ <param name="y" type="GLdouble"/>
+ <param name="z" type="GLdouble"/>
</function>
- <function name="VertexAttrib4fvNV" offset="777">
+ <function name="VertexAttrib3dvNV" offset="769">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLfloat *" count="4"/>
- <glx rop="4196" ignore="true"/>
+ <param name="v" type="const GLdouble *" count="3"/>
+ <glx rop="4199" doubles_in_order="true"/>
</function>
- <function name="VertexAttrib4sNV" offset="778" vectorequiv="VertexAttrib4svNV">
+ <function name="VertexAttrib4dNV" offset="774" vectorequiv="VertexAttrib4dvNV">
<param name="index" type="GLuint"/>
- <param name="x" type="GLshort"/>
- <param name="y" type="GLshort"/>
- <param name="z" type="GLshort"/>
- <param name="w" type="GLshort"/>
- <glx ignore="true"/>
+ <param name="x" type="GLdouble"/>
+ <param name="y" type="GLdouble"/>
+ <param name="z" type="GLdouble"/>
+ <param name="w" type="GLdouble"/>
</function>
- <function name="VertexAttrib4svNV" offset="779">
+ <function name="VertexAttrib4dvNV" offset="775">
<param name="index" type="GLuint"/>
- <param name="v" type="const GLshort *" count="4"/>
- <glx rop="4192" ignore="true"/>
+ <param name="v" type="const GLdouble *" count="4"/>
+ <glx rop="4200" doubles_in_order="true"/>
</function>
<function name="VertexAttrib4ubNV" offset="780" vectorequiv="VertexAttrib4ubvNV">
<param name="y" type="GLubyte"/>
<param name="z" type="GLubyte"/>
<param name="w" type="GLubyte"/>
- <glx ignore="true"/>
</function>
<function name="VertexAttrib4ubvNV" offset="781">
<param name="index" type="GLuint"/>
<param name="v" type="const GLubyte *" count="4"/>
- <glx rop="4201" ignore="true"/>
- </function>
-
- <function name="VertexAttribs1dvNV" offset="629">
- <param name="index" type="GLuint"/>
- <param name="n" type="GLsizei" counter="true"/>
- <param name="v" type="const GLdouble *" count="n"/>
- <glx rop="4210" doubles_in_order="true" ignore="true"/>
- </function>
-
- <function name="VertexAttribs1fvNV" offset="630">
- <param name="index" type="GLuint"/>
- <param name="n" type="GLsizei" counter="true"/>
- <param name="v" type="const GLfloat *" count="n"/>
- <glx rop="4206" ignore="true"/>
+ <glx rop="4201"/>
</function>
<function name="VertexAttribs1svNV" offset="631">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei" counter="true"/>
<param name="v" type="const GLshort *" count="n"/>
- <glx rop="4202" ignore="true"/>
+ <glx rop="4202"/>
</function>
- <function name="VertexAttribs2dvNV" offset="632">
+ <function name="VertexAttribs2svNV" offset="634">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei"/>
- <param name="v" type="const GLdouble *"/>
-
- <!-- This is hand coded because the number of array elements
- pointed to by 'v' is 2*n.
- -->
- <glx rop="4211" handcode="true" ignore="true"/>
+ <param name="v" type="const GLshort *" count="n" count_scale="2"/>
+ <glx rop="4203"/>
</function>
- <function name="VertexAttribs2fvNV" offset="633">
+ <function name="VertexAttribs3svNV" offset="637">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei"/>
- <param name="v" type="const GLfloat *"/>
-
- <!-- This is hand coded because the number of array elements
- pointed to by 'v' is 2*n.
- -->
- <glx rop="4207" handcode="true" ignore="true"/>
+ <param name="v" type="const GLshort *" count="n" count_scale="3"/>
+ <glx rop="4204"/>
</function>
- <function name="VertexAttribs2svNV" offset="634">
+ <function name="VertexAttribs4svNV" offset="640">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei"/>
- <param name="v" type="const GLshort *"/>
- <glx rop="4203" handcode="true" ignore="true"/>
+ <param name="v" type="const GLshort *" count="n" count_scale="4"/>
+ <glx rop="4205"/>
+ </function>
- <!-- This is hand coded because the number of array elements
- pointed to by 'v' is 2*n.
- -->
+ <function name="VertexAttribs1fvNV" offset="630">
+ <param name="index" type="GLuint"/>
+ <param name="n" type="GLsizei" counter="true"/>
+ <param name="v" type="const GLfloat *" count="n"/>
+ <glx rop="4206"/>
</function>
- <function name="VertexAttribs3dvNV" offset="635">
+ <function name="VertexAttribs2fvNV" offset="633">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei"/>
- <param name="v" type="const GLdouble *"/>
-
- <!-- This is hand coded because the number of array elements
- pointed to by 'v' is 3*n.
- -->
- <glx rop="4212" handcode="true" ignore="true"/>
+ <param name="v" type="const GLfloat *" count="n" count_scale="2"/>
+ <glx rop="4207"/>
</function>
<function name="VertexAttribs3fvNV" offset="636">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei"/>
- <param name="v" type="const GLfloat *"/>
-
- <!-- This is hand coded because the number of array elements
- pointed to by 'v' is 3*n.
- -->
- <glx rop="4208" handcode="true" ignore="true"/>
+ <param name="v" type="const GLfloat *" count="n" count_scale="3"/>
+ <glx rop="4208"/>
</function>
- <function name="VertexAttribs3svNV" offset="637">
+ <function name="VertexAttribs4fvNV" offset="639">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei"/>
- <param name="v" type="const GLshort *"/>
+ <param name="v" type="const GLfloat *" count="n" count_scale="4"/>
+ <glx rop="4209"/>
+ </function>
- <!-- This is hand coded because the number of array elements
- pointed to by 'v' is 3*n.
- -->
- <glx rop="4204" handcode="true" ignore="true"/>
+ <function name="VertexAttribs1dvNV" offset="629">
+ <param name="index" type="GLuint"/>
+ <param name="n" type="GLsizei" counter="true"/>
+ <param name="v" type="const GLdouble *" count="n"/>
+ <glx rop="4210" doubles_in_order="true"/>
</function>
- <function name="VertexAttribs4dvNV" offset="638">
+ <function name="VertexAttribs2dvNV" offset="632">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei"/>
- <param name="v" type="const GLdouble *"/>
-
- <!-- This is hand coded because the number of array elements
- pointed to by 'v' is 4*n.
- -->
- <glx rop="4213" handcode="true" ignore="true"/>
+ <param name="v" type="const GLdouble *" doubles_in_order="true" count="n" count_scale="2"/>
+ <glx rop="4211"/>
</function>
- <function name="VertexAttribs4fvNV" offset="639">
+ <function name="VertexAttribs3dvNV" offset="635">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei"/>
- <param name="v" type="const GLfloat *"/>
-
- <!-- This is hand coded because the number of array elements
- pointed to by 'v' is 4*n.
- -->
- <glx rop="4209" handcode="true" ignore="true"/>
+ <param name="v" type="const GLdouble *" doubles_in_order="true" count="n" count_scale="3"/>
+ <glx rop="4212"/>
</function>
- <function name="VertexAttribs4svNV" offset="640">
+ <function name="VertexAttribs4dvNV" offset="638">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei"/>
- <param name="v" type="const GLshort *"/>
-
- <!-- This is hand coded because the number of array elements
- pointed to by 'v' is 4*n.
- -->
- <glx rop="4205" handcode="true" ignore="true"/>
+ <param name="v" type="const GLdouble *" doubles_in_order="true" count="n" count_scale="4"/>
+ <glx rop="4213"/>
</function>
<function name="VertexAttribs4ubvNV" offset="641">
<param name="index" type="GLuint"/>
<param name="n" type="GLsizei"/>
- <param name="v" type="const GLubyte *"/>
-
- <!-- This is hand coded because the number of array elements
- pointed to by 'v' is 4*n.
- -->
- <glx rop="4214" handcode="true" ignore="true"/>
+ <param name="v" type="const GLubyte *" count="n" count_scale="4"/>
+ <glx rop="4214"/>
</function>
</category>
<category name="GL_NV_fragment_program" number="282">
<function name="ProgramNamedParameter4fNV" offset="682" vectorequiv="ProgramNamedParameter4fvNV">
<param name="id" type="GLuint"/>
- <param name="len" type="GLsizei"/>
- <param name="name" type="const GLubyte *"/>
+ <param name="len" type="GLsizei" counter="true"/>
+ <param name="name" type="const GLubyte *" count="len"/>
<param name="x" type="GLfloat"/>
<param name="y" type="GLfloat"/>
<param name="z" type="GLfloat"/>
<param name="w" type="GLfloat"/>
- <glx rop="4218" handcode="true" ignore="true"/>
</function>
<function name="ProgramNamedParameter4dNV" offset="683" vectorequiv="ProgramNamedParameter4dvNV">
<param name="id" type="GLuint"/>
- <param name="len" type="GLsizei"/>
- <param name="name" type="const GLubyte *" variable_param="len"/>
+ <param name="len" type="GLsizei" counter="true"/>
+ <param name="name" type="const GLubyte *" count="len"/>
<param name="x" type="GLdouble"/>
<param name="y" type="GLdouble"/>
<param name="z" type="GLdouble"/>
<param name="w" type="GLdouble"/>
- <glx ignore="true"/>
</function>
<function name="ProgramNamedParameter4fvNV" offset="684">
<param name="id" type="GLuint"/>
- <param name="len" type="GLsizei"/>
- <param name="name" type="const GLubyte *"/>
- <param name="v" type="const GLfloat *"/>
- <glx rop="4218" handcode="true" ignore="true"/>
+ <param name="len" type="GLsizei" counter="true"/>
+ <param name="name" type="const GLubyte *" count="len"/>
+ <param name="v" type="const GLfloat *" count="4"/>
+ <glx rop="4218"/>
</function>
<function name="ProgramNamedParameter4dvNV" offset="685">
<param name="id" type="GLuint"/>
- <param name="len" type="GLsizei"/>
- <param name="name" type="const GLubyte *"/>
- <param name="v" type="const GLdouble *"/>
- <glx rop="4219" handcode="true" ignore="true"/>
+ <param name="len" type="GLsizei" counter="true"/>
+ <param name="name" type="const GLubyte *" count="len"/>
+ <param name="v" type="const GLdouble *" count="4"/>
+ <glx rop="4219"/>
</function>
<function name="GetProgramNamedParameterfvNV" offset="686">
<param name="id" type="GLuint"/>
- <param name="len" type="GLsizei"/>
- <param name="name" type="const GLubyte *"/>
- <param name="params" type="GLfloat *" output="true"/>
- <glx vendorpriv="1310" handcode="true" ignore="true"/>
+ <param name="len" type="GLsizei" counter="true"/>
+ <param name="name" type="const GLubyte *" count="len"/>
+ <param name="params" type="GLfloat *" output="true" count="4"/>
+ <glx vendorpriv="1310" always_array="true"/>
</function>
<function name="GetProgramNamedParameterdvNV" offset="687">
<param name="id" type="GLuint"/>
- <param name="len" type="GLsizei"/>
- <param name="name" type="const GLubyte *"/>
- <param name="params" type="GLdouble *" output="true"/>
- <glx vendorpriv="1311" handcode="true" ignore="true"/>
+ <param name="len" type="GLsizei" counter="true"/>
+ <param name="name" type="const GLubyte *" count="len"/>
+ <param name="params" type="GLdouble *" output="true" count="4"/>
+ <glx vendorpriv="1311" always_array="true"/>
</function>
</category>
<enum name="PIXEL_UNPACK_BUFFER_BINDING_EXT" value="0x88EF"/>
</category>
+<category name="GL_NV_fragment_program_option" number="303">
+ <!-- No new functions, types, enums. -->
+</category>
+
+<category name="GL_NV_fragment_program2" number="304">
+ <enum name="MAX_PROGRAM_EXEC_INSTRUCTIONS_NV" count="1" value="0x88F4">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_CALL_DEPTH_NV" count="1" value="0x88F5">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_IF_DEPTH_NV" count="1" value="0x88F6">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_LOOP_DEPTH_NV" count="1" value="0x88F7">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_LOOP_COUNT_NV" count="1" value="0x88F8">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+</category>
+
+<category name="GL_NV_vertex_program2_option" number="305">
+ <enum name="MAX_PROGRAM_EXEC_INSTRUCTIONS_NV" count="1" value="0x88F4">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+ <enum name="MAX_PROGRAM_CALL_DEPTH_NV" count="1" value="0x88F5">
+ <size name="GetProgramivARB" mode="get"/>
+ </enum>
+</category>
+
+<category name="GL_NV_vertex_program3" number="306">
+ <enum name="MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB" count="1" value="0x8B4C"/>
+</category>
+
<category name="GL_EXT_framebuffer_object" number="310">
<enum name="FRAMEBUFFER_EXT" value="0x8D40"/>
<enum name="RENDERBUFFER_EXT" value="0x8D41"/>
projects / platform / upstream / mesa.git / commitdiff