From b5b8d22c4ee921dff99b898a5907023b20670a27 Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Sat, 27 Nov 2004 20:07:08 +0000 Subject: [PATCH] Change the dispatch offsets for the VertexAttrib*NV functions so they don't alias with the corresponding ARB functions. GL_ARB_vertex_shader (and OpenGL 2.0's) VertexAttrib functions don't alias with conventional vertex attributes, as GL_NV_vertex_program does. So, the ARB and NV version of VertexAttrib need to be distinct. --- src/mesa/array_cache/ac_import.c | 2 +- src/mesa/glapi/gl_API.xml | 242 ++++++------ src/mesa/glapi/glapioffsets.h | 87 +++-- src/mesa/glapi/glapitable.h | 87 +++-- src/mesa/glapi/glapitemp.h | 522 +++++++++++++------------- src/mesa/glapi/glprocs.h | 768 +++++++++++++++++++-------------------- src/mesa/main/api_arrayelt.c | 249 +++++++------ src/mesa/main/api_loopback.c | 267 +++++++++----- src/mesa/main/api_noop.c | 113 +++++- src/mesa/main/api_noop.h | 71 +--- src/mesa/main/dd.h | 10 +- src/mesa/main/dlist.c | 374 +++++++++++++++---- src/mesa/main/state.c | 6 +- src/mesa/main/vtxfmt.c | 10 +- src/mesa/main/vtxfmt_tmp.h | 62 +++- src/mesa/swrast/s_lines.c | 2 +- src/mesa/tnl/t_save_api.c | 81 +++++ src/mesa/tnl/t_save_loopback.c | 40 +- src/mesa/tnl/t_vtx_generic.c | 70 ++++ src/mesa/x86/glapi_x86.S | 116 +++--- 20 files changed, 1929 insertions(+), 1250 deletions(-) diff --git a/src/mesa/array_cache/ac_import.c b/src/mesa/array_cache/ac_import.c index c33a4e3..0c66084 100644 --- a/src/mesa/array_cache/ac_import.c +++ b/src/mesa/array_cache/ac_import.c @@ -461,7 +461,7 @@ import_attrib( GLcontext *ctx, GLuint index, GLenum type, GLuint stride ) struct gl_client_array *to = &ac->Cache.Attrib[index]; (void) type; (void) stride; - ASSERT(index < VERT_ATTRIB_MAX); + ASSERT(index < MAX_VERTEX_PROGRAM_ATTRIBS); /* Limited choices at this stage: */ diff --git a/src/mesa/glapi/gl_API.xml b/src/mesa/glapi/gl_API.xml index 03048c2..c0d3b72 100644 --- a/src/mesa/glapi/gl_API.xml +++ b/src/mesa/glapi/gl_API.xml @@ -4932,135 +4932,173 @@ - + - + + - + - + + + + + + + + - + - + - - + - + - - + + + + + + + + + + + + + + + + - + - - - + - + - - + + + + + + + + + + + + + + + + + - + - - - - + - + - - + - - - - + - + - - - - + + + - + - + - + - + + + + - + - + - + - + + + + - + - + - + - + + + + - + - + - + - + + + + - + - + @@ -5069,11 +5107,6 @@ - - - - - @@ -5098,16 +5131,6 @@ - - - - - - - - - - @@ -5126,11 +5149,6 @@ - - - - - @@ -5293,7 +5311,6 @@ - @@ -5301,7 +5318,6 @@ - @@ -5309,24 +5325,6 @@ - - - - - - - - - - - - - - - - - - @@ -8696,21 +8694,21 @@ - + - + - + @@ -8819,82 +8817,82 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + @@ -8902,13 +8900,13 @@ - + - + @@ -8916,13 +8914,13 @@ - + - + @@ -8930,13 +8928,13 @@ - + - + @@ -8945,13 +8943,13 @@ - + - + @@ -8960,13 +8958,13 @@ - + - + @@ -8975,13 +8973,13 @@ - + - + @@ -8990,7 +8988,7 @@ - + diff --git a/src/mesa/glapi/glapioffsets.h b/src/mesa/glapi/glapioffsets.h index 03f7409..f80c14c 100644 --- a/src/mesa/glapi/glapioffsets.h +++ b/src/mesa/glapi/glapioffsets.h @@ -617,9 +617,9 @@ #define _gloffset_GetProgramivNV 585 #define _gloffset_GetProgramStringNV 586 #define _gloffset_GetTrackMatrixivNV 587 -#define _gloffset_GetVertexAttribdvNV 588 -#define _gloffset_GetVertexAttribfvNV 589 -#define _gloffset_GetVertexAttribivNV 590 +#define _gloffset_GetVertexAttribdvARB 588 +#define _gloffset_GetVertexAttribfvARB 589 +#define _gloffset_GetVertexAttribivARB 590 #define _gloffset_GetVertexAttribPointervNV 591 #define _gloffset_IsProgramNV 592 #define _gloffset_LoadProgramNV 593 @@ -632,32 +632,32 @@ #define _gloffset_RequestResidentProgramsNV 600 #define _gloffset_TrackMatrixNV 601 #define _gloffset_VertexAttribPointerNV 602 -#define _gloffset_VertexAttrib1dNV 603 -#define _gloffset_VertexAttrib1dvNV 604 -#define _gloffset_VertexAttrib1fNV 605 -#define _gloffset_VertexAttrib1fvNV 606 -#define _gloffset_VertexAttrib1sNV 607 -#define _gloffset_VertexAttrib1svNV 608 -#define _gloffset_VertexAttrib2dNV 609 -#define _gloffset_VertexAttrib2dvNV 610 -#define _gloffset_VertexAttrib2fNV 611 -#define _gloffset_VertexAttrib2fvNV 612 -#define _gloffset_VertexAttrib2sNV 613 -#define _gloffset_VertexAttrib2svNV 614 -#define _gloffset_VertexAttrib3dNV 615 -#define _gloffset_VertexAttrib3dvNV 616 -#define _gloffset_VertexAttrib3fNV 617 -#define _gloffset_VertexAttrib3fvNV 618 -#define _gloffset_VertexAttrib3sNV 619 -#define _gloffset_VertexAttrib3svNV 620 -#define _gloffset_VertexAttrib4dNV 621 -#define _gloffset_VertexAttrib4dvNV 622 -#define _gloffset_VertexAttrib4fNV 623 -#define _gloffset_VertexAttrib4fvNV 624 -#define _gloffset_VertexAttrib4sNV 625 -#define _gloffset_VertexAttrib4svNV 626 -#define _gloffset_VertexAttrib4ubNV 627 -#define _gloffset_VertexAttrib4ubvNV 628 +#define _gloffset_VertexAttrib1dARB 603 +#define _gloffset_VertexAttrib1dvARB 604 +#define _gloffset_VertexAttrib1fARB 605 +#define _gloffset_VertexAttrib1fvARB 606 +#define _gloffset_VertexAttrib1sARB 607 +#define _gloffset_VertexAttrib1svARB 608 +#define _gloffset_VertexAttrib2dARB 609 +#define _gloffset_VertexAttrib2dvARB 610 +#define _gloffset_VertexAttrib2fARB 611 +#define _gloffset_VertexAttrib2fvARB 612 +#define _gloffset_VertexAttrib2sARB 613 +#define _gloffset_VertexAttrib2svARB 614 +#define _gloffset_VertexAttrib3dARB 615 +#define _gloffset_VertexAttrib3dvARB 616 +#define _gloffset_VertexAttrib3fARB 617 +#define _gloffset_VertexAttrib3fvARB 618 +#define _gloffset_VertexAttrib3sARB 619 +#define _gloffset_VertexAttrib3svARB 620 +#define _gloffset_VertexAttrib4dARB 621 +#define _gloffset_VertexAttrib4dvARB 622 +#define _gloffset_VertexAttrib4fARB 623 +#define _gloffset_VertexAttrib4fvARB 624 +#define _gloffset_VertexAttrib4sARB 625 +#define _gloffset_VertexAttrib4svARB 626 +#define _gloffset_VertexAttrib4NubARB 627 +#define _gloffset_VertexAttrib4NubvARB 628 #define _gloffset_VertexAttribs1dvNV 629 #define _gloffset_VertexAttribs1fvNV 630 #define _gloffset_VertexAttribs1svNV 631 @@ -782,5 +782,34 @@ #define _gloffset_BindAttribLocationARB 750 #define _gloffset_GetActiveAttribARB 751 #define _gloffset_GetAttribLocationARB 752 +#define _gloffset_GetVertexAttribdvNV 753 +#define _gloffset_GetVertexAttribfvNV 754 +#define _gloffset_GetVertexAttribivNV 755 +#define _gloffset_VertexAttrib1dNV 756 +#define _gloffset_VertexAttrib1dvNV 757 +#define _gloffset_VertexAttrib1fNV 758 +#define _gloffset_VertexAttrib1fvNV 759 +#define _gloffset_VertexAttrib1sNV 760 +#define _gloffset_VertexAttrib1svNV 761 +#define _gloffset_VertexAttrib2dNV 762 +#define _gloffset_VertexAttrib2dvNV 763 +#define _gloffset_VertexAttrib2fNV 764 +#define _gloffset_VertexAttrib2fvNV 765 +#define _gloffset_VertexAttrib2sNV 766 +#define _gloffset_VertexAttrib2svNV 767 +#define _gloffset_VertexAttrib3dNV 768 +#define _gloffset_VertexAttrib3dvNV 769 +#define _gloffset_VertexAttrib3fNV 770 +#define _gloffset_VertexAttrib3fvNV 771 +#define _gloffset_VertexAttrib3sNV 772 +#define _gloffset_VertexAttrib3svNV 773 +#define _gloffset_VertexAttrib4dNV 774 +#define _gloffset_VertexAttrib4dvNV 775 +#define _gloffset_VertexAttrib4fNV 776 +#define _gloffset_VertexAttrib4fvNV 777 +#define _gloffset_VertexAttrib4sNV 778 +#define _gloffset_VertexAttrib4svNV 779 +#define _gloffset_VertexAttrib4ubNV 780 +#define _gloffset_VertexAttrib4ubvNV 781 #endif diff --git a/src/mesa/glapi/glapitable.h b/src/mesa/glapi/glapitable.h index c00d74c..c9ec9ea 100644 --- a/src/mesa/glapi/glapitable.h +++ b/src/mesa/glapi/glapitable.h @@ -623,9 +623,9 @@ struct _glapi_table void (GLAPIENTRYP GetProgramivNV)(GLuint id, GLenum pname, GLint * params); /* 585 */ void (GLAPIENTRYP GetProgramStringNV)(GLuint id, GLenum pname, GLubyte * program); /* 586 */ void (GLAPIENTRYP GetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint * params); /* 587 */ - void (GLAPIENTRYP GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params); /* 588 */ - void (GLAPIENTRYP GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params); /* 589 */ - void (GLAPIENTRYP GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params); /* 590 */ + void (GLAPIENTRYP GetVertexAttribdvARB)(GLuint index, GLenum pname, GLdouble * params); /* 588 */ + void (GLAPIENTRYP GetVertexAttribfvARB)(GLuint index, GLenum pname, GLfloat * params); /* 589 */ + void (GLAPIENTRYP GetVertexAttribivARB)(GLuint index, GLenum pname, GLint * params); /* 590 */ void (GLAPIENTRYP GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer); /* 591 */ GLboolean (GLAPIENTRYP IsProgramNV)(GLuint id); /* 592 */ void (GLAPIENTRYP LoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte * program); /* 593 */ @@ -638,32 +638,32 @@ struct _glapi_table void (GLAPIENTRYP RequestResidentProgramsNV)(GLsizei n, const GLuint * ids); /* 600 */ void (GLAPIENTRYP TrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform); /* 601 */ void (GLAPIENTRYP VertexAttribPointerNV)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 602 */ - void (GLAPIENTRYP VertexAttrib1dNV)(GLuint index, GLdouble x); /* 603 */ - void (GLAPIENTRYP VertexAttrib1dvNV)(GLuint index, const GLdouble * v); /* 604 */ - void (GLAPIENTRYP VertexAttrib1fNV)(GLuint index, GLfloat x); /* 605 */ - void (GLAPIENTRYP VertexAttrib1fvNV)(GLuint index, const GLfloat * v); /* 606 */ - void (GLAPIENTRYP VertexAttrib1sNV)(GLuint index, GLshort x); /* 607 */ - void (GLAPIENTRYP VertexAttrib1svNV)(GLuint index, const GLshort * v); /* 608 */ - void (GLAPIENTRYP VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y); /* 609 */ - void (GLAPIENTRYP VertexAttrib2dvNV)(GLuint index, const GLdouble * v); /* 610 */ - void (GLAPIENTRYP VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y); /* 611 */ - void (GLAPIENTRYP VertexAttrib2fvNV)(GLuint index, const GLfloat * v); /* 612 */ - void (GLAPIENTRYP VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y); /* 613 */ - void (GLAPIENTRYP VertexAttrib2svNV)(GLuint index, const GLshort * v); /* 614 */ - void (GLAPIENTRYP VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 615 */ - void (GLAPIENTRYP VertexAttrib3dvNV)(GLuint index, const GLdouble * v); /* 616 */ - void (GLAPIENTRYP VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 617 */ - void (GLAPIENTRYP VertexAttrib3fvNV)(GLuint index, const GLfloat * v); /* 618 */ - void (GLAPIENTRYP VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z); /* 619 */ - void (GLAPIENTRYP VertexAttrib3svNV)(GLuint index, const GLshort * v); /* 620 */ - void (GLAPIENTRYP VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 621 */ - void (GLAPIENTRYP VertexAttrib4dvNV)(GLuint index, const GLdouble * v); /* 622 */ - void (GLAPIENTRYP VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 623 */ - void (GLAPIENTRYP VertexAttrib4fvNV)(GLuint index, const GLfloat * v); /* 624 */ - void (GLAPIENTRYP VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 625 */ - void (GLAPIENTRYP VertexAttrib4svNV)(GLuint index, const GLshort * v); /* 626 */ - void (GLAPIENTRYP VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 627 */ - void (GLAPIENTRYP VertexAttrib4ubvNV)(GLuint index, const GLubyte * v); /* 628 */ + void (GLAPIENTRYP VertexAttrib1dARB)(GLuint index, GLdouble x); /* 603 */ + void (GLAPIENTRYP VertexAttrib1dvARB)(GLuint index, const GLdouble * v); /* 604 */ + void (GLAPIENTRYP VertexAttrib1fARB)(GLuint index, GLfloat x); /* 605 */ + void (GLAPIENTRYP VertexAttrib1fvARB)(GLuint index, const GLfloat * v); /* 606 */ + void (GLAPIENTRYP VertexAttrib1sARB)(GLuint index, GLshort x); /* 607 */ + void (GLAPIENTRYP VertexAttrib1svARB)(GLuint index, const GLshort * v); /* 608 */ + void (GLAPIENTRYP VertexAttrib2dARB)(GLuint index, GLdouble x, GLdouble y); /* 609 */ + void (GLAPIENTRYP VertexAttrib2dvARB)(GLuint index, const GLdouble * v); /* 610 */ + void (GLAPIENTRYP VertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y); /* 611 */ + void (GLAPIENTRYP VertexAttrib2fvARB)(GLuint index, const GLfloat * v); /* 612 */ + void (GLAPIENTRYP VertexAttrib2sARB)(GLuint index, GLshort x, GLshort y); /* 613 */ + void (GLAPIENTRYP VertexAttrib2svARB)(GLuint index, const GLshort * v); /* 614 */ + void (GLAPIENTRYP VertexAttrib3dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 615 */ + void (GLAPIENTRYP VertexAttrib3dvARB)(GLuint index, const GLdouble * v); /* 616 */ + void (GLAPIENTRYP VertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 617 */ + void (GLAPIENTRYP VertexAttrib3fvARB)(GLuint index, const GLfloat * v); /* 618 */ + void (GLAPIENTRYP VertexAttrib3sARB)(GLuint index, GLshort x, GLshort y, GLshort z); /* 619 */ + void (GLAPIENTRYP VertexAttrib3svARB)(GLuint index, const GLshort * v); /* 620 */ + void (GLAPIENTRYP VertexAttrib4dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 621 */ + void (GLAPIENTRYP VertexAttrib4dvARB)(GLuint index, const GLdouble * v); /* 622 */ + void (GLAPIENTRYP VertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 623 */ + void (GLAPIENTRYP VertexAttrib4fvARB)(GLuint index, const GLfloat * v); /* 624 */ + void (GLAPIENTRYP VertexAttrib4sARB)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 625 */ + void (GLAPIENTRYP VertexAttrib4svARB)(GLuint index, const GLshort * v); /* 626 */ + void (GLAPIENTRYP VertexAttrib4NubARB)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 627 */ + void (GLAPIENTRYP VertexAttrib4NubvARB)(GLuint index, const GLubyte * v); /* 628 */ void (GLAPIENTRYP VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 629 */ void (GLAPIENTRYP VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 630 */ void (GLAPIENTRYP VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort * v); /* 631 */ @@ -788,6 +788,35 @@ struct _glapi_table void (GLAPIENTRYP BindAttribLocationARB)(GLhandleARB programObj, GLuint index, const GLcharARB * name); /* 750 */ void (GLAPIENTRYP GetActiveAttribARB)(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name); /* 751 */ GLint (GLAPIENTRYP GetAttribLocationARB)(GLhandleARB programObj, const GLcharARB * name); /* 752 */ + void (GLAPIENTRYP GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params); /* 753 */ + void (GLAPIENTRYP GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params); /* 754 */ + void (GLAPIENTRYP GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params); /* 755 */ + void (GLAPIENTRYP VertexAttrib1dNV)(GLuint index, GLdouble x); /* 756 */ + void (GLAPIENTRYP VertexAttrib1dvNV)(GLuint index, const GLdouble * v); /* 757 */ + void (GLAPIENTRYP VertexAttrib1fNV)(GLuint index, GLfloat x); /* 758 */ + void (GLAPIENTRYP VertexAttrib1fvNV)(GLuint index, const GLfloat * v); /* 759 */ + void (GLAPIENTRYP VertexAttrib1sNV)(GLuint index, GLshort x); /* 760 */ + void (GLAPIENTRYP VertexAttrib1svNV)(GLuint index, const GLshort * v); /* 761 */ + void (GLAPIENTRYP VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y); /* 762 */ + void (GLAPIENTRYP VertexAttrib2dvNV)(GLuint index, const GLdouble * v); /* 763 */ + void (GLAPIENTRYP VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y); /* 764 */ + void (GLAPIENTRYP VertexAttrib2fvNV)(GLuint index, const GLfloat * v); /* 765 */ + void (GLAPIENTRYP VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y); /* 766 */ + void (GLAPIENTRYP VertexAttrib2svNV)(GLuint index, const GLshort * v); /* 767 */ + void (GLAPIENTRYP VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 768 */ + void (GLAPIENTRYP VertexAttrib3dvNV)(GLuint index, const GLdouble * v); /* 769 */ + void (GLAPIENTRYP VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 770 */ + void (GLAPIENTRYP VertexAttrib3fvNV)(GLuint index, const GLfloat * v); /* 771 */ + void (GLAPIENTRYP VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z); /* 772 */ + void (GLAPIENTRYP VertexAttrib3svNV)(GLuint index, const GLshort * v); /* 773 */ + void (GLAPIENTRYP VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 774 */ + void (GLAPIENTRYP VertexAttrib4dvNV)(GLuint index, const GLdouble * v); /* 775 */ + void (GLAPIENTRYP VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 776 */ + void (GLAPIENTRYP VertexAttrib4fvNV)(GLuint index, const GLfloat * v); /* 777 */ + void (GLAPIENTRYP VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 778 */ + void (GLAPIENTRYP VertexAttrib4svNV)(GLuint index, const GLshort * v); /* 779 */ + void (GLAPIENTRYP VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 780 */ + void (GLAPIENTRYP VertexAttrib4ubvNV)(GLuint index, const GLubyte * v); /* 781 */ }; #endif diff --git a/src/mesa/glapi/glapitemp.h b/src/mesa/glapi/glapitemp.h index 1802ff0..01c1cf8 100644 --- a/src/mesa/glapi/glapitemp.h +++ b/src/mesa/glapi/glapitemp.h @@ -3010,19 +3010,19 @@ KEYWORD1 void KEYWORD2 NAME(GetTrackMatrixivNV)(GLenum target, GLuint address, G DISPATCH(GetTrackMatrixivNV, (target, address, pname, params), (F, "glGetTrackMatrixivNV(0x%x, %d, 0x%x, %p);\n", target, address, pname, (const void *) params)); } -KEYWORD1 void KEYWORD2 NAME(GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params) +KEYWORD1 void KEYWORD2 NAME(GetVertexAttribdvARB)(GLuint index, GLenum pname, GLdouble * params) { - DISPATCH(GetVertexAttribdvNV, (index, pname, params), (F, "glGetVertexAttribdvNV(%d, 0x%x, %p);\n", index, pname, (const void *) params)); + DISPATCH(GetVertexAttribdvARB, (index, pname, params), (F, "glGetVertexAttribdvARB(%d, 0x%x, %p);\n", index, pname, (const void *) params)); } -KEYWORD1 void KEYWORD2 NAME(GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params) +KEYWORD1 void KEYWORD2 NAME(GetVertexAttribfvARB)(GLuint index, GLenum pname, GLfloat * params) { - DISPATCH(GetVertexAttribfvNV, (index, pname, params), (F, "glGetVertexAttribfvNV(%d, 0x%x, %p);\n", index, pname, (const void *) params)); + DISPATCH(GetVertexAttribfvARB, (index, pname, params), (F, "glGetVertexAttribfvARB(%d, 0x%x, %p);\n", index, pname, (const void *) params)); } -KEYWORD1 void KEYWORD2 NAME(GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params) +KEYWORD1 void KEYWORD2 NAME(GetVertexAttribivARB)(GLuint index, GLenum pname, GLint * params) { - DISPATCH(GetVertexAttribivNV, (index, pname, params), (F, "glGetVertexAttribivNV(%d, 0x%x, %p);\n", index, pname, (const void *) params)); + DISPATCH(GetVertexAttribivARB, (index, pname, params), (F, "glGetVertexAttribivARB(%d, 0x%x, %p);\n", index, pname, (const void *) params)); } KEYWORD1 void KEYWORD2 NAME(GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer) @@ -3085,134 +3085,134 @@ KEYWORD1 void KEYWORD2 NAME(VertexAttribPointerNV)(GLuint index, GLint size, GLe DISPATCH(VertexAttribPointerNV, (index, size, type, stride, pointer), (F, "glVertexAttribPointerNV(%d, %d, 0x%x, %d, %p);\n", index, size, type, stride, (const void *) pointer)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1dNV)(GLuint index, GLdouble x) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1dARB)(GLuint index, GLdouble x) { - DISPATCH(VertexAttrib1dNV, (index, x), (F, "glVertexAttrib1dNV(%d, %f);\n", index, x)); + DISPATCH(VertexAttrib1dARB, (index, x), (F, "glVertexAttrib1dARB(%d, %f);\n", index, x)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1dvNV)(GLuint index, const GLdouble * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1dvARB)(GLuint index, const GLdouble * v) { - DISPATCH(VertexAttrib1dvNV, (index, v), (F, "glVertexAttrib1dvNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib1dvARB, (index, v), (F, "glVertexAttrib1dvARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fNV)(GLuint index, GLfloat x) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fARB)(GLuint index, GLfloat x) { - DISPATCH(VertexAttrib1fNV, (index, x), (F, "glVertexAttrib1fNV(%d, %f);\n", index, x)); + DISPATCH(VertexAttrib1fARB, (index, x), (F, "glVertexAttrib1fARB(%d, %f);\n", index, x)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fvNV)(GLuint index, const GLfloat * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fvARB)(GLuint index, const GLfloat * v) { - DISPATCH(VertexAttrib1fvNV, (index, v), (F, "glVertexAttrib1fvNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib1fvARB, (index, v), (F, "glVertexAttrib1fvARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1sNV)(GLuint index, GLshort x) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1sARB)(GLuint index, GLshort x) { - DISPATCH(VertexAttrib1sNV, (index, x), (F, "glVertexAttrib1sNV(%d, %d);\n", index, x)); + DISPATCH(VertexAttrib1sARB, (index, x), (F, "glVertexAttrib1sARB(%d, %d);\n", index, x)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1svNV)(GLuint index, const GLshort * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1svARB)(GLuint index, const GLshort * v) { - DISPATCH(VertexAttrib1svNV, (index, v), (F, "glVertexAttrib1svNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib1svARB, (index, v), (F, "glVertexAttrib1svARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2dARB)(GLuint index, GLdouble x, GLdouble y) { - DISPATCH(VertexAttrib2dNV, (index, x, y), (F, "glVertexAttrib2dNV(%d, %f, %f);\n", index, x, y)); + DISPATCH(VertexAttrib2dARB, (index, x, y), (F, "glVertexAttrib2dARB(%d, %f, %f);\n", index, x, y)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2dvNV)(GLuint index, const GLdouble * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2dvARB)(GLuint index, const GLdouble * v) { - DISPATCH(VertexAttrib2dvNV, (index, v), (F, "glVertexAttrib2dvNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib2dvARB, (index, v), (F, "glVertexAttrib2dvARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y) { - DISPATCH(VertexAttrib2fNV, (index, x, y), (F, "glVertexAttrib2fNV(%d, %f, %f);\n", index, x, y)); + DISPATCH(VertexAttrib2fARB, (index, x, y), (F, "glVertexAttrib2fARB(%d, %f, %f);\n", index, x, y)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fvNV)(GLuint index, const GLfloat * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fvARB)(GLuint index, const GLfloat * v) { - DISPATCH(VertexAttrib2fvNV, (index, v), (F, "glVertexAttrib2fvNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib2fvARB, (index, v), (F, "glVertexAttrib2fvARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2sARB)(GLuint index, GLshort x, GLshort y) { - DISPATCH(VertexAttrib2sNV, (index, x, y), (F, "glVertexAttrib2sNV(%d, %d, %d);\n", index, x, y)); + DISPATCH(VertexAttrib2sARB, (index, x, y), (F, "glVertexAttrib2sARB(%d, %d, %d);\n", index, x, y)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2svNV)(GLuint index, const GLshort * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2svARB)(GLuint index, const GLshort * v) { - DISPATCH(VertexAttrib2svNV, (index, v), (F, "glVertexAttrib2svNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib2svARB, (index, v), (F, "glVertexAttrib2svARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z) { - DISPATCH(VertexAttrib3dNV, (index, x, y, z), (F, "glVertexAttrib3dNV(%d, %f, %f, %f);\n", index, x, y, z)); + DISPATCH(VertexAttrib3dARB, (index, x, y, z), (F, "glVertexAttrib3dARB(%d, %f, %f, %f);\n", index, x, y, z)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3dvNV)(GLuint index, const GLdouble * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3dvARB)(GLuint index, const GLdouble * v) { - DISPATCH(VertexAttrib3dvNV, (index, v), (F, "glVertexAttrib3dvNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib3dvARB, (index, v), (F, "glVertexAttrib3dvARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z) { - DISPATCH(VertexAttrib3fNV, (index, x, y, z), (F, "glVertexAttrib3fNV(%d, %f, %f, %f);\n", index, x, y, z)); + DISPATCH(VertexAttrib3fARB, (index, x, y, z), (F, "glVertexAttrib3fARB(%d, %f, %f, %f);\n", index, x, y, z)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fvNV)(GLuint index, const GLfloat * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fvARB)(GLuint index, const GLfloat * v) { - DISPATCH(VertexAttrib3fvNV, (index, v), (F, "glVertexAttrib3fvNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib3fvARB, (index, v), (F, "glVertexAttrib3fvARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3sARB)(GLuint index, GLshort x, GLshort y, GLshort z) { - DISPATCH(VertexAttrib3sNV, (index, x, y, z), (F, "glVertexAttrib3sNV(%d, %d, %d, %d);\n", index, x, y, z)); + DISPATCH(VertexAttrib3sARB, (index, x, y, z), (F, "glVertexAttrib3sARB(%d, %d, %d, %d);\n", index, x, y, z)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3svNV)(GLuint index, const GLshort * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3svARB)(GLuint index, const GLshort * v) { - DISPATCH(VertexAttrib3svNV, (index, v), (F, "glVertexAttrib3svNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib3svARB, (index, v), (F, "glVertexAttrib3svARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { - DISPATCH(VertexAttrib4dNV, (index, x, y, z, w), (F, "glVertexAttrib4dNV(%d, %f, %f, %f, %f);\n", index, x, y, z, w)); + DISPATCH(VertexAttrib4dARB, (index, x, y, z, w), (F, "glVertexAttrib4dARB(%d, %f, %f, %f, %f);\n", index, x, y, z, w)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4dvNV)(GLuint index, const GLdouble * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4dvARB)(GLuint index, const GLdouble * v) { - DISPATCH(VertexAttrib4dvNV, (index, v), (F, "glVertexAttrib4dvNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib4dvARB, (index, v), (F, "glVertexAttrib4dvARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { - DISPATCH(VertexAttrib4fNV, (index, x, y, z, w), (F, "glVertexAttrib4fNV(%d, %f, %f, %f, %f);\n", index, x, y, z, w)); + DISPATCH(VertexAttrib4fARB, (index, x, y, z, w), (F, "glVertexAttrib4fARB(%d, %f, %f, %f, %f);\n", index, x, y, z, w)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fvNV)(GLuint index, const GLfloat * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fvARB)(GLuint index, const GLfloat * v) { - DISPATCH(VertexAttrib4fvNV, (index, v), (F, "glVertexAttrib4fvNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib4fvARB, (index, v), (F, "glVertexAttrib4fvARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4sARB)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) { - DISPATCH(VertexAttrib4sNV, (index, x, y, z, w), (F, "glVertexAttrib4sNV(%d, %d, %d, %d, %d);\n", index, x, y, z, w)); + DISPATCH(VertexAttrib4sARB, (index, x, y, z, w), (F, "glVertexAttrib4sARB(%d, %d, %d, %d, %d);\n", index, x, y, z, w)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4svNV)(GLuint index, const GLshort * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4svARB)(GLuint index, const GLshort * v) { - DISPATCH(VertexAttrib4svNV, (index, v), (F, "glVertexAttrib4svNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib4svARB, (index, v), (F, "glVertexAttrib4svARB(%d, %p);\n", index, (const void *) v)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4NubARB)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) { - DISPATCH(VertexAttrib4ubNV, (index, x, y, z, w), (F, "glVertexAttrib4ubNV(%d, %d, %d, %d, %d);\n", index, x, y, z, w)); + DISPATCH(VertexAttrib4NubARB, (index, x, y, z, w), (F, "glVertexAttrib4NubARB(%d, %d, %d, %d, %d);\n", index, x, y, z, w)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4ubvNV)(GLuint index, const GLubyte * v) +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4NubvARB)(GLuint index, const GLubyte * v) { - DISPATCH(VertexAttrib4ubvNV, (index, v), (F, "glVertexAttrib4ubvNV(%d, %p);\n", index, (const void *) v)); + DISPATCH(VertexAttrib4NubvARB, (index, v), (F, "glVertexAttrib4NubvARB(%d, %p);\n", index, (const void *) v)); } KEYWORD1 void KEYWORD2 NAME(VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble * v) @@ -3835,6 +3835,151 @@ KEYWORD1 GLint KEYWORD2 NAME(GetAttribLocationARB)(GLhandleARB programObj, const RETURN_DISPATCH(GetAttribLocationARB, (programObj, name), (F, "glGetAttribLocationARB(%d, %p);\n", programObj, (const void *) name)); } +KEYWORD1 void KEYWORD2 NAME(GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params) +{ + DISPATCH(GetVertexAttribdvNV, (index, pname, params), (F, "glGetVertexAttribdvNV(%d, 0x%x, %p);\n", index, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params) +{ + DISPATCH(GetVertexAttribfvNV, (index, pname, params), (F, "glGetVertexAttribfvNV(%d, 0x%x, %p);\n", index, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params) +{ + DISPATCH(GetVertexAttribivNV, (index, pname, params), (F, "glGetVertexAttribivNV(%d, 0x%x, %p);\n", index, pname, (const void *) params)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1dNV)(GLuint index, GLdouble x) +{ + DISPATCH(VertexAttrib1dNV, (index, x), (F, "glVertexAttrib1dNV(%d, %f);\n", index, x)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1dvNV)(GLuint index, const GLdouble * v) +{ + DISPATCH(VertexAttrib1dvNV, (index, v), (F, "glVertexAttrib1dvNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fNV)(GLuint index, GLfloat x) +{ + DISPATCH(VertexAttrib1fNV, (index, x), (F, "glVertexAttrib1fNV(%d, %f);\n", index, x)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fvNV)(GLuint index, const GLfloat * v) +{ + DISPATCH(VertexAttrib1fvNV, (index, v), (F, "glVertexAttrib1fvNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1sNV)(GLuint index, GLshort x) +{ + DISPATCH(VertexAttrib1sNV, (index, x), (F, "glVertexAttrib1sNV(%d, %d);\n", index, x)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib1svNV)(GLuint index, const GLshort * v) +{ + DISPATCH(VertexAttrib1svNV, (index, v), (F, "glVertexAttrib1svNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y) +{ + DISPATCH(VertexAttrib2dNV, (index, x, y), (F, "glVertexAttrib2dNV(%d, %f, %f);\n", index, x, y)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2dvNV)(GLuint index, const GLdouble * v) +{ + DISPATCH(VertexAttrib2dvNV, (index, v), (F, "glVertexAttrib2dvNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y) +{ + DISPATCH(VertexAttrib2fNV, (index, x, y), (F, "glVertexAttrib2fNV(%d, %f, %f);\n", index, x, y)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fvNV)(GLuint index, const GLfloat * v) +{ + DISPATCH(VertexAttrib2fvNV, (index, v), (F, "glVertexAttrib2fvNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y) +{ + DISPATCH(VertexAttrib2sNV, (index, x, y), (F, "glVertexAttrib2sNV(%d, %d, %d);\n", index, x, y)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib2svNV)(GLuint index, const GLshort * v) +{ + DISPATCH(VertexAttrib2svNV, (index, v), (F, "glVertexAttrib2svNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + DISPATCH(VertexAttrib3dNV, (index, x, y, z), (F, "glVertexAttrib3dNV(%d, %f, %f, %f);\n", index, x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3dvNV)(GLuint index, const GLdouble * v) +{ + DISPATCH(VertexAttrib3dvNV, (index, v), (F, "glVertexAttrib3dvNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + DISPATCH(VertexAttrib3fNV, (index, x, y, z), (F, "glVertexAttrib3fNV(%d, %f, %f, %f);\n", index, x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fvNV)(GLuint index, const GLfloat * v) +{ + DISPATCH(VertexAttrib3fvNV, (index, v), (F, "glVertexAttrib3fvNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z) +{ + DISPATCH(VertexAttrib3sNV, (index, x, y, z), (F, "glVertexAttrib3sNV(%d, %d, %d, %d);\n", index, x, y, z)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib3svNV)(GLuint index, const GLshort * v) +{ + DISPATCH(VertexAttrib3svNV, (index, v), (F, "glVertexAttrib3svNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + DISPATCH(VertexAttrib4dNV, (index, x, y, z, w), (F, "glVertexAttrib4dNV(%d, %f, %f, %f, %f);\n", index, x, y, z, w)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4dvNV)(GLuint index, const GLdouble * v) +{ + DISPATCH(VertexAttrib4dvNV, (index, v), (F, "glVertexAttrib4dvNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + DISPATCH(VertexAttrib4fNV, (index, x, y, z, w), (F, "glVertexAttrib4fNV(%d, %f, %f, %f, %f);\n", index, x, y, z, w)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fvNV)(GLuint index, const GLfloat * v) +{ + DISPATCH(VertexAttrib4fvNV, (index, v), (F, "glVertexAttrib4fvNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + DISPATCH(VertexAttrib4sNV, (index, x, y, z, w), (F, "glVertexAttrib4sNV(%d, %d, %d, %d, %d);\n", index, x, y, z, w)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4svNV)(GLuint index, const GLshort * v) +{ + DISPATCH(VertexAttrib4svNV, (index, v), (F, "glVertexAttrib4svNV(%d, %p);\n", index, (const void *) v)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + DISPATCH(VertexAttrib4ubNV, (index, x, y, z, w), (F, "glVertexAttrib4ubNV(%d, %d, %d, %d, %d);\n", index, x, y, z, w)); +} + +KEYWORD1 void KEYWORD2 NAME(VertexAttrib4ubvNV)(GLuint index, const GLubyte * v) +{ + DISPATCH(VertexAttrib4ubvNV, (index, v), (F, "glVertexAttrib4ubvNV(%d, %p);\n", index, (const void *) v)); +} + KEYWORD1 void KEYWORD2 NAME(ActiveTexture)(GLenum texture) { DISPATCH(ActiveTextureARB, (texture), (F, "glActiveTexture(0x%x);\n", texture)); @@ -4475,136 +4620,6 @@ KEYWORD1 void KEYWORD2 NAME(WindowPos3svARB)(const GLshort * p) DISPATCH(WindowPos3svMESA, (p), (F, "glWindowPos3svARB(%p);\n", (const void *) p)); } -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1sARB)(GLuint index, GLshort x) -{ - DISPATCH(VertexAttrib1sNV, (index, x), (F, "glVertexAttrib1sARB(%d, %d);\n", index, x)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fARB)(GLuint index, GLfloat x) -{ - DISPATCH(VertexAttrib1fNV, (index, x), (F, "glVertexAttrib1fARB(%d, %f);\n", index, x)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1dARB)(GLuint index, GLdouble x) -{ - DISPATCH(VertexAttrib1dNV, (index, x), (F, "glVertexAttrib1dARB(%d, %f);\n", index, x)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2sARB)(GLuint index, GLshort x, GLshort y) -{ - DISPATCH(VertexAttrib2sNV, (index, x, y), (F, "glVertexAttrib2sARB(%d, %d, %d);\n", index, x, y)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y) -{ - DISPATCH(VertexAttrib2fNV, (index, x, y), (F, "glVertexAttrib2fARB(%d, %f, %f);\n", index, x, y)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2dARB)(GLuint index, GLdouble x, GLdouble y) -{ - DISPATCH(VertexAttrib2dNV, (index, x, y), (F, "glVertexAttrib2dARB(%d, %f, %f);\n", index, x, y)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3sARB)(GLuint index, GLshort x, GLshort y, GLshort z) -{ - DISPATCH(VertexAttrib3sNV, (index, x, y, z), (F, "glVertexAttrib3sARB(%d, %d, %d, %d);\n", index, x, y, z)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z) -{ - DISPATCH(VertexAttrib3fNV, (index, x, y, z), (F, "glVertexAttrib3fARB(%d, %f, %f, %f);\n", index, x, y, z)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z) -{ - DISPATCH(VertexAttrib3dNV, (index, x, y, z), (F, "glVertexAttrib3dARB(%d, %f, %f, %f);\n", index, x, y, z)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4sARB)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) -{ - DISPATCH(VertexAttrib4sNV, (index, x, y, z, w), (F, "glVertexAttrib4sARB(%d, %d, %d, %d, %d);\n", index, x, y, z, w)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) -{ - DISPATCH(VertexAttrib4fNV, (index, x, y, z, w), (F, "glVertexAttrib4fARB(%d, %f, %f, %f, %f);\n", index, x, y, z, w)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) -{ - DISPATCH(VertexAttrib4dNV, (index, x, y, z, w), (F, "glVertexAttrib4dARB(%d, %f, %f, %f, %f);\n", index, x, y, z, w)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4NubARB)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) -{ - DISPATCH(VertexAttrib4ubNV, (index, x, y, z, w), (F, "glVertexAttrib4NubARB(%d, %d, %d, %d, %d);\n", index, x, y, z, w)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1svARB)(GLuint index, const GLshort * v) -{ - DISPATCH(VertexAttrib1svNV, (index, v), (F, "glVertexAttrib1svARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1fvARB)(GLuint index, const GLfloat * v) -{ - DISPATCH(VertexAttrib1fvNV, (index, v), (F, "glVertexAttrib1fvARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib1dvARB)(GLuint index, const GLdouble * v) -{ - DISPATCH(VertexAttrib1dvNV, (index, v), (F, "glVertexAttrib1dvARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2svARB)(GLuint index, const GLshort * v) -{ - DISPATCH(VertexAttrib2svNV, (index, v), (F, "glVertexAttrib2svARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2fvARB)(GLuint index, const GLfloat * v) -{ - DISPATCH(VertexAttrib2fvNV, (index, v), (F, "glVertexAttrib2fvARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib2dvARB)(GLuint index, const GLdouble * v) -{ - DISPATCH(VertexAttrib2dvNV, (index, v), (F, "glVertexAttrib2dvARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3svARB)(GLuint index, const GLshort * v) -{ - DISPATCH(VertexAttrib3svNV, (index, v), (F, "glVertexAttrib3svARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3fvARB)(GLuint index, const GLfloat * v) -{ - DISPATCH(VertexAttrib3fvNV, (index, v), (F, "glVertexAttrib3fvARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib3dvARB)(GLuint index, const GLdouble * v) -{ - DISPATCH(VertexAttrib3dvNV, (index, v), (F, "glVertexAttrib3dvARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4svARB)(GLuint index, const GLshort * v) -{ - DISPATCH(VertexAttrib4svNV, (index, v), (F, "glVertexAttrib4svARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4fvARB)(GLuint index, const GLfloat * v) -{ - DISPATCH(VertexAttrib4fvNV, (index, v), (F, "glVertexAttrib4fvARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4dvARB)(GLuint index, const GLdouble * v) -{ - DISPATCH(VertexAttrib4dvNV, (index, v), (F, "glVertexAttrib4dvARB(%d, %p);\n", index, (const void *) v)); -} - -KEYWORD1 void KEYWORD2 NAME(VertexAttrib4NubvARB)(GLuint index, const GLubyte * v) -{ - DISPATCH(VertexAttrib4ubvNV, (index, v), (F, "glVertexAttrib4NubvARB(%d, %p);\n", index, (const void *) v)); -} - KEYWORD1 void KEYWORD2 NAME(BindProgramARB)(GLenum target, GLuint program) { DISPATCH(BindProgramNV, (target, program), (F, "glBindProgramARB(0x%x, %d);\n", target, program)); @@ -4625,21 +4640,6 @@ KEYWORD1 GLboolean KEYWORD2 NAME(IsProgramARB)(GLuint program) RETURN_DISPATCH(IsProgramNV, (program), (F, "glIsProgramARB(%d);\n", program)); } -KEYWORD1 void KEYWORD2 NAME(GetVertexAttribdvARB)(GLuint index, GLenum pname, GLdouble * params) -{ - DISPATCH(GetVertexAttribdvNV, (index, pname, params), (F, "glGetVertexAttribdvARB(%d, 0x%x, %p);\n", index, pname, (const void *) params)); -} - -KEYWORD1 void KEYWORD2 NAME(GetVertexAttribfvARB)(GLuint index, GLenum pname, GLfloat * params) -{ - DISPATCH(GetVertexAttribfvNV, (index, pname, params), (F, "glGetVertexAttribfvARB(%d, 0x%x, %p);\n", index, pname, (const void *) params)); -} - -KEYWORD1 void KEYWORD2 NAME(GetVertexAttribivARB)(GLuint index, GLenum pname, GLint * params) -{ - DISPATCH(GetVertexAttribivNV, (index, pname, params), (F, "glGetVertexAttribivARB(%d, 0x%x, %p);\n", index, pname, (const void *) params)); -} - KEYWORD1 void KEYWORD2 NAME(GetVertexAttribPointervARB)(GLuint index, GLenum pname, GLvoid ** params) { DISPATCH(GetVertexAttribPointervNV, (index, pname, params), (F, "glGetVertexAttribPointervARB(%d, 0x%x, %p);\n", index, pname, (const void *) params)); @@ -5472,9 +5472,9 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = { TABLE_ENTRY(GetProgramivNV), TABLE_ENTRY(GetProgramStringNV), TABLE_ENTRY(GetTrackMatrixivNV), - TABLE_ENTRY(GetVertexAttribdvNV), - TABLE_ENTRY(GetVertexAttribfvNV), - TABLE_ENTRY(GetVertexAttribivNV), + TABLE_ENTRY(GetVertexAttribdvARB), + TABLE_ENTRY(GetVertexAttribfvARB), + TABLE_ENTRY(GetVertexAttribivARB), TABLE_ENTRY(GetVertexAttribPointervNV), TABLE_ENTRY(IsProgramNV), TABLE_ENTRY(LoadProgramNV), @@ -5487,32 +5487,32 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = { TABLE_ENTRY(RequestResidentProgramsNV), TABLE_ENTRY(TrackMatrixNV), TABLE_ENTRY(VertexAttribPointerNV), - TABLE_ENTRY(VertexAttrib1dNV), - TABLE_ENTRY(VertexAttrib1dvNV), - TABLE_ENTRY(VertexAttrib1fNV), - TABLE_ENTRY(VertexAttrib1fvNV), - TABLE_ENTRY(VertexAttrib1sNV), - TABLE_ENTRY(VertexAttrib1svNV), - TABLE_ENTRY(VertexAttrib2dNV), - TABLE_ENTRY(VertexAttrib2dvNV), - TABLE_ENTRY(VertexAttrib2fNV), - TABLE_ENTRY(VertexAttrib2fvNV), - TABLE_ENTRY(VertexAttrib2sNV), - TABLE_ENTRY(VertexAttrib2svNV), - TABLE_ENTRY(VertexAttrib3dNV), - TABLE_ENTRY(VertexAttrib3dvNV), - TABLE_ENTRY(VertexAttrib3fNV), - TABLE_ENTRY(VertexAttrib3fvNV), - TABLE_ENTRY(VertexAttrib3sNV), - TABLE_ENTRY(VertexAttrib3svNV), - TABLE_ENTRY(VertexAttrib4dNV), - TABLE_ENTRY(VertexAttrib4dvNV), - TABLE_ENTRY(VertexAttrib4fNV), - TABLE_ENTRY(VertexAttrib4fvNV), - TABLE_ENTRY(VertexAttrib4sNV), - TABLE_ENTRY(VertexAttrib4svNV), - TABLE_ENTRY(VertexAttrib4ubNV), - TABLE_ENTRY(VertexAttrib4ubvNV), + TABLE_ENTRY(VertexAttrib1dARB), + TABLE_ENTRY(VertexAttrib1dvARB), + TABLE_ENTRY(VertexAttrib1fARB), + TABLE_ENTRY(VertexAttrib1fvARB), + TABLE_ENTRY(VertexAttrib1sARB), + TABLE_ENTRY(VertexAttrib1svARB), + TABLE_ENTRY(VertexAttrib2dARB), + TABLE_ENTRY(VertexAttrib2dvARB), + TABLE_ENTRY(VertexAttrib2fARB), + TABLE_ENTRY(VertexAttrib2fvARB), + TABLE_ENTRY(VertexAttrib2sARB), + TABLE_ENTRY(VertexAttrib2svARB), + TABLE_ENTRY(VertexAttrib3dARB), + TABLE_ENTRY(VertexAttrib3dvARB), + TABLE_ENTRY(VertexAttrib3fARB), + TABLE_ENTRY(VertexAttrib3fvARB), + TABLE_ENTRY(VertexAttrib3sARB), + TABLE_ENTRY(VertexAttrib3svARB), + TABLE_ENTRY(VertexAttrib4dARB), + TABLE_ENTRY(VertexAttrib4dvARB), + TABLE_ENTRY(VertexAttrib4fARB), + TABLE_ENTRY(VertexAttrib4fvARB), + TABLE_ENTRY(VertexAttrib4sARB), + TABLE_ENTRY(VertexAttrib4svARB), + TABLE_ENTRY(VertexAttrib4NubARB), + TABLE_ENTRY(VertexAttrib4NubvARB), TABLE_ENTRY(VertexAttribs1dvNV), TABLE_ENTRY(VertexAttribs1fvNV), TABLE_ENTRY(VertexAttribs1svNV), @@ -5637,6 +5637,35 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = { TABLE_ENTRY(BindAttribLocationARB), TABLE_ENTRY(GetActiveAttribARB), TABLE_ENTRY(GetAttribLocationARB), + TABLE_ENTRY(GetVertexAttribdvNV), + TABLE_ENTRY(GetVertexAttribfvNV), + TABLE_ENTRY(GetVertexAttribivNV), + TABLE_ENTRY(VertexAttrib1dNV), + TABLE_ENTRY(VertexAttrib1dvNV), + TABLE_ENTRY(VertexAttrib1fNV), + TABLE_ENTRY(VertexAttrib1fvNV), + TABLE_ENTRY(VertexAttrib1sNV), + TABLE_ENTRY(VertexAttrib1svNV), + TABLE_ENTRY(VertexAttrib2dNV), + TABLE_ENTRY(VertexAttrib2dvNV), + TABLE_ENTRY(VertexAttrib2fNV), + TABLE_ENTRY(VertexAttrib2fvNV), + TABLE_ENTRY(VertexAttrib2sNV), + TABLE_ENTRY(VertexAttrib2svNV), + TABLE_ENTRY(VertexAttrib3dNV), + TABLE_ENTRY(VertexAttrib3dvNV), + TABLE_ENTRY(VertexAttrib3fNV), + TABLE_ENTRY(VertexAttrib3fvNV), + TABLE_ENTRY(VertexAttrib3sNV), + TABLE_ENTRY(VertexAttrib3svNV), + TABLE_ENTRY(VertexAttrib4dNV), + TABLE_ENTRY(VertexAttrib4dvNV), + TABLE_ENTRY(VertexAttrib4fNV), + TABLE_ENTRY(VertexAttrib4fvNV), + TABLE_ENTRY(VertexAttrib4sNV), + TABLE_ENTRY(VertexAttrib4svNV), + TABLE_ENTRY(VertexAttrib4ubNV), + TABLE_ENTRY(VertexAttrib4ubvNV), /* A whole bunch of no-op functions. These might be called * when someone tries to call a dynamically-registered * extension function without a current rendering context. @@ -5878,39 +5907,10 @@ static _glapi_proc UNUSED_TABLE_NAME[] = { TABLE_ENTRY(WindowPos3fvARB), TABLE_ENTRY(WindowPos3ivARB), TABLE_ENTRY(WindowPos3svARB), - TABLE_ENTRY(VertexAttrib1sARB), - TABLE_ENTRY(VertexAttrib1fARB), - TABLE_ENTRY(VertexAttrib1dARB), - TABLE_ENTRY(VertexAttrib2sARB), - TABLE_ENTRY(VertexAttrib2fARB), - TABLE_ENTRY(VertexAttrib2dARB), - TABLE_ENTRY(VertexAttrib3sARB), - TABLE_ENTRY(VertexAttrib3fARB), - TABLE_ENTRY(VertexAttrib3dARB), - TABLE_ENTRY(VertexAttrib4sARB), - TABLE_ENTRY(VertexAttrib4fARB), - TABLE_ENTRY(VertexAttrib4dARB), - TABLE_ENTRY(VertexAttrib4NubARB), - TABLE_ENTRY(VertexAttrib1svARB), - TABLE_ENTRY(VertexAttrib1fvARB), - TABLE_ENTRY(VertexAttrib1dvARB), - TABLE_ENTRY(VertexAttrib2svARB), - TABLE_ENTRY(VertexAttrib2fvARB), - TABLE_ENTRY(VertexAttrib2dvARB), - TABLE_ENTRY(VertexAttrib3svARB), - TABLE_ENTRY(VertexAttrib3fvARB), - TABLE_ENTRY(VertexAttrib3dvARB), - TABLE_ENTRY(VertexAttrib4svARB), - TABLE_ENTRY(VertexAttrib4fvARB), - TABLE_ENTRY(VertexAttrib4dvARB), - TABLE_ENTRY(VertexAttrib4NubvARB), TABLE_ENTRY(BindProgramARB), TABLE_ENTRY(DeleteProgramsARB), TABLE_ENTRY(GenProgramsARB), TABLE_ENTRY(IsProgramARB), - TABLE_ENTRY(GetVertexAttribdvARB), - TABLE_ENTRY(GetVertexAttribfvARB), - TABLE_ENTRY(GetVertexAttribivARB), TABLE_ENTRY(GetVertexAttribPointervARB), TABLE_ENTRY(BlendColorEXT), TABLE_ENTRY(TexImage3DEXT), diff --git a/src/mesa/glapi/glprocs.h b/src/mesa/glapi/glprocs.h index 6bc07ed..02cf81a 100644 --- a/src/mesa/glapi/glprocs.h +++ b/src/mesa/glapi/glprocs.h @@ -634,9 +634,9 @@ static const char gl_string_table[] = "glGetProgramivNV\0" "glGetProgramStringNV\0" "glGetTrackMatrixivNV\0" - "glGetVertexAttribdvNV\0" - "glGetVertexAttribfvNV\0" - "glGetVertexAttribivNV\0" + "glGetVertexAttribdvARB\0" + "glGetVertexAttribfvARB\0" + "glGetVertexAttribivARB\0" "glGetVertexAttribPointervNV\0" "glIsProgramNV\0" "glLoadProgramNV\0" @@ -649,32 +649,32 @@ static const char gl_string_table[] = "glRequestResidentProgramsNV\0" "glTrackMatrixNV\0" "glVertexAttribPointerNV\0" - "glVertexAttrib1dNV\0" - "glVertexAttrib1dvNV\0" - "glVertexAttrib1fNV\0" - "glVertexAttrib1fvNV\0" - "glVertexAttrib1sNV\0" - "glVertexAttrib1svNV\0" - "glVertexAttrib2dNV\0" - "glVertexAttrib2dvNV\0" - "glVertexAttrib2fNV\0" - "glVertexAttrib2fvNV\0" - "glVertexAttrib2sNV\0" - "glVertexAttrib2svNV\0" - "glVertexAttrib3dNV\0" - "glVertexAttrib3dvNV\0" - "glVertexAttrib3fNV\0" - "glVertexAttrib3fvNV\0" - "glVertexAttrib3sNV\0" - "glVertexAttrib3svNV\0" - "glVertexAttrib4dNV\0" - "glVertexAttrib4dvNV\0" - "glVertexAttrib4fNV\0" - "glVertexAttrib4fvNV\0" - "glVertexAttrib4sNV\0" - "glVertexAttrib4svNV\0" - "glVertexAttrib4ubNV\0" - "glVertexAttrib4ubvNV\0" + "glVertexAttrib1dARB\0" + "glVertexAttrib1dvARB\0" + "glVertexAttrib1fARB\0" + "glVertexAttrib1fvARB\0" + "glVertexAttrib1sARB\0" + "glVertexAttrib1svARB\0" + "glVertexAttrib2dARB\0" + "glVertexAttrib2dvARB\0" + "glVertexAttrib2fARB\0" + "glVertexAttrib2fvARB\0" + "glVertexAttrib2sARB\0" + "glVertexAttrib2svARB\0" + "glVertexAttrib3dARB\0" + "glVertexAttrib3dvARB\0" + "glVertexAttrib3fARB\0" + "glVertexAttrib3fvARB\0" + "glVertexAttrib3sARB\0" + "glVertexAttrib3svARB\0" + "glVertexAttrib4dARB\0" + "glVertexAttrib4dvARB\0" + "glVertexAttrib4fARB\0" + "glVertexAttrib4fvARB\0" + "glVertexAttrib4sARB\0" + "glVertexAttrib4svARB\0" + "glVertexAttrib4NubARB\0" + "glVertexAttrib4NubvARB\0" "glVertexAttribs1dvNV\0" "glVertexAttribs1fvNV\0" "glVertexAttribs1svNV\0" @@ -799,6 +799,35 @@ static const char gl_string_table[] = "glBindAttribLocationARB\0" "glGetActiveAttribARB\0" "glGetAttribLocationARB\0" + "glGetVertexAttribdvNV\0" + "glGetVertexAttribfvNV\0" + "glGetVertexAttribivNV\0" + "glVertexAttrib1dNV\0" + "glVertexAttrib1dvNV\0" + "glVertexAttrib1fNV\0" + "glVertexAttrib1fvNV\0" + "glVertexAttrib1sNV\0" + "glVertexAttrib1svNV\0" + "glVertexAttrib2dNV\0" + "glVertexAttrib2dvNV\0" + "glVertexAttrib2fNV\0" + "glVertexAttrib2fvNV\0" + "glVertexAttrib2sNV\0" + "glVertexAttrib2svNV\0" + "glVertexAttrib3dNV\0" + "glVertexAttrib3dvNV\0" + "glVertexAttrib3fNV\0" + "glVertexAttrib3fvNV\0" + "glVertexAttrib3sNV\0" + "glVertexAttrib3svNV\0" + "glVertexAttrib4dNV\0" + "glVertexAttrib4dvNV\0" + "glVertexAttrib4fNV\0" + "glVertexAttrib4fvNV\0" + "glVertexAttrib4sNV\0" + "glVertexAttrib4svNV\0" + "glVertexAttrib4ubNV\0" + "glVertexAttrib4ubvNV\0" "glActiveTexture\0" "glClientActiveTexture\0" "glMultiTexCoord1d\0" @@ -927,39 +956,10 @@ static const char gl_string_table[] = "glWindowPos3fvARB\0" "glWindowPos3ivARB\0" "glWindowPos3svARB\0" - "glVertexAttrib1sARB\0" - "glVertexAttrib1fARB\0" - "glVertexAttrib1dARB\0" - "glVertexAttrib2sARB\0" - "glVertexAttrib2fARB\0" - "glVertexAttrib2dARB\0" - "glVertexAttrib3sARB\0" - "glVertexAttrib3fARB\0" - "glVertexAttrib3dARB\0" - "glVertexAttrib4sARB\0" - "glVertexAttrib4fARB\0" - "glVertexAttrib4dARB\0" - "glVertexAttrib4NubARB\0" - "glVertexAttrib1svARB\0" - "glVertexAttrib1fvARB\0" - "glVertexAttrib1dvARB\0" - "glVertexAttrib2svARB\0" - "glVertexAttrib2fvARB\0" - "glVertexAttrib2dvARB\0" - "glVertexAttrib3svARB\0" - "glVertexAttrib3fvARB\0" - "glVertexAttrib3dvARB\0" - "glVertexAttrib4svARB\0" - "glVertexAttrib4fvARB\0" - "glVertexAttrib4dvARB\0" - "glVertexAttrib4NubvARB\0" "glBindProgramARB\0" "glDeleteProgramsARB\0" "glGenProgramsARB\0" "glIsProgramARB\0" - "glGetVertexAttribdvARB\0" - "glGetVertexAttribfvARB\0" - "glGetVertexAttribivARB\0" "glGetVertexAttribPointervARB\0" "glBlendColorEXT\0" "glTexImage3DEXT\0" @@ -1597,332 +1597,332 @@ static const glprocs_table_t static_functions[] = { NAME_FUNC_OFFSET( 9748, glGetProgramivNV, _gloffset_GetProgramivNV ), NAME_FUNC_OFFSET( 9765, glGetProgramStringNV, _gloffset_GetProgramStringNV ), NAME_FUNC_OFFSET( 9786, glGetTrackMatrixivNV, _gloffset_GetTrackMatrixivNV ), - NAME_FUNC_OFFSET( 9807, glGetVertexAttribdvNV, _gloffset_GetVertexAttribdvNV ), - NAME_FUNC_OFFSET( 9829, glGetVertexAttribfvNV, _gloffset_GetVertexAttribfvNV ), - NAME_FUNC_OFFSET( 9851, glGetVertexAttribivNV, _gloffset_GetVertexAttribivNV ), - NAME_FUNC_OFFSET( 9873, glGetVertexAttribPointervNV, _gloffset_GetVertexAttribPointervNV ), - NAME_FUNC_OFFSET( 9901, glIsProgramNV, _gloffset_IsProgramNV ), - NAME_FUNC_OFFSET( 9915, glLoadProgramNV, _gloffset_LoadProgramNV ), - NAME_FUNC_OFFSET( 9931, glProgramParameter4dNV, _gloffset_ProgramParameter4dNV ), - NAME_FUNC_OFFSET( 9954, glProgramParameter4dvNV, _gloffset_ProgramParameter4dvNV ), - NAME_FUNC_OFFSET( 9978, glProgramParameter4fNV, _gloffset_ProgramParameter4fNV ), - NAME_FUNC_OFFSET( 10001, glProgramParameter4fvNV, _gloffset_ProgramParameter4fvNV ), - NAME_FUNC_OFFSET( 10025, glProgramParameters4dvNV, _gloffset_ProgramParameters4dvNV ), - NAME_FUNC_OFFSET( 10050, glProgramParameters4fvNV, _gloffset_ProgramParameters4fvNV ), - NAME_FUNC_OFFSET( 10075, glRequestResidentProgramsNV, _gloffset_RequestResidentProgramsNV ), - NAME_FUNC_OFFSET( 10103, glTrackMatrixNV, _gloffset_TrackMatrixNV ), - NAME_FUNC_OFFSET( 10119, glVertexAttribPointerNV, _gloffset_VertexAttribPointerNV ), - NAME_FUNC_OFFSET( 10143, glVertexAttrib1dNV, _gloffset_VertexAttrib1dNV ), - NAME_FUNC_OFFSET( 10162, glVertexAttrib1dvNV, _gloffset_VertexAttrib1dvNV ), - NAME_FUNC_OFFSET( 10182, glVertexAttrib1fNV, _gloffset_VertexAttrib1fNV ), - NAME_FUNC_OFFSET( 10201, glVertexAttrib1fvNV, _gloffset_VertexAttrib1fvNV ), - NAME_FUNC_OFFSET( 10221, glVertexAttrib1sNV, _gloffset_VertexAttrib1sNV ), - NAME_FUNC_OFFSET( 10240, glVertexAttrib1svNV, _gloffset_VertexAttrib1svNV ), - NAME_FUNC_OFFSET( 10260, glVertexAttrib2dNV, _gloffset_VertexAttrib2dNV ), - NAME_FUNC_OFFSET( 10279, glVertexAttrib2dvNV, _gloffset_VertexAttrib2dvNV ), - NAME_FUNC_OFFSET( 10299, glVertexAttrib2fNV, _gloffset_VertexAttrib2fNV ), - NAME_FUNC_OFFSET( 10318, glVertexAttrib2fvNV, _gloffset_VertexAttrib2fvNV ), - NAME_FUNC_OFFSET( 10338, glVertexAttrib2sNV, _gloffset_VertexAttrib2sNV ), - NAME_FUNC_OFFSET( 10357, glVertexAttrib2svNV, _gloffset_VertexAttrib2svNV ), - NAME_FUNC_OFFSET( 10377, glVertexAttrib3dNV, _gloffset_VertexAttrib3dNV ), - NAME_FUNC_OFFSET( 10396, glVertexAttrib3dvNV, _gloffset_VertexAttrib3dvNV ), - NAME_FUNC_OFFSET( 10416, glVertexAttrib3fNV, _gloffset_VertexAttrib3fNV ), - NAME_FUNC_OFFSET( 10435, glVertexAttrib3fvNV, _gloffset_VertexAttrib3fvNV ), - NAME_FUNC_OFFSET( 10455, glVertexAttrib3sNV, _gloffset_VertexAttrib3sNV ), - NAME_FUNC_OFFSET( 10474, glVertexAttrib3svNV, _gloffset_VertexAttrib3svNV ), - NAME_FUNC_OFFSET( 10494, glVertexAttrib4dNV, _gloffset_VertexAttrib4dNV ), - NAME_FUNC_OFFSET( 10513, glVertexAttrib4dvNV, _gloffset_VertexAttrib4dvNV ), - NAME_FUNC_OFFSET( 10533, glVertexAttrib4fNV, _gloffset_VertexAttrib4fNV ), - NAME_FUNC_OFFSET( 10552, glVertexAttrib4fvNV, _gloffset_VertexAttrib4fvNV ), - NAME_FUNC_OFFSET( 10572, glVertexAttrib4sNV, _gloffset_VertexAttrib4sNV ), - NAME_FUNC_OFFSET( 10591, glVertexAttrib4svNV, _gloffset_VertexAttrib4svNV ), - NAME_FUNC_OFFSET( 10611, glVertexAttrib4ubNV, _gloffset_VertexAttrib4ubNV ), - NAME_FUNC_OFFSET( 10631, glVertexAttrib4ubvNV, _gloffset_VertexAttrib4ubvNV ), - NAME_FUNC_OFFSET( 10652, glVertexAttribs1dvNV, _gloffset_VertexAttribs1dvNV ), - NAME_FUNC_OFFSET( 10673, glVertexAttribs1fvNV, _gloffset_VertexAttribs1fvNV ), - NAME_FUNC_OFFSET( 10694, glVertexAttribs1svNV, _gloffset_VertexAttribs1svNV ), - NAME_FUNC_OFFSET( 10715, glVertexAttribs2dvNV, _gloffset_VertexAttribs2dvNV ), - NAME_FUNC_OFFSET( 10736, glVertexAttribs2fvNV, _gloffset_VertexAttribs2fvNV ), - NAME_FUNC_OFFSET( 10757, glVertexAttribs2svNV, _gloffset_VertexAttribs2svNV ), - NAME_FUNC_OFFSET( 10778, glVertexAttribs3dvNV, _gloffset_VertexAttribs3dvNV ), - NAME_FUNC_OFFSET( 10799, glVertexAttribs3fvNV, _gloffset_VertexAttribs3fvNV ), - NAME_FUNC_OFFSET( 10820, glVertexAttribs3svNV, _gloffset_VertexAttribs3svNV ), - NAME_FUNC_OFFSET( 10841, glVertexAttribs4dvNV, _gloffset_VertexAttribs4dvNV ), - NAME_FUNC_OFFSET( 10862, glVertexAttribs4fvNV, _gloffset_VertexAttribs4fvNV ), - NAME_FUNC_OFFSET( 10883, glVertexAttribs4svNV, _gloffset_VertexAttribs4svNV ), - NAME_FUNC_OFFSET( 10904, glVertexAttribs4ubvNV, _gloffset_VertexAttribs4ubvNV ), - NAME_FUNC_OFFSET( 10926, glPointParameteriNV, _gloffset_PointParameteriNV ), - NAME_FUNC_OFFSET( 10946, glPointParameterivNV, _gloffset_PointParameterivNV ), - NAME_FUNC_OFFSET( 10967, glMultiDrawArraysEXT, _gloffset_MultiDrawArraysEXT ), - NAME_FUNC_OFFSET( 10988, glMultiDrawElementsEXT, _gloffset_MultiDrawElementsEXT ), - NAME_FUNC_OFFSET( 11011, glActiveStencilFaceEXT, _gloffset_ActiveStencilFaceEXT ), - NAME_FUNC_OFFSET( 11034, glDeleteFencesNV, _gloffset_DeleteFencesNV ), - NAME_FUNC_OFFSET( 11051, glGenFencesNV, _gloffset_GenFencesNV ), - NAME_FUNC_OFFSET( 11065, glIsFenceNV, _gloffset_IsFenceNV ), - NAME_FUNC_OFFSET( 11077, glTestFenceNV, _gloffset_TestFenceNV ), - NAME_FUNC_OFFSET( 11091, glGetFenceivNV, _gloffset_GetFenceivNV ), - NAME_FUNC_OFFSET( 11106, glFinishFenceNV, _gloffset_FinishFenceNV ), - NAME_FUNC_OFFSET( 11122, glSetFenceNV, _gloffset_SetFenceNV ), - NAME_FUNC_OFFSET( 11135, glVertexAttrib4bvARB, _gloffset_VertexAttrib4bvARB ), - NAME_FUNC_OFFSET( 11156, glVertexAttrib4ivARB, _gloffset_VertexAttrib4ivARB ), - NAME_FUNC_OFFSET( 11177, glVertexAttrib4ubvARB, _gloffset_VertexAttrib4ubvARB ), - NAME_FUNC_OFFSET( 11199, glVertexAttrib4usvARB, _gloffset_VertexAttrib4usvARB ), - NAME_FUNC_OFFSET( 11221, glVertexAttrib4uivARB, _gloffset_VertexAttrib4uivARB ), - NAME_FUNC_OFFSET( 11243, glVertexAttrib4NbvARB, _gloffset_VertexAttrib4NbvARB ), - NAME_FUNC_OFFSET( 11265, glVertexAttrib4NsvARB, _gloffset_VertexAttrib4NsvARB ), - NAME_FUNC_OFFSET( 11287, glVertexAttrib4NivARB, _gloffset_VertexAttrib4NivARB ), - NAME_FUNC_OFFSET( 11309, glVertexAttrib4NusvARB, _gloffset_VertexAttrib4NusvARB ), - NAME_FUNC_OFFSET( 11332, glVertexAttrib4NuivARB, _gloffset_VertexAttrib4NuivARB ), - NAME_FUNC_OFFSET( 11355, glVertexAttribPointerARB, _gloffset_VertexAttribPointerARB ), - NAME_FUNC_OFFSET( 11380, glEnableVertexAttribArrayARB, _gloffset_EnableVertexAttribArrayARB ), - NAME_FUNC_OFFSET( 11409, glDisableVertexAttribArrayARB, _gloffset_DisableVertexAttribArrayARB ), - NAME_FUNC_OFFSET( 11439, glProgramStringARB, _gloffset_ProgramStringARB ), - NAME_FUNC_OFFSET( 11458, glProgramEnvParameter4dARB, _gloffset_ProgramEnvParameter4dARB ), - NAME_FUNC_OFFSET( 11485, glProgramEnvParameter4dvARB, _gloffset_ProgramEnvParameter4dvARB ), - NAME_FUNC_OFFSET( 11513, glProgramEnvParameter4fARB, _gloffset_ProgramEnvParameter4fARB ), - NAME_FUNC_OFFSET( 11540, glProgramEnvParameter4fvARB, _gloffset_ProgramEnvParameter4fvARB ), - NAME_FUNC_OFFSET( 11568, glProgramLocalParameter4dARB, _gloffset_ProgramLocalParameter4dARB ), - NAME_FUNC_OFFSET( 11597, glProgramLocalParameter4dvARB, _gloffset_ProgramLocalParameter4dvARB ), - NAME_FUNC_OFFSET( 11627, glProgramLocalParameter4fARB, _gloffset_ProgramLocalParameter4fARB ), - NAME_FUNC_OFFSET( 11656, glProgramLocalParameter4fvARB, _gloffset_ProgramLocalParameter4fvARB ), - NAME_FUNC_OFFSET( 11686, glGetProgramEnvParameterdvARB, _gloffset_GetProgramEnvParameterdvARB ), - NAME_FUNC_OFFSET( 11716, glGetProgramEnvParameterfvARB, _gloffset_GetProgramEnvParameterfvARB ), - NAME_FUNC_OFFSET( 11746, glGetProgramLocalParameterdvARB, _gloffset_GetProgramLocalParameterdvARB ), - NAME_FUNC_OFFSET( 11778, glGetProgramLocalParameterfvARB, _gloffset_GetProgramLocalParameterfvARB ), - NAME_FUNC_OFFSET( 11810, glGetProgramivARB, _gloffset_GetProgramivARB ), - NAME_FUNC_OFFSET( 11828, glGetProgramStringARB, _gloffset_GetProgramStringARB ), - NAME_FUNC_OFFSET( 11850, glProgramNamedParameter4fNV, _gloffset_ProgramNamedParameter4fNV ), - NAME_FUNC_OFFSET( 11878, glProgramNamedParameter4dNV, _gloffset_ProgramNamedParameter4dNV ), - NAME_FUNC_OFFSET( 11906, glProgramNamedParameter4fvNV, _gloffset_ProgramNamedParameter4fvNV ), - NAME_FUNC_OFFSET( 11935, glProgramNamedParameter4dvNV, _gloffset_ProgramNamedParameter4dvNV ), - NAME_FUNC_OFFSET( 11964, glGetProgramNamedParameterfvNV, _gloffset_GetProgramNamedParameterfvNV ), - NAME_FUNC_OFFSET( 11995, glGetProgramNamedParameterdvNV, _gloffset_GetProgramNamedParameterdvNV ), - NAME_FUNC_OFFSET( 12026, glBindBufferARB, _gloffset_BindBufferARB ), - NAME_FUNC_OFFSET( 12042, glBufferDataARB, _gloffset_BufferDataARB ), - NAME_FUNC_OFFSET( 12058, glBufferSubDataARB, _gloffset_BufferSubDataARB ), - NAME_FUNC_OFFSET( 12077, glDeleteBuffersARB, _gloffset_DeleteBuffersARB ), - NAME_FUNC_OFFSET( 12096, glGenBuffersARB, _gloffset_GenBuffersARB ), - NAME_FUNC_OFFSET( 12112, glGetBufferParameterivARB, _gloffset_GetBufferParameterivARB ), - NAME_FUNC_OFFSET( 12138, glGetBufferPointervARB, _gloffset_GetBufferPointervARB ), - NAME_FUNC_OFFSET( 12161, glGetBufferSubDataARB, _gloffset_GetBufferSubDataARB ), - NAME_FUNC_OFFSET( 12183, glIsBufferARB, _gloffset_IsBufferARB ), - NAME_FUNC_OFFSET( 12197, glMapBufferARB, _gloffset_MapBufferARB ), - NAME_FUNC_OFFSET( 12212, glUnmapBufferARB, _gloffset_UnmapBufferARB ), - NAME_FUNC_OFFSET( 12229, glDepthBoundsEXT, _gloffset_DepthBoundsEXT ), - NAME_FUNC_OFFSET( 12246, glGenQueriesARB, _gloffset_GenQueriesARB ), - NAME_FUNC_OFFSET( 12262, glDeleteQueriesARB, _gloffset_DeleteQueriesARB ), - NAME_FUNC_OFFSET( 12281, glIsQueryARB, _gloffset_IsQueryARB ), - NAME_FUNC_OFFSET( 12294, glBeginQueryARB, _gloffset_BeginQueryARB ), - NAME_FUNC_OFFSET( 12310, glEndQueryARB, _gloffset_EndQueryARB ), - NAME_FUNC_OFFSET( 12324, glGetQueryivARB, _gloffset_GetQueryivARB ), - NAME_FUNC_OFFSET( 12340, glGetQueryObjectivARB, _gloffset_GetQueryObjectivARB ), - NAME_FUNC_OFFSET( 12362, glGetQueryObjectuivARB, _gloffset_GetQueryObjectuivARB ), - NAME_FUNC_OFFSET( 12385, glMultiModeDrawArraysIBM, _gloffset_MultiModeDrawArraysIBM ), - NAME_FUNC_OFFSET( 12410, glMultiModeDrawElementsIBM, _gloffset_MultiModeDrawElementsIBM ), - NAME_FUNC_OFFSET( 12437, glBlendEquationSeparateEXT, _gloffset_BlendEquationSeparateEXT ), - NAME_FUNC_OFFSET( 12464, glDeleteObjectARB, _gloffset_DeleteObjectARB ), - NAME_FUNC_OFFSET( 12482, glGetHandleARB, _gloffset_GetHandleARB ), - NAME_FUNC_OFFSET( 12497, glDetachObjectARB, _gloffset_DetachObjectARB ), - NAME_FUNC_OFFSET( 12515, glCreateShaderObjectARB, _gloffset_CreateShaderObjectARB ), - NAME_FUNC_OFFSET( 12539, glShaderSourceARB, _gloffset_ShaderSourceARB ), - NAME_FUNC_OFFSET( 12557, glCompileShaderARB, _gloffset_CompileShaderARB ), - NAME_FUNC_OFFSET( 12576, glCreateProgramObjectARB, _gloffset_CreateProgramObjectARB ), - NAME_FUNC_OFFSET( 12601, glAttachObjectARB, _gloffset_AttachObjectARB ), - NAME_FUNC_OFFSET( 12619, glLinkProgramARB, _gloffset_LinkProgramARB ), - NAME_FUNC_OFFSET( 12636, glUseProgramObjectARB, _gloffset_UseProgramObjectARB ), - NAME_FUNC_OFFSET( 12658, glValidateProgramARB, _gloffset_ValidateProgramARB ), - NAME_FUNC_OFFSET( 12679, glUniform1fARB, _gloffset_Uniform1fARB ), - NAME_FUNC_OFFSET( 12694, glUniform2fARB, _gloffset_Uniform2fARB ), - NAME_FUNC_OFFSET( 12709, glUniform3fARB, _gloffset_Uniform3fARB ), - NAME_FUNC_OFFSET( 12724, glUniform4fARB, _gloffset_Uniform4fARB ), - NAME_FUNC_OFFSET( 12739, glUniform1iARB, _gloffset_Uniform1iARB ), - NAME_FUNC_OFFSET( 12754, glUniform2iARB, _gloffset_Uniform2iARB ), - NAME_FUNC_OFFSET( 12769, glUniform3iARB, _gloffset_Uniform3iARB ), - NAME_FUNC_OFFSET( 12784, glUniform4iARB, _gloffset_Uniform4iARB ), - NAME_FUNC_OFFSET( 12799, glUniform1fvARB, _gloffset_Uniform1fvARB ), - NAME_FUNC_OFFSET( 12815, glUniform2fvARB, _gloffset_Uniform2fvARB ), - NAME_FUNC_OFFSET( 12831, glUniform3fvARB, _gloffset_Uniform3fvARB ), - NAME_FUNC_OFFSET( 12847, glUniform4fvARB, _gloffset_Uniform4fvARB ), - NAME_FUNC_OFFSET( 12863, glUniform1ivARB, _gloffset_Uniform1ivARB ), - NAME_FUNC_OFFSET( 12879, glUniform2ivARB, _gloffset_Uniform2ivARB ), - NAME_FUNC_OFFSET( 12895, glUniform3ivARB, _gloffset_Uniform3ivARB ), - NAME_FUNC_OFFSET( 12911, glUniform4ivARB, _gloffset_Uniform4ivARB ), - NAME_FUNC_OFFSET( 12927, glUniformMatrix2fvARB, _gloffset_UniformMatrix2fvARB ), - NAME_FUNC_OFFSET( 12949, glUniformMatrix3fvARB, _gloffset_UniformMatrix3fvARB ), - NAME_FUNC_OFFSET( 12971, glUniformMatrix4fvARB, _gloffset_UniformMatrix4fvARB ), - NAME_FUNC_OFFSET( 12993, glGetObjectParameterfvARB, _gloffset_GetObjectParameterfvARB ), - NAME_FUNC_OFFSET( 13019, glGetObjectParameterivARB, _gloffset_GetObjectParameterivARB ), - NAME_FUNC_OFFSET( 13045, glGetInfoLogARB, _gloffset_GetInfoLogARB ), - NAME_FUNC_OFFSET( 13061, glGetAttachedObjectsARB, _gloffset_GetAttachedObjectsARB ), - NAME_FUNC_OFFSET( 13085, glGetUniformLocationARB, _gloffset_GetUniformLocationARB ), - NAME_FUNC_OFFSET( 13109, glGetActiveUniformARB, _gloffset_GetActiveUniformARB ), - NAME_FUNC_OFFSET( 13131, glGetUniformfvARB, _gloffset_GetUniformfvARB ), - NAME_FUNC_OFFSET( 13149, glGetUniformivARB, _gloffset_GetUniformivARB ), - NAME_FUNC_OFFSET( 13167, glGetShaderSourceARB, _gloffset_GetShaderSourceARB ), - NAME_FUNC_OFFSET( 13188, glBindAttribLocationARB, _gloffset_BindAttribLocationARB ), - NAME_FUNC_OFFSET( 13212, glGetActiveAttribARB, _gloffset_GetActiveAttribARB ), - NAME_FUNC_OFFSET( 13233, glGetAttribLocationARB, _gloffset_GetAttribLocationARB ), - NAME_FUNC_OFFSET( 13256, glActiveTexture, _gloffset_ActiveTextureARB ), - NAME_FUNC_OFFSET( 13272, glClientActiveTexture, _gloffset_ClientActiveTextureARB ), - NAME_FUNC_OFFSET( 13294, glMultiTexCoord1d, _gloffset_MultiTexCoord1dARB ), - NAME_FUNC_OFFSET( 13312, glMultiTexCoord1dv, _gloffset_MultiTexCoord1dvARB ), - NAME_FUNC_OFFSET( 13331, glMultiTexCoord1f, _gloffset_MultiTexCoord1fARB ), - NAME_FUNC_OFFSET( 13349, glMultiTexCoord1fv, _gloffset_MultiTexCoord1fvARB ), - NAME_FUNC_OFFSET( 13368, glMultiTexCoord1i, _gloffset_MultiTexCoord1iARB ), - NAME_FUNC_OFFSET( 13386, glMultiTexCoord1iv, _gloffset_MultiTexCoord1ivARB ), - NAME_FUNC_OFFSET( 13405, glMultiTexCoord1s, _gloffset_MultiTexCoord1sARB ), - NAME_FUNC_OFFSET( 13423, glMultiTexCoord1sv, _gloffset_MultiTexCoord1svARB ), - NAME_FUNC_OFFSET( 13442, glMultiTexCoord2d, _gloffset_MultiTexCoord2dARB ), - NAME_FUNC_OFFSET( 13460, glMultiTexCoord2dv, _gloffset_MultiTexCoord2dvARB ), - NAME_FUNC_OFFSET( 13479, glMultiTexCoord2f, _gloffset_MultiTexCoord2fARB ), - NAME_FUNC_OFFSET( 13497, glMultiTexCoord2fv, _gloffset_MultiTexCoord2fvARB ), - NAME_FUNC_OFFSET( 13516, glMultiTexCoord2i, _gloffset_MultiTexCoord2iARB ), - NAME_FUNC_OFFSET( 13534, glMultiTexCoord2iv, _gloffset_MultiTexCoord2ivARB ), - NAME_FUNC_OFFSET( 13553, glMultiTexCoord2s, _gloffset_MultiTexCoord2sARB ), - NAME_FUNC_OFFSET( 13571, glMultiTexCoord2sv, _gloffset_MultiTexCoord2svARB ), - NAME_FUNC_OFFSET( 13590, glMultiTexCoord3d, _gloffset_MultiTexCoord3dARB ), - NAME_FUNC_OFFSET( 13608, glMultiTexCoord3dv, _gloffset_MultiTexCoord3dvARB ), - NAME_FUNC_OFFSET( 13627, glMultiTexCoord3f, _gloffset_MultiTexCoord3fARB ), - NAME_FUNC_OFFSET( 13645, glMultiTexCoord3fv, _gloffset_MultiTexCoord3fvARB ), - NAME_FUNC_OFFSET( 13664, glMultiTexCoord3i, _gloffset_MultiTexCoord3iARB ), - NAME_FUNC_OFFSET( 13682, glMultiTexCoord3iv, _gloffset_MultiTexCoord3ivARB ), - NAME_FUNC_OFFSET( 13701, glMultiTexCoord3s, _gloffset_MultiTexCoord3sARB ), - NAME_FUNC_OFFSET( 13719, glMultiTexCoord3sv, _gloffset_MultiTexCoord3svARB ), - NAME_FUNC_OFFSET( 13738, glMultiTexCoord4d, _gloffset_MultiTexCoord4dARB ), - NAME_FUNC_OFFSET( 13756, glMultiTexCoord4dv, _gloffset_MultiTexCoord4dvARB ), - NAME_FUNC_OFFSET( 13775, glMultiTexCoord4f, _gloffset_MultiTexCoord4fARB ), - NAME_FUNC_OFFSET( 13793, glMultiTexCoord4fv, _gloffset_MultiTexCoord4fvARB ), - NAME_FUNC_OFFSET( 13812, glMultiTexCoord4i, _gloffset_MultiTexCoord4iARB ), - NAME_FUNC_OFFSET( 13830, glMultiTexCoord4iv, _gloffset_MultiTexCoord4ivARB ), - NAME_FUNC_OFFSET( 13849, glMultiTexCoord4s, _gloffset_MultiTexCoord4sARB ), - NAME_FUNC_OFFSET( 13867, glMultiTexCoord4sv, _gloffset_MultiTexCoord4svARB ), - NAME_FUNC_OFFSET( 13886, glLoadTransposeMatrixf, _gloffset_LoadTransposeMatrixfARB ), - NAME_FUNC_OFFSET( 13909, glLoadTransposeMatrixd, _gloffset_LoadTransposeMatrixdARB ), - NAME_FUNC_OFFSET( 13932, glMultTransposeMatrixf, _gloffset_MultTransposeMatrixfARB ), - NAME_FUNC_OFFSET( 13955, glMultTransposeMatrixd, _gloffset_MultTransposeMatrixdARB ), - NAME_FUNC_OFFSET( 13978, glSampleCoverage, _gloffset_SampleCoverageARB ), - NAME_FUNC_OFFSET( 13995, glCompressedTexImage3D, _gloffset_CompressedTexImage3DARB ), - NAME_FUNC_OFFSET( 14018, glCompressedTexImage2D, _gloffset_CompressedTexImage2DARB ), - NAME_FUNC_OFFSET( 14041, glCompressedTexImage1D, _gloffset_CompressedTexImage1DARB ), - NAME_FUNC_OFFSET( 14064, glCompressedTexSubImage3D, _gloffset_CompressedTexSubImage3DARB ), - NAME_FUNC_OFFSET( 14090, glCompressedTexSubImage2D, _gloffset_CompressedTexSubImage2DARB ), - NAME_FUNC_OFFSET( 14116, glCompressedTexSubImage1D, _gloffset_CompressedTexSubImage1DARB ), - NAME_FUNC_OFFSET( 14142, glGetCompressedTexImage, _gloffset_GetCompressedTexImageARB ), - NAME_FUNC_OFFSET( 14166, glBlendFuncSeparate, _gloffset_BlendFuncSeparateEXT ), - NAME_FUNC_OFFSET( 14186, glFogCoordf, _gloffset_FogCoordfEXT ), - NAME_FUNC_OFFSET( 14198, glFogCoordfv, _gloffset_FogCoordfvEXT ), - NAME_FUNC_OFFSET( 14211, glFogCoordd, _gloffset_FogCoorddEXT ), - NAME_FUNC_OFFSET( 14223, glFogCoorddv, _gloffset_FogCoorddvEXT ), - NAME_FUNC_OFFSET( 14236, glFogCoordPointer, _gloffset_FogCoordPointerEXT ), - NAME_FUNC_OFFSET( 14254, glMultiDrawArrays, _gloffset_MultiDrawArraysEXT ), - NAME_FUNC_OFFSET( 14272, glMultiDrawElements, _gloffset_MultiDrawElementsEXT ), - NAME_FUNC_OFFSET( 14292, glPointParameterf, _gloffset_PointParameterfEXT ), - NAME_FUNC_OFFSET( 14310, glPointParameterfv, _gloffset_PointParameterfvEXT ), - NAME_FUNC_OFFSET( 14329, glPointParameteri, _gloffset_PointParameteriNV ), - NAME_FUNC_OFFSET( 14347, glPointParameteriv, _gloffset_PointParameterivNV ), - NAME_FUNC_OFFSET( 14366, glSecondaryColor3b, _gloffset_SecondaryColor3bEXT ), - NAME_FUNC_OFFSET( 14385, glSecondaryColor3bv, _gloffset_SecondaryColor3bvEXT ), - NAME_FUNC_OFFSET( 14405, glSecondaryColor3d, _gloffset_SecondaryColor3dEXT ), - NAME_FUNC_OFFSET( 14424, glSecondaryColor3dv, _gloffset_SecondaryColor3dvEXT ), - NAME_FUNC_OFFSET( 14444, glSecondaryColor3f, _gloffset_SecondaryColor3fEXT ), - NAME_FUNC_OFFSET( 14463, glSecondaryColor3fv, _gloffset_SecondaryColor3fvEXT ), - NAME_FUNC_OFFSET( 14483, glSecondaryColor3i, _gloffset_SecondaryColor3iEXT ), - NAME_FUNC_OFFSET( 14502, glSecondaryColor3iv, _gloffset_SecondaryColor3ivEXT ), - NAME_FUNC_OFFSET( 14522, glSecondaryColor3s, _gloffset_SecondaryColor3sEXT ), - NAME_FUNC_OFFSET( 14541, glSecondaryColor3sv, _gloffset_SecondaryColor3svEXT ), - NAME_FUNC_OFFSET( 14561, glSecondaryColor3ub, _gloffset_SecondaryColor3ubEXT ), - NAME_FUNC_OFFSET( 14581, glSecondaryColor3ubv, _gloffset_SecondaryColor3ubvEXT ), - NAME_FUNC_OFFSET( 14602, glSecondaryColor3ui, _gloffset_SecondaryColor3uiEXT ), - NAME_FUNC_OFFSET( 14622, glSecondaryColor3uiv, _gloffset_SecondaryColor3uivEXT ), - NAME_FUNC_OFFSET( 14643, glSecondaryColor3us, _gloffset_SecondaryColor3usEXT ), - NAME_FUNC_OFFSET( 14663, glSecondaryColor3usv, _gloffset_SecondaryColor3usvEXT ), - NAME_FUNC_OFFSET( 14684, glSecondaryColorPointer, _gloffset_SecondaryColorPointerEXT ), - NAME_FUNC_OFFSET( 14708, glWindowPos2d, _gloffset_WindowPos2dMESA ), - NAME_FUNC_OFFSET( 14722, glWindowPos2dv, _gloffset_WindowPos2dvMESA ), - NAME_FUNC_OFFSET( 14737, glWindowPos2f, _gloffset_WindowPos2fMESA ), - NAME_FUNC_OFFSET( 14751, glWindowPos2fv, _gloffset_WindowPos2fvMESA ), - NAME_FUNC_OFFSET( 14766, glWindowPos2i, _gloffset_WindowPos2iMESA ), - NAME_FUNC_OFFSET( 14780, glWindowPos2iv, _gloffset_WindowPos2ivMESA ), - NAME_FUNC_OFFSET( 14795, glWindowPos2s, _gloffset_WindowPos2sMESA ), - NAME_FUNC_OFFSET( 14809, glWindowPos2sv, _gloffset_WindowPos2svMESA ), - NAME_FUNC_OFFSET( 14824, glWindowPos3d, _gloffset_WindowPos3dMESA ), - NAME_FUNC_OFFSET( 14838, glWindowPos3dv, _gloffset_WindowPos3dvMESA ), - NAME_FUNC_OFFSET( 14853, glWindowPos3f, _gloffset_WindowPos3fMESA ), - NAME_FUNC_OFFSET( 14867, glWindowPos3fv, _gloffset_WindowPos3fvMESA ), - NAME_FUNC_OFFSET( 14882, glWindowPos3i, _gloffset_WindowPos3iMESA ), - NAME_FUNC_OFFSET( 14896, glWindowPos3iv, _gloffset_WindowPos3ivMESA ), - NAME_FUNC_OFFSET( 14911, glWindowPos3s, _gloffset_WindowPos3sMESA ), - NAME_FUNC_OFFSET( 14925, glWindowPos3sv, _gloffset_WindowPos3svMESA ), - NAME_FUNC_OFFSET( 14940, glBindBuffer, _gloffset_BindBufferARB ), - NAME_FUNC_OFFSET( 14953, glBufferData, _gloffset_BufferDataARB ), - NAME_FUNC_OFFSET( 14966, glBufferSubData, _gloffset_BufferSubDataARB ), - NAME_FUNC_OFFSET( 14982, glDeleteBuffers, _gloffset_DeleteBuffersARB ), - NAME_FUNC_OFFSET( 14998, glGenBuffers, _gloffset_GenBuffersARB ), - NAME_FUNC_OFFSET( 15011, glGetBufferParameteriv, _gloffset_GetBufferParameterivARB ), - NAME_FUNC_OFFSET( 15034, glGetBufferPointerv, _gloffset_GetBufferPointervARB ), - NAME_FUNC_OFFSET( 15054, glGetBufferSubData, _gloffset_GetBufferSubDataARB ), - NAME_FUNC_OFFSET( 15073, glIsBuffer, _gloffset_IsBufferARB ), - NAME_FUNC_OFFSET( 15084, glMapBuffer, _gloffset_MapBufferARB ), - NAME_FUNC_OFFSET( 15096, glUnmapBuffer, _gloffset_UnmapBufferARB ), - NAME_FUNC_OFFSET( 15110, glGenQueries, _gloffset_GenQueriesARB ), - NAME_FUNC_OFFSET( 15123, glDeleteQueries, _gloffset_DeleteQueriesARB ), - NAME_FUNC_OFFSET( 15139, glIsQuery, _gloffset_IsQueryARB ), - NAME_FUNC_OFFSET( 15149, glBeginQuery, _gloffset_BeginQueryARB ), - NAME_FUNC_OFFSET( 15162, glEndQuery, _gloffset_EndQueryARB ), - NAME_FUNC_OFFSET( 15173, glGetQueryiv, _gloffset_GetQueryivARB ), - NAME_FUNC_OFFSET( 15186, glGetQueryObjectiv, _gloffset_GetQueryObjectivARB ), - NAME_FUNC_OFFSET( 15205, glGetQueryObjectuiv, _gloffset_GetQueryObjectuivARB ), - NAME_FUNC_OFFSET( 15225, glPointParameterfARB, _gloffset_PointParameterfEXT ), - NAME_FUNC_OFFSET( 15246, glPointParameterfvARB, _gloffset_PointParameterfvEXT ), - NAME_FUNC_OFFSET( 15268, glWindowPos2dARB, _gloffset_WindowPos2dMESA ), - NAME_FUNC_OFFSET( 15285, glWindowPos2fARB, _gloffset_WindowPos2fMESA ), - NAME_FUNC_OFFSET( 15302, glWindowPos2iARB, _gloffset_WindowPos2iMESA ), - NAME_FUNC_OFFSET( 15319, glWindowPos2sARB, _gloffset_WindowPos2sMESA ), - NAME_FUNC_OFFSET( 15336, glWindowPos2dvARB, _gloffset_WindowPos2dvMESA ), - NAME_FUNC_OFFSET( 15354, glWindowPos2fvARB, _gloffset_WindowPos2fvMESA ), - NAME_FUNC_OFFSET( 15372, glWindowPos2ivARB, _gloffset_WindowPos2ivMESA ), - NAME_FUNC_OFFSET( 15390, glWindowPos2svARB, _gloffset_WindowPos2svMESA ), - NAME_FUNC_OFFSET( 15408, glWindowPos3dARB, _gloffset_WindowPos3dMESA ), - NAME_FUNC_OFFSET( 15425, glWindowPos3fARB, _gloffset_WindowPos3fMESA ), - NAME_FUNC_OFFSET( 15442, glWindowPos3iARB, _gloffset_WindowPos3iMESA ), - NAME_FUNC_OFFSET( 15459, glWindowPos3sARB, _gloffset_WindowPos3sMESA ), - NAME_FUNC_OFFSET( 15476, glWindowPos3dvARB, _gloffset_WindowPos3dvMESA ), - NAME_FUNC_OFFSET( 15494, glWindowPos3fvARB, _gloffset_WindowPos3fvMESA ), - NAME_FUNC_OFFSET( 15512, glWindowPos3ivARB, _gloffset_WindowPos3ivMESA ), - NAME_FUNC_OFFSET( 15530, glWindowPos3svARB, _gloffset_WindowPos3svMESA ), - NAME_FUNC_OFFSET( 15548, glVertexAttrib1sARB, _gloffset_VertexAttrib1sNV ), - NAME_FUNC_OFFSET( 15568, glVertexAttrib1fARB, _gloffset_VertexAttrib1fNV ), - NAME_FUNC_OFFSET( 15588, glVertexAttrib1dARB, _gloffset_VertexAttrib1dNV ), - NAME_FUNC_OFFSET( 15608, glVertexAttrib2sARB, _gloffset_VertexAttrib2sNV ), - NAME_FUNC_OFFSET( 15628, glVertexAttrib2fARB, _gloffset_VertexAttrib2fNV ), - NAME_FUNC_OFFSET( 15648, glVertexAttrib2dARB, _gloffset_VertexAttrib2dNV ), - NAME_FUNC_OFFSET( 15668, glVertexAttrib3sARB, _gloffset_VertexAttrib3sNV ), - NAME_FUNC_OFFSET( 15688, glVertexAttrib3fARB, _gloffset_VertexAttrib3fNV ), - NAME_FUNC_OFFSET( 15708, glVertexAttrib3dARB, _gloffset_VertexAttrib3dNV ), - NAME_FUNC_OFFSET( 15728, glVertexAttrib4sARB, _gloffset_VertexAttrib4sNV ), - NAME_FUNC_OFFSET( 15748, glVertexAttrib4fARB, _gloffset_VertexAttrib4fNV ), - NAME_FUNC_OFFSET( 15768, glVertexAttrib4dARB, _gloffset_VertexAttrib4dNV ), - NAME_FUNC_OFFSET( 15788, glVertexAttrib4NubARB, _gloffset_VertexAttrib4ubNV ), - NAME_FUNC_OFFSET( 15810, glVertexAttrib1svARB, _gloffset_VertexAttrib1svNV ), - NAME_FUNC_OFFSET( 15831, glVertexAttrib1fvARB, _gloffset_VertexAttrib1fvNV ), - NAME_FUNC_OFFSET( 15852, glVertexAttrib1dvARB, _gloffset_VertexAttrib1dvNV ), - NAME_FUNC_OFFSET( 15873, glVertexAttrib2svARB, _gloffset_VertexAttrib2svNV ), - NAME_FUNC_OFFSET( 15894, glVertexAttrib2fvARB, _gloffset_VertexAttrib2fvNV ), - NAME_FUNC_OFFSET( 15915, glVertexAttrib2dvARB, _gloffset_VertexAttrib2dvNV ), - NAME_FUNC_OFFSET( 15936, glVertexAttrib3svARB, _gloffset_VertexAttrib3svNV ), - NAME_FUNC_OFFSET( 15957, glVertexAttrib3fvARB, _gloffset_VertexAttrib3fvNV ), - NAME_FUNC_OFFSET( 15978, glVertexAttrib3dvARB, _gloffset_VertexAttrib3dvNV ), - NAME_FUNC_OFFSET( 15999, glVertexAttrib4svARB, _gloffset_VertexAttrib4svNV ), - NAME_FUNC_OFFSET( 16020, glVertexAttrib4fvARB, _gloffset_VertexAttrib4fvNV ), - NAME_FUNC_OFFSET( 16041, glVertexAttrib4dvARB, _gloffset_VertexAttrib4dvNV ), - NAME_FUNC_OFFSET( 16062, glVertexAttrib4NubvARB, _gloffset_VertexAttrib4ubvNV ), - NAME_FUNC_OFFSET( 16085, glBindProgramARB, _gloffset_BindProgramNV ), - NAME_FUNC_OFFSET( 16102, glDeleteProgramsARB, _gloffset_DeleteProgramsNV ), - NAME_FUNC_OFFSET( 16122, glGenProgramsARB, _gloffset_GenProgramsNV ), - NAME_FUNC_OFFSET( 16139, glIsProgramARB, _gloffset_IsProgramNV ), - NAME_FUNC_OFFSET( 16154, glGetVertexAttribdvARB, _gloffset_GetVertexAttribdvNV ), - NAME_FUNC_OFFSET( 16177, glGetVertexAttribfvARB, _gloffset_GetVertexAttribfvNV ), - NAME_FUNC_OFFSET( 16200, glGetVertexAttribivARB, _gloffset_GetVertexAttribivNV ), + NAME_FUNC_OFFSET( 9807, glGetVertexAttribdvARB, _gloffset_GetVertexAttribdvARB ), + NAME_FUNC_OFFSET( 9830, glGetVertexAttribfvARB, _gloffset_GetVertexAttribfvARB ), + NAME_FUNC_OFFSET( 9853, glGetVertexAttribivARB, _gloffset_GetVertexAttribivARB ), + NAME_FUNC_OFFSET( 9876, glGetVertexAttribPointervNV, _gloffset_GetVertexAttribPointervNV ), + NAME_FUNC_OFFSET( 9904, glIsProgramNV, _gloffset_IsProgramNV ), + NAME_FUNC_OFFSET( 9918, glLoadProgramNV, _gloffset_LoadProgramNV ), + NAME_FUNC_OFFSET( 9934, glProgramParameter4dNV, _gloffset_ProgramParameter4dNV ), + NAME_FUNC_OFFSET( 9957, glProgramParameter4dvNV, _gloffset_ProgramParameter4dvNV ), + NAME_FUNC_OFFSET( 9981, glProgramParameter4fNV, _gloffset_ProgramParameter4fNV ), + NAME_FUNC_OFFSET( 10004, glProgramParameter4fvNV, _gloffset_ProgramParameter4fvNV ), + NAME_FUNC_OFFSET( 10028, glProgramParameters4dvNV, _gloffset_ProgramParameters4dvNV ), + NAME_FUNC_OFFSET( 10053, glProgramParameters4fvNV, _gloffset_ProgramParameters4fvNV ), + NAME_FUNC_OFFSET( 10078, glRequestResidentProgramsNV, _gloffset_RequestResidentProgramsNV ), + NAME_FUNC_OFFSET( 10106, glTrackMatrixNV, _gloffset_TrackMatrixNV ), + NAME_FUNC_OFFSET( 10122, glVertexAttribPointerNV, _gloffset_VertexAttribPointerNV ), + NAME_FUNC_OFFSET( 10146, glVertexAttrib1dARB, _gloffset_VertexAttrib1dARB ), + NAME_FUNC_OFFSET( 10166, glVertexAttrib1dvARB, _gloffset_VertexAttrib1dvARB ), + NAME_FUNC_OFFSET( 10187, glVertexAttrib1fARB, _gloffset_VertexAttrib1fARB ), + NAME_FUNC_OFFSET( 10207, glVertexAttrib1fvARB, _gloffset_VertexAttrib1fvARB ), + NAME_FUNC_OFFSET( 10228, glVertexAttrib1sARB, _gloffset_VertexAttrib1sARB ), + NAME_FUNC_OFFSET( 10248, glVertexAttrib1svARB, _gloffset_VertexAttrib1svARB ), + NAME_FUNC_OFFSET( 10269, glVertexAttrib2dARB, _gloffset_VertexAttrib2dARB ), + NAME_FUNC_OFFSET( 10289, glVertexAttrib2dvARB, _gloffset_VertexAttrib2dvARB ), + NAME_FUNC_OFFSET( 10310, glVertexAttrib2fARB, _gloffset_VertexAttrib2fARB ), + NAME_FUNC_OFFSET( 10330, glVertexAttrib2fvARB, _gloffset_VertexAttrib2fvARB ), + NAME_FUNC_OFFSET( 10351, glVertexAttrib2sARB, _gloffset_VertexAttrib2sARB ), + NAME_FUNC_OFFSET( 10371, glVertexAttrib2svARB, _gloffset_VertexAttrib2svARB ), + NAME_FUNC_OFFSET( 10392, glVertexAttrib3dARB, _gloffset_VertexAttrib3dARB ), + NAME_FUNC_OFFSET( 10412, glVertexAttrib3dvARB, _gloffset_VertexAttrib3dvARB ), + NAME_FUNC_OFFSET( 10433, glVertexAttrib3fARB, _gloffset_VertexAttrib3fARB ), + NAME_FUNC_OFFSET( 10453, glVertexAttrib3fvARB, _gloffset_VertexAttrib3fvARB ), + NAME_FUNC_OFFSET( 10474, glVertexAttrib3sARB, _gloffset_VertexAttrib3sARB ), + NAME_FUNC_OFFSET( 10494, glVertexAttrib3svARB, _gloffset_VertexAttrib3svARB ), + NAME_FUNC_OFFSET( 10515, glVertexAttrib4dARB, _gloffset_VertexAttrib4dARB ), + NAME_FUNC_OFFSET( 10535, glVertexAttrib4dvARB, _gloffset_VertexAttrib4dvARB ), + NAME_FUNC_OFFSET( 10556, glVertexAttrib4fARB, _gloffset_VertexAttrib4fARB ), + NAME_FUNC_OFFSET( 10576, glVertexAttrib4fvARB, _gloffset_VertexAttrib4fvARB ), + NAME_FUNC_OFFSET( 10597, glVertexAttrib4sARB, _gloffset_VertexAttrib4sARB ), + NAME_FUNC_OFFSET( 10617, glVertexAttrib4svARB, _gloffset_VertexAttrib4svARB ), + NAME_FUNC_OFFSET( 10638, glVertexAttrib4NubARB, _gloffset_VertexAttrib4NubARB ), + NAME_FUNC_OFFSET( 10660, glVertexAttrib4NubvARB, _gloffset_VertexAttrib4NubvARB ), + NAME_FUNC_OFFSET( 10683, glVertexAttribs1dvNV, _gloffset_VertexAttribs1dvNV ), + NAME_FUNC_OFFSET( 10704, glVertexAttribs1fvNV, _gloffset_VertexAttribs1fvNV ), + NAME_FUNC_OFFSET( 10725, glVertexAttribs1svNV, _gloffset_VertexAttribs1svNV ), + NAME_FUNC_OFFSET( 10746, glVertexAttribs2dvNV, _gloffset_VertexAttribs2dvNV ), + NAME_FUNC_OFFSET( 10767, glVertexAttribs2fvNV, _gloffset_VertexAttribs2fvNV ), + NAME_FUNC_OFFSET( 10788, glVertexAttribs2svNV, _gloffset_VertexAttribs2svNV ), + NAME_FUNC_OFFSET( 10809, glVertexAttribs3dvNV, _gloffset_VertexAttribs3dvNV ), + NAME_FUNC_OFFSET( 10830, glVertexAttribs3fvNV, _gloffset_VertexAttribs3fvNV ), + NAME_FUNC_OFFSET( 10851, glVertexAttribs3svNV, _gloffset_VertexAttribs3svNV ), + NAME_FUNC_OFFSET( 10872, glVertexAttribs4dvNV, _gloffset_VertexAttribs4dvNV ), + NAME_FUNC_OFFSET( 10893, glVertexAttribs4fvNV, _gloffset_VertexAttribs4fvNV ), + NAME_FUNC_OFFSET( 10914, glVertexAttribs4svNV, _gloffset_VertexAttribs4svNV ), + NAME_FUNC_OFFSET( 10935, glVertexAttribs4ubvNV, _gloffset_VertexAttribs4ubvNV ), + NAME_FUNC_OFFSET( 10957, glPointParameteriNV, _gloffset_PointParameteriNV ), + NAME_FUNC_OFFSET( 10977, glPointParameterivNV, _gloffset_PointParameterivNV ), + NAME_FUNC_OFFSET( 10998, glMultiDrawArraysEXT, _gloffset_MultiDrawArraysEXT ), + NAME_FUNC_OFFSET( 11019, glMultiDrawElementsEXT, _gloffset_MultiDrawElementsEXT ), + NAME_FUNC_OFFSET( 11042, glActiveStencilFaceEXT, _gloffset_ActiveStencilFaceEXT ), + NAME_FUNC_OFFSET( 11065, glDeleteFencesNV, _gloffset_DeleteFencesNV ), + NAME_FUNC_OFFSET( 11082, glGenFencesNV, _gloffset_GenFencesNV ), + NAME_FUNC_OFFSET( 11096, glIsFenceNV, _gloffset_IsFenceNV ), + NAME_FUNC_OFFSET( 11108, glTestFenceNV, _gloffset_TestFenceNV ), + NAME_FUNC_OFFSET( 11122, glGetFenceivNV, _gloffset_GetFenceivNV ), + NAME_FUNC_OFFSET( 11137, glFinishFenceNV, _gloffset_FinishFenceNV ), + NAME_FUNC_OFFSET( 11153, glSetFenceNV, _gloffset_SetFenceNV ), + NAME_FUNC_OFFSET( 11166, glVertexAttrib4bvARB, _gloffset_VertexAttrib4bvARB ), + NAME_FUNC_OFFSET( 11187, glVertexAttrib4ivARB, _gloffset_VertexAttrib4ivARB ), + NAME_FUNC_OFFSET( 11208, glVertexAttrib4ubvARB, _gloffset_VertexAttrib4ubvARB ), + NAME_FUNC_OFFSET( 11230, glVertexAttrib4usvARB, _gloffset_VertexAttrib4usvARB ), + NAME_FUNC_OFFSET( 11252, glVertexAttrib4uivARB, _gloffset_VertexAttrib4uivARB ), + NAME_FUNC_OFFSET( 11274, glVertexAttrib4NbvARB, _gloffset_VertexAttrib4NbvARB ), + NAME_FUNC_OFFSET( 11296, glVertexAttrib4NsvARB, _gloffset_VertexAttrib4NsvARB ), + NAME_FUNC_OFFSET( 11318, glVertexAttrib4NivARB, _gloffset_VertexAttrib4NivARB ), + NAME_FUNC_OFFSET( 11340, glVertexAttrib4NusvARB, _gloffset_VertexAttrib4NusvARB ), + NAME_FUNC_OFFSET( 11363, glVertexAttrib4NuivARB, _gloffset_VertexAttrib4NuivARB ), + NAME_FUNC_OFFSET( 11386, glVertexAttribPointerARB, _gloffset_VertexAttribPointerARB ), + NAME_FUNC_OFFSET( 11411, glEnableVertexAttribArrayARB, _gloffset_EnableVertexAttribArrayARB ), + NAME_FUNC_OFFSET( 11440, glDisableVertexAttribArrayARB, _gloffset_DisableVertexAttribArrayARB ), + NAME_FUNC_OFFSET( 11470, glProgramStringARB, _gloffset_ProgramStringARB ), + NAME_FUNC_OFFSET( 11489, glProgramEnvParameter4dARB, _gloffset_ProgramEnvParameter4dARB ), + NAME_FUNC_OFFSET( 11516, glProgramEnvParameter4dvARB, _gloffset_ProgramEnvParameter4dvARB ), + NAME_FUNC_OFFSET( 11544, glProgramEnvParameter4fARB, _gloffset_ProgramEnvParameter4fARB ), + NAME_FUNC_OFFSET( 11571, glProgramEnvParameter4fvARB, _gloffset_ProgramEnvParameter4fvARB ), + NAME_FUNC_OFFSET( 11599, glProgramLocalParameter4dARB, _gloffset_ProgramLocalParameter4dARB ), + NAME_FUNC_OFFSET( 11628, glProgramLocalParameter4dvARB, _gloffset_ProgramLocalParameter4dvARB ), + NAME_FUNC_OFFSET( 11658, glProgramLocalParameter4fARB, _gloffset_ProgramLocalParameter4fARB ), + NAME_FUNC_OFFSET( 11687, glProgramLocalParameter4fvARB, _gloffset_ProgramLocalParameter4fvARB ), + NAME_FUNC_OFFSET( 11717, glGetProgramEnvParameterdvARB, _gloffset_GetProgramEnvParameterdvARB ), + NAME_FUNC_OFFSET( 11747, glGetProgramEnvParameterfvARB, _gloffset_GetProgramEnvParameterfvARB ), + NAME_FUNC_OFFSET( 11777, glGetProgramLocalParameterdvARB, _gloffset_GetProgramLocalParameterdvARB ), + NAME_FUNC_OFFSET( 11809, glGetProgramLocalParameterfvARB, _gloffset_GetProgramLocalParameterfvARB ), + NAME_FUNC_OFFSET( 11841, glGetProgramivARB, _gloffset_GetProgramivARB ), + NAME_FUNC_OFFSET( 11859, glGetProgramStringARB, _gloffset_GetProgramStringARB ), + NAME_FUNC_OFFSET( 11881, glProgramNamedParameter4fNV, _gloffset_ProgramNamedParameter4fNV ), + NAME_FUNC_OFFSET( 11909, glProgramNamedParameter4dNV, _gloffset_ProgramNamedParameter4dNV ), + NAME_FUNC_OFFSET( 11937, glProgramNamedParameter4fvNV, _gloffset_ProgramNamedParameter4fvNV ), + NAME_FUNC_OFFSET( 11966, glProgramNamedParameter4dvNV, _gloffset_ProgramNamedParameter4dvNV ), + NAME_FUNC_OFFSET( 11995, glGetProgramNamedParameterfvNV, _gloffset_GetProgramNamedParameterfvNV ), + NAME_FUNC_OFFSET( 12026, glGetProgramNamedParameterdvNV, _gloffset_GetProgramNamedParameterdvNV ), + NAME_FUNC_OFFSET( 12057, glBindBufferARB, _gloffset_BindBufferARB ), + NAME_FUNC_OFFSET( 12073, glBufferDataARB, _gloffset_BufferDataARB ), + NAME_FUNC_OFFSET( 12089, glBufferSubDataARB, _gloffset_BufferSubDataARB ), + NAME_FUNC_OFFSET( 12108, glDeleteBuffersARB, _gloffset_DeleteBuffersARB ), + NAME_FUNC_OFFSET( 12127, glGenBuffersARB, _gloffset_GenBuffersARB ), + NAME_FUNC_OFFSET( 12143, glGetBufferParameterivARB, _gloffset_GetBufferParameterivARB ), + NAME_FUNC_OFFSET( 12169, glGetBufferPointervARB, _gloffset_GetBufferPointervARB ), + NAME_FUNC_OFFSET( 12192, glGetBufferSubDataARB, _gloffset_GetBufferSubDataARB ), + NAME_FUNC_OFFSET( 12214, glIsBufferARB, _gloffset_IsBufferARB ), + NAME_FUNC_OFFSET( 12228, glMapBufferARB, _gloffset_MapBufferARB ), + NAME_FUNC_OFFSET( 12243, glUnmapBufferARB, _gloffset_UnmapBufferARB ), + NAME_FUNC_OFFSET( 12260, glDepthBoundsEXT, _gloffset_DepthBoundsEXT ), + NAME_FUNC_OFFSET( 12277, glGenQueriesARB, _gloffset_GenQueriesARB ), + NAME_FUNC_OFFSET( 12293, glDeleteQueriesARB, _gloffset_DeleteQueriesARB ), + NAME_FUNC_OFFSET( 12312, glIsQueryARB, _gloffset_IsQueryARB ), + NAME_FUNC_OFFSET( 12325, glBeginQueryARB, _gloffset_BeginQueryARB ), + NAME_FUNC_OFFSET( 12341, glEndQueryARB, _gloffset_EndQueryARB ), + NAME_FUNC_OFFSET( 12355, glGetQueryivARB, _gloffset_GetQueryivARB ), + NAME_FUNC_OFFSET( 12371, glGetQueryObjectivARB, _gloffset_GetQueryObjectivARB ), + NAME_FUNC_OFFSET( 12393, glGetQueryObjectuivARB, _gloffset_GetQueryObjectuivARB ), + NAME_FUNC_OFFSET( 12416, glMultiModeDrawArraysIBM, _gloffset_MultiModeDrawArraysIBM ), + NAME_FUNC_OFFSET( 12441, glMultiModeDrawElementsIBM, _gloffset_MultiModeDrawElementsIBM ), + NAME_FUNC_OFFSET( 12468, glBlendEquationSeparateEXT, _gloffset_BlendEquationSeparateEXT ), + NAME_FUNC_OFFSET( 12495, glDeleteObjectARB, _gloffset_DeleteObjectARB ), + NAME_FUNC_OFFSET( 12513, glGetHandleARB, _gloffset_GetHandleARB ), + NAME_FUNC_OFFSET( 12528, glDetachObjectARB, _gloffset_DetachObjectARB ), + NAME_FUNC_OFFSET( 12546, glCreateShaderObjectARB, _gloffset_CreateShaderObjectARB ), + NAME_FUNC_OFFSET( 12570, glShaderSourceARB, _gloffset_ShaderSourceARB ), + NAME_FUNC_OFFSET( 12588, glCompileShaderARB, _gloffset_CompileShaderARB ), + NAME_FUNC_OFFSET( 12607, glCreateProgramObjectARB, _gloffset_CreateProgramObjectARB ), + NAME_FUNC_OFFSET( 12632, glAttachObjectARB, _gloffset_AttachObjectARB ), + NAME_FUNC_OFFSET( 12650, glLinkProgramARB, _gloffset_LinkProgramARB ), + NAME_FUNC_OFFSET( 12667, glUseProgramObjectARB, _gloffset_UseProgramObjectARB ), + NAME_FUNC_OFFSET( 12689, glValidateProgramARB, _gloffset_ValidateProgramARB ), + NAME_FUNC_OFFSET( 12710, glUniform1fARB, _gloffset_Uniform1fARB ), + NAME_FUNC_OFFSET( 12725, glUniform2fARB, _gloffset_Uniform2fARB ), + NAME_FUNC_OFFSET( 12740, glUniform3fARB, _gloffset_Uniform3fARB ), + NAME_FUNC_OFFSET( 12755, glUniform4fARB, _gloffset_Uniform4fARB ), + NAME_FUNC_OFFSET( 12770, glUniform1iARB, _gloffset_Uniform1iARB ), + NAME_FUNC_OFFSET( 12785, glUniform2iARB, _gloffset_Uniform2iARB ), + NAME_FUNC_OFFSET( 12800, glUniform3iARB, _gloffset_Uniform3iARB ), + NAME_FUNC_OFFSET( 12815, glUniform4iARB, _gloffset_Uniform4iARB ), + NAME_FUNC_OFFSET( 12830, glUniform1fvARB, _gloffset_Uniform1fvARB ), + NAME_FUNC_OFFSET( 12846, glUniform2fvARB, _gloffset_Uniform2fvARB ), + NAME_FUNC_OFFSET( 12862, glUniform3fvARB, _gloffset_Uniform3fvARB ), + NAME_FUNC_OFFSET( 12878, glUniform4fvARB, _gloffset_Uniform4fvARB ), + NAME_FUNC_OFFSET( 12894, glUniform1ivARB, _gloffset_Uniform1ivARB ), + NAME_FUNC_OFFSET( 12910, glUniform2ivARB, _gloffset_Uniform2ivARB ), + NAME_FUNC_OFFSET( 12926, glUniform3ivARB, _gloffset_Uniform3ivARB ), + NAME_FUNC_OFFSET( 12942, glUniform4ivARB, _gloffset_Uniform4ivARB ), + NAME_FUNC_OFFSET( 12958, glUniformMatrix2fvARB, _gloffset_UniformMatrix2fvARB ), + NAME_FUNC_OFFSET( 12980, glUniformMatrix3fvARB, _gloffset_UniformMatrix3fvARB ), + NAME_FUNC_OFFSET( 13002, glUniformMatrix4fvARB, _gloffset_UniformMatrix4fvARB ), + NAME_FUNC_OFFSET( 13024, glGetObjectParameterfvARB, _gloffset_GetObjectParameterfvARB ), + NAME_FUNC_OFFSET( 13050, glGetObjectParameterivARB, _gloffset_GetObjectParameterivARB ), + NAME_FUNC_OFFSET( 13076, glGetInfoLogARB, _gloffset_GetInfoLogARB ), + NAME_FUNC_OFFSET( 13092, glGetAttachedObjectsARB, _gloffset_GetAttachedObjectsARB ), + NAME_FUNC_OFFSET( 13116, glGetUniformLocationARB, _gloffset_GetUniformLocationARB ), + NAME_FUNC_OFFSET( 13140, glGetActiveUniformARB, _gloffset_GetActiveUniformARB ), + NAME_FUNC_OFFSET( 13162, glGetUniformfvARB, _gloffset_GetUniformfvARB ), + NAME_FUNC_OFFSET( 13180, glGetUniformivARB, _gloffset_GetUniformivARB ), + NAME_FUNC_OFFSET( 13198, glGetShaderSourceARB, _gloffset_GetShaderSourceARB ), + NAME_FUNC_OFFSET( 13219, glBindAttribLocationARB, _gloffset_BindAttribLocationARB ), + NAME_FUNC_OFFSET( 13243, glGetActiveAttribARB, _gloffset_GetActiveAttribARB ), + NAME_FUNC_OFFSET( 13264, glGetAttribLocationARB, _gloffset_GetAttribLocationARB ), + NAME_FUNC_OFFSET( 13287, glGetVertexAttribdvNV, _gloffset_GetVertexAttribdvNV ), + NAME_FUNC_OFFSET( 13309, glGetVertexAttribfvNV, _gloffset_GetVertexAttribfvNV ), + NAME_FUNC_OFFSET( 13331, glGetVertexAttribivNV, _gloffset_GetVertexAttribivNV ), + NAME_FUNC_OFFSET( 13353, glVertexAttrib1dNV, _gloffset_VertexAttrib1dNV ), + NAME_FUNC_OFFSET( 13372, glVertexAttrib1dvNV, _gloffset_VertexAttrib1dvNV ), + NAME_FUNC_OFFSET( 13392, glVertexAttrib1fNV, _gloffset_VertexAttrib1fNV ), + NAME_FUNC_OFFSET( 13411, glVertexAttrib1fvNV, _gloffset_VertexAttrib1fvNV ), + NAME_FUNC_OFFSET( 13431, glVertexAttrib1sNV, _gloffset_VertexAttrib1sNV ), + NAME_FUNC_OFFSET( 13450, glVertexAttrib1svNV, _gloffset_VertexAttrib1svNV ), + NAME_FUNC_OFFSET( 13470, glVertexAttrib2dNV, _gloffset_VertexAttrib2dNV ), + NAME_FUNC_OFFSET( 13489, glVertexAttrib2dvNV, _gloffset_VertexAttrib2dvNV ), + NAME_FUNC_OFFSET( 13509, glVertexAttrib2fNV, _gloffset_VertexAttrib2fNV ), + NAME_FUNC_OFFSET( 13528, glVertexAttrib2fvNV, _gloffset_VertexAttrib2fvNV ), + NAME_FUNC_OFFSET( 13548, glVertexAttrib2sNV, _gloffset_VertexAttrib2sNV ), + NAME_FUNC_OFFSET( 13567, glVertexAttrib2svNV, _gloffset_VertexAttrib2svNV ), + NAME_FUNC_OFFSET( 13587, glVertexAttrib3dNV, _gloffset_VertexAttrib3dNV ), + NAME_FUNC_OFFSET( 13606, glVertexAttrib3dvNV, _gloffset_VertexAttrib3dvNV ), + NAME_FUNC_OFFSET( 13626, glVertexAttrib3fNV, _gloffset_VertexAttrib3fNV ), + NAME_FUNC_OFFSET( 13645, glVertexAttrib3fvNV, _gloffset_VertexAttrib3fvNV ), + NAME_FUNC_OFFSET( 13665, glVertexAttrib3sNV, _gloffset_VertexAttrib3sNV ), + NAME_FUNC_OFFSET( 13684, glVertexAttrib3svNV, _gloffset_VertexAttrib3svNV ), + NAME_FUNC_OFFSET( 13704, glVertexAttrib4dNV, _gloffset_VertexAttrib4dNV ), + NAME_FUNC_OFFSET( 13723, glVertexAttrib4dvNV, _gloffset_VertexAttrib4dvNV ), + NAME_FUNC_OFFSET( 13743, glVertexAttrib4fNV, _gloffset_VertexAttrib4fNV ), + NAME_FUNC_OFFSET( 13762, glVertexAttrib4fvNV, _gloffset_VertexAttrib4fvNV ), + NAME_FUNC_OFFSET( 13782, glVertexAttrib4sNV, _gloffset_VertexAttrib4sNV ), + NAME_FUNC_OFFSET( 13801, glVertexAttrib4svNV, _gloffset_VertexAttrib4svNV ), + NAME_FUNC_OFFSET( 13821, glVertexAttrib4ubNV, _gloffset_VertexAttrib4ubNV ), + NAME_FUNC_OFFSET( 13841, glVertexAttrib4ubvNV, _gloffset_VertexAttrib4ubvNV ), + NAME_FUNC_OFFSET( 13862, glActiveTexture, _gloffset_ActiveTextureARB ), + NAME_FUNC_OFFSET( 13878, glClientActiveTexture, _gloffset_ClientActiveTextureARB ), + NAME_FUNC_OFFSET( 13900, glMultiTexCoord1d, _gloffset_MultiTexCoord1dARB ), + NAME_FUNC_OFFSET( 13918, glMultiTexCoord1dv, _gloffset_MultiTexCoord1dvARB ), + NAME_FUNC_OFFSET( 13937, glMultiTexCoord1f, _gloffset_MultiTexCoord1fARB ), + NAME_FUNC_OFFSET( 13955, glMultiTexCoord1fv, _gloffset_MultiTexCoord1fvARB ), + NAME_FUNC_OFFSET( 13974, glMultiTexCoord1i, _gloffset_MultiTexCoord1iARB ), + NAME_FUNC_OFFSET( 13992, glMultiTexCoord1iv, _gloffset_MultiTexCoord1ivARB ), + NAME_FUNC_OFFSET( 14011, glMultiTexCoord1s, _gloffset_MultiTexCoord1sARB ), + NAME_FUNC_OFFSET( 14029, glMultiTexCoord1sv, _gloffset_MultiTexCoord1svARB ), + NAME_FUNC_OFFSET( 14048, glMultiTexCoord2d, _gloffset_MultiTexCoord2dARB ), + NAME_FUNC_OFFSET( 14066, glMultiTexCoord2dv, _gloffset_MultiTexCoord2dvARB ), + NAME_FUNC_OFFSET( 14085, glMultiTexCoord2f, _gloffset_MultiTexCoord2fARB ), + NAME_FUNC_OFFSET( 14103, glMultiTexCoord2fv, _gloffset_MultiTexCoord2fvARB ), + NAME_FUNC_OFFSET( 14122, glMultiTexCoord2i, _gloffset_MultiTexCoord2iARB ), + NAME_FUNC_OFFSET( 14140, glMultiTexCoord2iv, _gloffset_MultiTexCoord2ivARB ), + NAME_FUNC_OFFSET( 14159, glMultiTexCoord2s, _gloffset_MultiTexCoord2sARB ), + NAME_FUNC_OFFSET( 14177, glMultiTexCoord2sv, _gloffset_MultiTexCoord2svARB ), + NAME_FUNC_OFFSET( 14196, glMultiTexCoord3d, _gloffset_MultiTexCoord3dARB ), + NAME_FUNC_OFFSET( 14214, glMultiTexCoord3dv, _gloffset_MultiTexCoord3dvARB ), + NAME_FUNC_OFFSET( 14233, glMultiTexCoord3f, _gloffset_MultiTexCoord3fARB ), + NAME_FUNC_OFFSET( 14251, glMultiTexCoord3fv, _gloffset_MultiTexCoord3fvARB ), + NAME_FUNC_OFFSET( 14270, glMultiTexCoord3i, _gloffset_MultiTexCoord3iARB ), + NAME_FUNC_OFFSET( 14288, glMultiTexCoord3iv, _gloffset_MultiTexCoord3ivARB ), + NAME_FUNC_OFFSET( 14307, glMultiTexCoord3s, _gloffset_MultiTexCoord3sARB ), + NAME_FUNC_OFFSET( 14325, glMultiTexCoord3sv, _gloffset_MultiTexCoord3svARB ), + NAME_FUNC_OFFSET( 14344, glMultiTexCoord4d, _gloffset_MultiTexCoord4dARB ), + NAME_FUNC_OFFSET( 14362, glMultiTexCoord4dv, _gloffset_MultiTexCoord4dvARB ), + NAME_FUNC_OFFSET( 14381, glMultiTexCoord4f, _gloffset_MultiTexCoord4fARB ), + NAME_FUNC_OFFSET( 14399, glMultiTexCoord4fv, _gloffset_MultiTexCoord4fvARB ), + NAME_FUNC_OFFSET( 14418, glMultiTexCoord4i, _gloffset_MultiTexCoord4iARB ), + NAME_FUNC_OFFSET( 14436, glMultiTexCoord4iv, _gloffset_MultiTexCoord4ivARB ), + NAME_FUNC_OFFSET( 14455, glMultiTexCoord4s, _gloffset_MultiTexCoord4sARB ), + NAME_FUNC_OFFSET( 14473, glMultiTexCoord4sv, _gloffset_MultiTexCoord4svARB ), + NAME_FUNC_OFFSET( 14492, glLoadTransposeMatrixf, _gloffset_LoadTransposeMatrixfARB ), + NAME_FUNC_OFFSET( 14515, glLoadTransposeMatrixd, _gloffset_LoadTransposeMatrixdARB ), + NAME_FUNC_OFFSET( 14538, glMultTransposeMatrixf, _gloffset_MultTransposeMatrixfARB ), + NAME_FUNC_OFFSET( 14561, glMultTransposeMatrixd, _gloffset_MultTransposeMatrixdARB ), + NAME_FUNC_OFFSET( 14584, glSampleCoverage, _gloffset_SampleCoverageARB ), + NAME_FUNC_OFFSET( 14601, glCompressedTexImage3D, _gloffset_CompressedTexImage3DARB ), + NAME_FUNC_OFFSET( 14624, glCompressedTexImage2D, _gloffset_CompressedTexImage2DARB ), + NAME_FUNC_OFFSET( 14647, glCompressedTexImage1D, _gloffset_CompressedTexImage1DARB ), + NAME_FUNC_OFFSET( 14670, glCompressedTexSubImage3D, _gloffset_CompressedTexSubImage3DARB ), + NAME_FUNC_OFFSET( 14696, glCompressedTexSubImage2D, _gloffset_CompressedTexSubImage2DARB ), + NAME_FUNC_OFFSET( 14722, glCompressedTexSubImage1D, _gloffset_CompressedTexSubImage1DARB ), + NAME_FUNC_OFFSET( 14748, glGetCompressedTexImage, _gloffset_GetCompressedTexImageARB ), + NAME_FUNC_OFFSET( 14772, glBlendFuncSeparate, _gloffset_BlendFuncSeparateEXT ), + NAME_FUNC_OFFSET( 14792, glFogCoordf, _gloffset_FogCoordfEXT ), + NAME_FUNC_OFFSET( 14804, glFogCoordfv, _gloffset_FogCoordfvEXT ), + NAME_FUNC_OFFSET( 14817, glFogCoordd, _gloffset_FogCoorddEXT ), + NAME_FUNC_OFFSET( 14829, glFogCoorddv, _gloffset_FogCoorddvEXT ), + NAME_FUNC_OFFSET( 14842, glFogCoordPointer, _gloffset_FogCoordPointerEXT ), + NAME_FUNC_OFFSET( 14860, glMultiDrawArrays, _gloffset_MultiDrawArraysEXT ), + NAME_FUNC_OFFSET( 14878, glMultiDrawElements, _gloffset_MultiDrawElementsEXT ), + NAME_FUNC_OFFSET( 14898, glPointParameterf, _gloffset_PointParameterfEXT ), + NAME_FUNC_OFFSET( 14916, glPointParameterfv, _gloffset_PointParameterfvEXT ), + NAME_FUNC_OFFSET( 14935, glPointParameteri, _gloffset_PointParameteriNV ), + NAME_FUNC_OFFSET( 14953, glPointParameteriv, _gloffset_PointParameterivNV ), + NAME_FUNC_OFFSET( 14972, glSecondaryColor3b, _gloffset_SecondaryColor3bEXT ), + NAME_FUNC_OFFSET( 14991, glSecondaryColor3bv, _gloffset_SecondaryColor3bvEXT ), + NAME_FUNC_OFFSET( 15011, glSecondaryColor3d, _gloffset_SecondaryColor3dEXT ), + NAME_FUNC_OFFSET( 15030, glSecondaryColor3dv, _gloffset_SecondaryColor3dvEXT ), + NAME_FUNC_OFFSET( 15050, glSecondaryColor3f, _gloffset_SecondaryColor3fEXT ), + NAME_FUNC_OFFSET( 15069, glSecondaryColor3fv, _gloffset_SecondaryColor3fvEXT ), + NAME_FUNC_OFFSET( 15089, glSecondaryColor3i, _gloffset_SecondaryColor3iEXT ), + NAME_FUNC_OFFSET( 15108, glSecondaryColor3iv, _gloffset_SecondaryColor3ivEXT ), + NAME_FUNC_OFFSET( 15128, glSecondaryColor3s, _gloffset_SecondaryColor3sEXT ), + NAME_FUNC_OFFSET( 15147, glSecondaryColor3sv, _gloffset_SecondaryColor3svEXT ), + NAME_FUNC_OFFSET( 15167, glSecondaryColor3ub, _gloffset_SecondaryColor3ubEXT ), + NAME_FUNC_OFFSET( 15187, glSecondaryColor3ubv, _gloffset_SecondaryColor3ubvEXT ), + NAME_FUNC_OFFSET( 15208, glSecondaryColor3ui, _gloffset_SecondaryColor3uiEXT ), + NAME_FUNC_OFFSET( 15228, glSecondaryColor3uiv, _gloffset_SecondaryColor3uivEXT ), + NAME_FUNC_OFFSET( 15249, glSecondaryColor3us, _gloffset_SecondaryColor3usEXT ), + NAME_FUNC_OFFSET( 15269, glSecondaryColor3usv, _gloffset_SecondaryColor3usvEXT ), + NAME_FUNC_OFFSET( 15290, glSecondaryColorPointer, _gloffset_SecondaryColorPointerEXT ), + NAME_FUNC_OFFSET( 15314, glWindowPos2d, _gloffset_WindowPos2dMESA ), + NAME_FUNC_OFFSET( 15328, glWindowPos2dv, _gloffset_WindowPos2dvMESA ), + NAME_FUNC_OFFSET( 15343, glWindowPos2f, _gloffset_WindowPos2fMESA ), + NAME_FUNC_OFFSET( 15357, glWindowPos2fv, _gloffset_WindowPos2fvMESA ), + NAME_FUNC_OFFSET( 15372, glWindowPos2i, _gloffset_WindowPos2iMESA ), + NAME_FUNC_OFFSET( 15386, glWindowPos2iv, _gloffset_WindowPos2ivMESA ), + NAME_FUNC_OFFSET( 15401, glWindowPos2s, _gloffset_WindowPos2sMESA ), + NAME_FUNC_OFFSET( 15415, glWindowPos2sv, _gloffset_WindowPos2svMESA ), + NAME_FUNC_OFFSET( 15430, glWindowPos3d, _gloffset_WindowPos3dMESA ), + NAME_FUNC_OFFSET( 15444, glWindowPos3dv, _gloffset_WindowPos3dvMESA ), + NAME_FUNC_OFFSET( 15459, glWindowPos3f, _gloffset_WindowPos3fMESA ), + NAME_FUNC_OFFSET( 15473, glWindowPos3fv, _gloffset_WindowPos3fvMESA ), + NAME_FUNC_OFFSET( 15488, glWindowPos3i, _gloffset_WindowPos3iMESA ), + NAME_FUNC_OFFSET( 15502, glWindowPos3iv, _gloffset_WindowPos3ivMESA ), + NAME_FUNC_OFFSET( 15517, glWindowPos3s, _gloffset_WindowPos3sMESA ), + NAME_FUNC_OFFSET( 15531, glWindowPos3sv, _gloffset_WindowPos3svMESA ), + NAME_FUNC_OFFSET( 15546, glBindBuffer, _gloffset_BindBufferARB ), + NAME_FUNC_OFFSET( 15559, glBufferData, _gloffset_BufferDataARB ), + NAME_FUNC_OFFSET( 15572, glBufferSubData, _gloffset_BufferSubDataARB ), + NAME_FUNC_OFFSET( 15588, glDeleteBuffers, _gloffset_DeleteBuffersARB ), + NAME_FUNC_OFFSET( 15604, glGenBuffers, _gloffset_GenBuffersARB ), + NAME_FUNC_OFFSET( 15617, glGetBufferParameteriv, _gloffset_GetBufferParameterivARB ), + NAME_FUNC_OFFSET( 15640, glGetBufferPointerv, _gloffset_GetBufferPointervARB ), + NAME_FUNC_OFFSET( 15660, glGetBufferSubData, _gloffset_GetBufferSubDataARB ), + NAME_FUNC_OFFSET( 15679, glIsBuffer, _gloffset_IsBufferARB ), + NAME_FUNC_OFFSET( 15690, glMapBuffer, _gloffset_MapBufferARB ), + NAME_FUNC_OFFSET( 15702, glUnmapBuffer, _gloffset_UnmapBufferARB ), + NAME_FUNC_OFFSET( 15716, glGenQueries, _gloffset_GenQueriesARB ), + NAME_FUNC_OFFSET( 15729, glDeleteQueries, _gloffset_DeleteQueriesARB ), + NAME_FUNC_OFFSET( 15745, glIsQuery, _gloffset_IsQueryARB ), + NAME_FUNC_OFFSET( 15755, glBeginQuery, _gloffset_BeginQueryARB ), + NAME_FUNC_OFFSET( 15768, glEndQuery, _gloffset_EndQueryARB ), + NAME_FUNC_OFFSET( 15779, glGetQueryiv, _gloffset_GetQueryivARB ), + NAME_FUNC_OFFSET( 15792, glGetQueryObjectiv, _gloffset_GetQueryObjectivARB ), + NAME_FUNC_OFFSET( 15811, glGetQueryObjectuiv, _gloffset_GetQueryObjectuivARB ), + NAME_FUNC_OFFSET( 15831, glPointParameterfARB, _gloffset_PointParameterfEXT ), + NAME_FUNC_OFFSET( 15852, glPointParameterfvARB, _gloffset_PointParameterfvEXT ), + NAME_FUNC_OFFSET( 15874, glWindowPos2dARB, _gloffset_WindowPos2dMESA ), + NAME_FUNC_OFFSET( 15891, glWindowPos2fARB, _gloffset_WindowPos2fMESA ), + NAME_FUNC_OFFSET( 15908, glWindowPos2iARB, _gloffset_WindowPos2iMESA ), + NAME_FUNC_OFFSET( 15925, glWindowPos2sARB, _gloffset_WindowPos2sMESA ), + NAME_FUNC_OFFSET( 15942, glWindowPos2dvARB, _gloffset_WindowPos2dvMESA ), + NAME_FUNC_OFFSET( 15960, glWindowPos2fvARB, _gloffset_WindowPos2fvMESA ), + NAME_FUNC_OFFSET( 15978, glWindowPos2ivARB, _gloffset_WindowPos2ivMESA ), + NAME_FUNC_OFFSET( 15996, glWindowPos2svARB, _gloffset_WindowPos2svMESA ), + NAME_FUNC_OFFSET( 16014, glWindowPos3dARB, _gloffset_WindowPos3dMESA ), + NAME_FUNC_OFFSET( 16031, glWindowPos3fARB, _gloffset_WindowPos3fMESA ), + NAME_FUNC_OFFSET( 16048, glWindowPos3iARB, _gloffset_WindowPos3iMESA ), + NAME_FUNC_OFFSET( 16065, glWindowPos3sARB, _gloffset_WindowPos3sMESA ), + NAME_FUNC_OFFSET( 16082, glWindowPos3dvARB, _gloffset_WindowPos3dvMESA ), + NAME_FUNC_OFFSET( 16100, glWindowPos3fvARB, _gloffset_WindowPos3fvMESA ), + NAME_FUNC_OFFSET( 16118, glWindowPos3ivARB, _gloffset_WindowPos3ivMESA ), + NAME_FUNC_OFFSET( 16136, glWindowPos3svARB, _gloffset_WindowPos3svMESA ), + NAME_FUNC_OFFSET( 16154, glBindProgramARB, _gloffset_BindProgramNV ), + NAME_FUNC_OFFSET( 16171, glDeleteProgramsARB, _gloffset_DeleteProgramsNV ), + NAME_FUNC_OFFSET( 16191, glGenProgramsARB, _gloffset_GenProgramsNV ), + NAME_FUNC_OFFSET( 16208, glIsProgramARB, _gloffset_IsProgramNV ), NAME_FUNC_OFFSET( 16223, glGetVertexAttribPointervARB, _gloffset_GetVertexAttribPointervNV ), NAME_FUNC_OFFSET( 16252, glBlendColorEXT, _gloffset_BlendColor ), NAME_FUNC_OFFSET( 16268, glTexImage3DEXT, _gloffset_TexImage3D ), diff --git a/src/mesa/main/api_arrayelt.c b/src/mesa/main/api_arrayelt.c index 626c92e..12ea413 100644 --- a/src/mesa/main/api_arrayelt.c +++ b/src/mesa/main/api_arrayelt.c @@ -1,6 +1,6 @@ /* * Mesa 3-D graphics library - * Version: 6.1 + * Version: 6.3 * * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. * @@ -411,39 +411,39 @@ static const array_func FogCoordFuncs[8] = { /* GL_BYTE attributes */ -static void GLAPIENTRY VertexAttrib1Nbv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib1NbvNV(GLuint index, const GLbyte *v) { GL_CALL(VertexAttrib1fNV)(index, BYTE_TO_FLOAT(v[0])); } -static void GLAPIENTRY VertexAttrib1bv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib1bvNV(GLuint index, const GLbyte *v) { GL_CALL(VertexAttrib1fNV)(index, v[0]); } -static void GLAPIENTRY VertexAttrib2Nbv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib2NbvNV(GLuint index, const GLbyte *v) { GL_CALL(VertexAttrib2fNV)(index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1])); } -static void GLAPIENTRY VertexAttrib2bv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib2bvNV(GLuint index, const GLbyte *v) { GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]); } -static void GLAPIENTRY VertexAttrib3Nbv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib3NbvNV(GLuint index, const GLbyte *v) { GL_CALL(VertexAttrib3fNV)(index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2])); } -static void GLAPIENTRY VertexAttrib3bv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib3bvNV(GLuint index, const GLbyte *v) { GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]); } -static void GLAPIENTRY VertexAttrib4Nbv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib4NbvNV(GLuint index, const GLbyte *v) { GL_CALL(VertexAttrib4fNV)(index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), @@ -451,46 +451,46 @@ static void GLAPIENTRY VertexAttrib4Nbv(GLuint index, const GLbyte *v) BYTE_TO_FLOAT(v[3])); } -static void GLAPIENTRY VertexAttrib4bv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib4bvNV(GLuint index, const GLbyte *v) { GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]); } /* GL_UNSIGNED_BYTE attributes */ -static void GLAPIENTRY VertexAttrib1Nubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib1NubvNV(GLuint index, const GLubyte *v) { GL_CALL(VertexAttrib1fNV)(index, UBYTE_TO_FLOAT(v[0])); } -static void GLAPIENTRY VertexAttrib1ubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib1ubvNV(GLuint index, const GLubyte *v) { GL_CALL(VertexAttrib1fNV)(index, v[0]); } -static void GLAPIENTRY VertexAttrib2Nubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib2NubvNV(GLuint index, const GLubyte *v) { GL_CALL(VertexAttrib2fNV)(index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1])); } -static void GLAPIENTRY VertexAttrib2ubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib2ubvNV(GLuint index, const GLubyte *v) { GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]); } -static void GLAPIENTRY VertexAttrib3Nubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib3NubvNV(GLuint index, const GLubyte *v) { GL_CALL(VertexAttrib3fNV)(index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), UBYTE_TO_FLOAT(v[2])); } -static void GLAPIENTRY VertexAttrib3ubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib3ubvNV(GLuint index, const GLubyte *v) { GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]); } -static void GLAPIENTRY VertexAttrib4Nubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib4NubvNV(GLuint index, const GLubyte *v) { GL_CALL(VertexAttrib4fNV)(index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), @@ -498,47 +498,47 @@ static void GLAPIENTRY VertexAttrib4Nubv(GLuint index, const GLubyte *v) UBYTE_TO_FLOAT(v[3])); } -static void GLAPIENTRY VertexAttrib4ubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib4ubvNV(GLuint index, const GLubyte *v) { GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]); } /* GL_SHORT attributes */ -static void GLAPIENTRY VertexAttrib1Nsv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib1NsvNV(GLuint index, const GLshort *v) { GL_CALL(VertexAttrib1fNV)(index, SHORT_TO_FLOAT(v[0])); } -static void GLAPIENTRY VertexAttrib1sv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib1svNV(GLuint index, const GLshort *v) { GL_CALL(VertexAttrib1fNV)(index, v[0]); } -static void GLAPIENTRY VertexAttrib2Nsv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib2NsvNV(GLuint index, const GLshort *v) { GL_CALL(VertexAttrib2fNV)(index, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1])); } -static void GLAPIENTRY VertexAttrib2sv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib2svNV(GLuint index, const GLshort *v) { GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]); } -static void GLAPIENTRY VertexAttrib3Nsv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib3NsvNV(GLuint index, const GLshort *v) { GL_CALL(VertexAttrib3fNV)(index, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2])); } -static void GLAPIENTRY VertexAttrib3sv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib3svNV(GLuint index, const GLshort *v) { GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]); } -static void GLAPIENTRY VertexAttrib4Nsv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib4NsvNV(GLuint index, const GLshort *v) { GL_CALL(VertexAttrib4fNV)(index, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), @@ -546,47 +546,47 @@ static void GLAPIENTRY VertexAttrib4Nsv(GLuint index, const GLshort *v) SHORT_TO_FLOAT(v[3])); } -static void GLAPIENTRY VertexAttrib4sv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib4svNV(GLuint index, const GLshort *v) { GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]); } /* GL_UNSIGNED_SHORT attributes */ -static void GLAPIENTRY VertexAttrib1Nusv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib1NusvNV(GLuint index, const GLushort *v) { GL_CALL(VertexAttrib1fNV)(index, USHORT_TO_FLOAT(v[0])); } -static void GLAPIENTRY VertexAttrib1usv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib1usvNV(GLuint index, const GLushort *v) { GL_CALL(VertexAttrib1fNV)(index, v[0]); } -static void GLAPIENTRY VertexAttrib2Nusv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib2NusvNV(GLuint index, const GLushort *v) { GL_CALL(VertexAttrib2fNV)(index, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1])); } -static void GLAPIENTRY VertexAttrib2usv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib2usvNV(GLuint index, const GLushort *v) { GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]); } -static void GLAPIENTRY VertexAttrib3Nusv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib3NusvNV(GLuint index, const GLushort *v) { GL_CALL(VertexAttrib3fNV)(index, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]), USHORT_TO_FLOAT(v[2])); } -static void GLAPIENTRY VertexAttrib3usv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib3usvNV(GLuint index, const GLushort *v) { GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]); } -static void GLAPIENTRY VertexAttrib4Nusv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib4NusvNV(GLuint index, const GLushort *v) { GL_CALL(VertexAttrib4fNV)(index, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]), @@ -594,47 +594,47 @@ static void GLAPIENTRY VertexAttrib4Nusv(GLuint index, const GLushort *v) USHORT_TO_FLOAT(v[3])); } -static void GLAPIENTRY VertexAttrib4usv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib4usvNV(GLuint index, const GLushort *v) { GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]); } /* GL_INT attributes */ -static void GLAPIENTRY VertexAttrib1Niv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib1NivNV(GLuint index, const GLint *v) { GL_CALL(VertexAttrib1fNV)(index, INT_TO_FLOAT(v[0])); } -static void GLAPIENTRY VertexAttrib1iv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib1ivNV(GLuint index, const GLint *v) { GL_CALL(VertexAttrib1fNV)(index, v[0]); } -static void GLAPIENTRY VertexAttrib2Niv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib2NivNV(GLuint index, const GLint *v) { GL_CALL(VertexAttrib2fNV)(index, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1])); } -static void GLAPIENTRY VertexAttrib2iv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib2ivNV(GLuint index, const GLint *v) { GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]); } -static void GLAPIENTRY VertexAttrib3Niv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib3NivNV(GLuint index, const GLint *v) { GL_CALL(VertexAttrib3fNV)(index, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2])); } -static void GLAPIENTRY VertexAttrib3iv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib3ivNV(GLuint index, const GLint *v) { GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]); } -static void GLAPIENTRY VertexAttrib4Niv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib4NivNV(GLuint index, const GLint *v) { GL_CALL(VertexAttrib4fNV)(index, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), @@ -642,47 +642,47 @@ static void GLAPIENTRY VertexAttrib4Niv(GLuint index, const GLint *v) INT_TO_FLOAT(v[3])); } -static void GLAPIENTRY VertexAttrib4iv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib4ivNV(GLuint index, const GLint *v) { GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]); } /* GL_UNSIGNED_INT attributes */ -static void GLAPIENTRY VertexAttrib1Nuiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib1NuivNV(GLuint index, const GLuint *v) { GL_CALL(VertexAttrib1fNV)(index, UINT_TO_FLOAT(v[0])); } -static void GLAPIENTRY VertexAttrib1uiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib1uivNV(GLuint index, const GLuint *v) { GL_CALL(VertexAttrib1fNV)(index, v[0]); } -static void GLAPIENTRY VertexAttrib2Nuiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib2NuivNV(GLuint index, const GLuint *v) { GL_CALL(VertexAttrib2fNV)(index, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1])); } -static void GLAPIENTRY VertexAttrib2uiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib2uivNV(GLuint index, const GLuint *v) { GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]); } -static void GLAPIENTRY VertexAttrib3Nuiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib3NuivNV(GLuint index, const GLuint *v) { GL_CALL(VertexAttrib3fNV)(index, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]), UINT_TO_FLOAT(v[2])); } -static void GLAPIENTRY VertexAttrib3uiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib3uivNV(GLuint index, const GLuint *v) { GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]); } -static void GLAPIENTRY VertexAttrib4Nuiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib4NuivNV(GLuint index, const GLuint *v) { GL_CALL(VertexAttrib4fNV)(index, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]), @@ -690,51 +690,51 @@ static void GLAPIENTRY VertexAttrib4Nuiv(GLuint index, const GLuint *v) UINT_TO_FLOAT(v[3])); } -static void GLAPIENTRY VertexAttrib4uiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib4uivNV(GLuint index, const GLuint *v) { GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]); } /* GL_FLOAT attributes */ -static void GLAPIENTRY VertexAttrib1fv(GLuint index, const GLfloat *v) +static void GLAPIENTRY VertexAttrib1fvNV(GLuint index, const GLfloat *v) { GL_CALL(VertexAttrib1fvNV)(index, v); } -static void GLAPIENTRY VertexAttrib2fv(GLuint index, const GLfloat *v) +static void GLAPIENTRY VertexAttrib2fvNV(GLuint index, const GLfloat *v) { GL_CALL(VertexAttrib2fvNV)(index, v); } -static void GLAPIENTRY VertexAttrib3fv(GLuint index, const GLfloat *v) +static void GLAPIENTRY VertexAttrib3fvNV(GLuint index, const GLfloat *v) { GL_CALL(VertexAttrib3fvNV)(index, v); } -static void GLAPIENTRY VertexAttrib4fv(GLuint index, const GLfloat *v) +static void GLAPIENTRY VertexAttrib4fvNV(GLuint index, const GLfloat *v) { GL_CALL(VertexAttrib4fvNV)(index, v); } /* GL_DOUBLE attributes */ -static void GLAPIENTRY VertexAttrib1dv(GLuint index, const GLdouble *v) +static void GLAPIENTRY VertexAttrib1dvNV(GLuint index, const GLdouble *v) { GL_CALL(VertexAttrib1dvNV)(index, v); } -static void GLAPIENTRY VertexAttrib2dv(GLuint index, const GLdouble *v) +static void GLAPIENTRY VertexAttrib2dvNV(GLuint index, const GLdouble *v) { GL_CALL(VertexAttrib2dvNV)(index, v); } -static void GLAPIENTRY VertexAttrib3dv(GLuint index, const GLdouble *v) +static void GLAPIENTRY VertexAttrib3dvNV(GLuint index, const GLdouble *v) { GL_CALL(VertexAttrib3dvNV)(index, v); } -static void GLAPIENTRY VertexAttrib4dv(GLuint index, const GLdouble *v) +static void GLAPIENTRY VertexAttrib4dvNV(GLuint index, const GLdouble *v) { GL_CALL(VertexAttrib4dvNV)(index, v); } @@ -743,99 +743,99 @@ static void GLAPIENTRY VertexAttrib4dv(GLuint index, const GLdouble *v) /* * Array [size][type] of VertexAttrib functions */ -static const attrib_func AttribFuncs[2][4][8] = { +static attrib_func AttribFuncsNV[2][4][8] = { { /* non-normalized */ { /* size 1 */ - (attrib_func) VertexAttrib1bv, - (attrib_func) VertexAttrib1ubv, - (attrib_func) VertexAttrib1sv, - (attrib_func) VertexAttrib1usv, - (attrib_func) VertexAttrib1iv, - (attrib_func) VertexAttrib1uiv, - (attrib_func) VertexAttrib1fv, - (attrib_func) VertexAttrib1dv + (attrib_func) VertexAttrib1bvNV, + (attrib_func) VertexAttrib1ubvNV, + (attrib_func) VertexAttrib1svNV, + (attrib_func) VertexAttrib1usvNV, + (attrib_func) VertexAttrib1ivNV, + (attrib_func) VertexAttrib1uivNV, + (attrib_func) VertexAttrib1fvNV, + (attrib_func) VertexAttrib1dvNV }, { /* size 2 */ - (attrib_func) VertexAttrib2bv, - (attrib_func) VertexAttrib2ubv, - (attrib_func) VertexAttrib2sv, - (attrib_func) VertexAttrib2usv, - (attrib_func) VertexAttrib2iv, - (attrib_func) VertexAttrib2uiv, - (attrib_func) VertexAttrib2fv, - (attrib_func) VertexAttrib2dv + (attrib_func) VertexAttrib2bvNV, + (attrib_func) VertexAttrib2ubvNV, + (attrib_func) VertexAttrib2svNV, + (attrib_func) VertexAttrib2usvNV, + (attrib_func) VertexAttrib2ivNV, + (attrib_func) VertexAttrib2uivNV, + (attrib_func) VertexAttrib2fvNV, + (attrib_func) VertexAttrib2dvNV }, { /* size 3 */ - (attrib_func) VertexAttrib3bv, - (attrib_func) VertexAttrib3ubv, - (attrib_func) VertexAttrib3sv, - (attrib_func) VertexAttrib3usv, - (attrib_func) VertexAttrib3iv, - (attrib_func) VertexAttrib3uiv, - (attrib_func) VertexAttrib3fv, - (attrib_func) VertexAttrib3dv + (attrib_func) VertexAttrib3bvNV, + (attrib_func) VertexAttrib3ubvNV, + (attrib_func) VertexAttrib3svNV, + (attrib_func) VertexAttrib3usvNV, + (attrib_func) VertexAttrib3ivNV, + (attrib_func) VertexAttrib3uivNV, + (attrib_func) VertexAttrib3fvNV, + (attrib_func) VertexAttrib3dvNV }, { /* size 4 */ - (attrib_func) VertexAttrib4bv, - (attrib_func) VertexAttrib4ubv, - (attrib_func) VertexAttrib4sv, - (attrib_func) VertexAttrib4usv, - (attrib_func) VertexAttrib4iv, - (attrib_func) VertexAttrib4uiv, - (attrib_func) VertexAttrib4fv, - (attrib_func) VertexAttrib4dv + (attrib_func) VertexAttrib4bvNV, + (attrib_func) VertexAttrib4ubvNV, + (attrib_func) VertexAttrib4svNV, + (attrib_func) VertexAttrib4usvNV, + (attrib_func) VertexAttrib4ivNV, + (attrib_func) VertexAttrib4uivNV, + (attrib_func) VertexAttrib4fvNV, + (attrib_func) VertexAttrib4dvNV } }, { /* normalized (except for float/double) */ { /* size 1 */ - (attrib_func) VertexAttrib1Nbv, - (attrib_func) VertexAttrib1Nubv, - (attrib_func) VertexAttrib1Nsv, - (attrib_func) VertexAttrib1Nusv, - (attrib_func) VertexAttrib1Niv, - (attrib_func) VertexAttrib1Nuiv, - (attrib_func) VertexAttrib1fv, - (attrib_func) VertexAttrib1dv + (attrib_func) VertexAttrib1NbvNV, + (attrib_func) VertexAttrib1NubvNV, + (attrib_func) VertexAttrib1NsvNV, + (attrib_func) VertexAttrib1NusvNV, + (attrib_func) VertexAttrib1NivNV, + (attrib_func) VertexAttrib1NuivNV, + (attrib_func) VertexAttrib1fvNV, + (attrib_func) VertexAttrib1dvNV }, { /* size 2 */ - (attrib_func) VertexAttrib2Nbv, - (attrib_func) VertexAttrib2Nubv, - (attrib_func) VertexAttrib2Nsv, - (attrib_func) VertexAttrib2Nusv, - (attrib_func) VertexAttrib2Niv, - (attrib_func) VertexAttrib2Nuiv, - (attrib_func) VertexAttrib2fv, - (attrib_func) VertexAttrib2dv + (attrib_func) VertexAttrib2NbvNV, + (attrib_func) VertexAttrib2NubvNV, + (attrib_func) VertexAttrib2NsvNV, + (attrib_func) VertexAttrib2NusvNV, + (attrib_func) VertexAttrib2NivNV, + (attrib_func) VertexAttrib2NuivNV, + (attrib_func) VertexAttrib2fvNV, + (attrib_func) VertexAttrib2dvNV }, { /* size 3 */ - (attrib_func) VertexAttrib3Nbv, - (attrib_func) VertexAttrib3Nubv, - (attrib_func) VertexAttrib3Nsv, - (attrib_func) VertexAttrib3Nusv, - (attrib_func) VertexAttrib3Niv, - (attrib_func) VertexAttrib3Nuiv, - (attrib_func) VertexAttrib3fv, - (attrib_func) VertexAttrib3dv + (attrib_func) VertexAttrib3NbvNV, + (attrib_func) VertexAttrib3NubvNV, + (attrib_func) VertexAttrib3NsvNV, + (attrib_func) VertexAttrib3NusvNV, + (attrib_func) VertexAttrib3NivNV, + (attrib_func) VertexAttrib3NuivNV, + (attrib_func) VertexAttrib3fvNV, + (attrib_func) VertexAttrib3dvNV }, { /* size 4 */ - (attrib_func) VertexAttrib4Nbv, - (attrib_func) VertexAttrib4Nubv, - (attrib_func) VertexAttrib4Nsv, - (attrib_func) VertexAttrib4Nusv, - (attrib_func) VertexAttrib4Niv, - (attrib_func) VertexAttrib4Nuiv, - (attrib_func) VertexAttrib4fv, - (attrib_func) VertexAttrib4dv + (attrib_func) VertexAttrib4NbvNV, + (attrib_func) VertexAttrib4NubvNV, + (attrib_func) VertexAttrib4NsvNV, + (attrib_func) VertexAttrib4NusvNV, + (attrib_func) VertexAttrib4NivNV, + (attrib_func) VertexAttrib4NuivNV, + (attrib_func) VertexAttrib4fvNV, + (attrib_func) VertexAttrib4dvNV } } }; @@ -923,7 +923,7 @@ static void _ae_update_state( GLcontext *ctx ) */ struct gl_client_array *attribArray = &ctx->Array.TexCoord[i]; at->array = attribArray; - at->func = AttribFuncs[at->array->Normalized][at->array->Size-1][TYPE_IDX(at->array->Type)]; + at->func = AttribFuncsNV[at->array->Normalized][at->array->Size-1][TYPE_IDX(at->array->Type)]; at->index = VERT_ATTRIB_TEX0 + i; at++; } @@ -939,7 +939,7 @@ static void _ae_update_state( GLcontext *ctx ) * change from one execution of _ae_loopback_array_elt() to * the next. Doing so caused UT to break. */ - at->func = AttribFuncs[at->array->Normalized][at->array->Size-1][TYPE_IDX(at->array->Type)]; + at->func = AttribFuncsNV[at->array->Normalized][at->array->Size-1][TYPE_IDX(at->array->Type)]; at->index = i; at++; } @@ -1004,7 +1004,6 @@ void GLAPIENTRY _ae_loopback_array_elt( GLint elt ) } - void _ae_invalidate_state( GLcontext *ctx, GLuint new_state ) { AE_CONTEXT(ctx)->NewState |= new_state; diff --git a/src/mesa/main/api_loopback.c b/src/mesa/main/api_loopback.c index 3281caf..2921569 100644 --- a/src/mesa/main/api_loopback.c +++ b/src/mesa/main/api_loopback.c @@ -65,15 +65,16 @@ #define MATERIALFV(a,b,c) GL_CALL(Materialfv)(a,b,c) #define RECTF(a,b,c,d) GL_CALL(Rectf)(a,b,c,d) -/* Extension functions must be dereferenced through _glapi_Dispatch as - * not all libGL.so's will have all the uptodate entrypoints. - */ -#define ATTRIB1(index,x) GL_CALL(VertexAttrib1fNV)(index,x) -#define ATTRIB2(index,x,y) GL_CALL(VertexAttrib2fNV)(index,x,y) -#define ATTRIB3(index,x,y,z) GL_CALL(VertexAttrib3fNV)(index,x,y,z) -#define ATTRIB4(index,x,y,z,w) GL_CALL(VertexAttrib4fNV)(index,x,y,z,w) -#define FOGCOORDF(x) GL_CALL(FogCoordfEXT)(x) -#define SECONDARYCOLORF(a,b,c) GL_CALL(SecondaryColor3fEXT)(a,b,c) +#define ATTRIB1NV(index,x) GL_CALL(VertexAttrib1fNV)(index,x) +#define ATTRIB2NV(index,x,y) GL_CALL(VertexAttrib2fNV)(index,x,y) +#define ATTRIB3NV(index,x,y,z) GL_CALL(VertexAttrib3fNV)(index,x,y,z) +#define ATTRIB4NV(index,x,y,z,w) GL_CALL(VertexAttrib4fNV)(index,x,y,z,w) +#define ATTRIB1ARB(index,x) GL_CALL(VertexAttrib1fARB)(index,x) +#define ATTRIB2ARB(index,x,y) GL_CALL(VertexAttrib2fARB)(index,x,y) +#define ATTRIB3ARB(index,x,y,z) GL_CALL(VertexAttrib3fARB)(index,x,y,z) +#define ATTRIB4ARB(index,x,y,z,w) GL_CALL(VertexAttrib4fARB)(index,x,y,z,w) +#define FOGCOORDF(x) GL_CALL(FogCoordfEXT)(x) +#define SECONDARYCOLORF(a,b,c) GL_CALL(SecondaryColor3fEXT)(a,b,c) static void GLAPIENTRY loopback_Color3b_f( GLbyte red, GLbyte green, GLbyte blue ) @@ -1024,159 +1025,118 @@ loopback_SecondaryColor3ubvEXT_f( const GLubyte *v ) /* - * GL_NV_vertex_program + * GL_NV_vertex_program: + * Always loop-back to one of the VertexAttrib[1234]f[v]NV functions. */ static void GLAPIENTRY loopback_VertexAttrib1sNV(GLuint index, GLshort x) { - ATTRIB1(index, (GLfloat) x); -} - -static void GLAPIENTRY -loopback_VertexAttrib1fNV(GLuint index, GLfloat x) -{ - ATTRIB1(index, x); + ATTRIB1NV(index, (GLfloat) x); } static void GLAPIENTRY loopback_VertexAttrib1dNV(GLuint index, GLdouble x) { - ATTRIB1(index, (GLfloat) x); + ATTRIB1NV(index, (GLfloat) x); } static void GLAPIENTRY loopback_VertexAttrib2sNV(GLuint index, GLshort x, GLshort y) { - ATTRIB2(index, (GLfloat) x, y); -} - -static void GLAPIENTRY -loopback_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y) -{ - ATTRIB2(index, (GLfloat) x, y); + ATTRIB2NV(index, (GLfloat) x, y); } static void GLAPIENTRY loopback_VertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y) { - ATTRIB2(index, (GLfloat) x, (GLfloat) y); + ATTRIB2NV(index, (GLfloat) x, (GLfloat) y); } static void GLAPIENTRY loopback_VertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z) { - ATTRIB3(index, (GLfloat) x, (GLfloat) y, (GLfloat) z); -} - -static void GLAPIENTRY -loopback_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z) -{ - ATTRIB3(index, x, y, z); + ATTRIB3NV(index, (GLfloat) x, (GLfloat) y, (GLfloat) z); } static void GLAPIENTRY loopback_VertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z) { - ATTRIB4(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F); + ATTRIB4NV(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F); } static void GLAPIENTRY loopback_VertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) { - ATTRIB4(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w); + ATTRIB4NV(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w); } static void GLAPIENTRY loopback_VertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { - ATTRIB4(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w); + ATTRIB4NV(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w); } static void GLAPIENTRY loopback_VertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) { - ATTRIB4(index, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y), + ATTRIB4NV(index, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y), UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w)); } static void GLAPIENTRY loopback_VertexAttrib1svNV(GLuint index, const GLshort *v) { - ATTRIB1(index, (GLfloat) v[0]); -} - -static void GLAPIENTRY -loopback_VertexAttrib1fvNV(GLuint index, const GLfloat *v) -{ - ATTRIB1(index, v[0]); + ATTRIB1NV(index, (GLfloat) v[0]); } static void GLAPIENTRY loopback_VertexAttrib1dvNV(GLuint index, const GLdouble *v) { - ATTRIB1(index, (GLfloat) v[0]); + ATTRIB1NV(index, (GLfloat) v[0]); } static void GLAPIENTRY loopback_VertexAttrib2svNV(GLuint index, const GLshort *v) { - ATTRIB2(index, (GLfloat) v[0], (GLfloat) v[1]); -} - -static void GLAPIENTRY -loopback_VertexAttrib2fvNV(GLuint index, const GLfloat *v) -{ - ATTRIB2(index, v[0], v[1]); + ATTRIB2NV(index, (GLfloat) v[0], (GLfloat) v[1]); } static void GLAPIENTRY loopback_VertexAttrib2dvNV(GLuint index, const GLdouble *v) { - ATTRIB2(index, (GLfloat) v[0], (GLfloat) v[1]); + ATTRIB2NV(index, (GLfloat) v[0], (GLfloat) v[1]); } static void GLAPIENTRY loopback_VertexAttrib3svNV(GLuint index, const GLshort *v) { - ATTRIB3(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]); -} - -static void GLAPIENTRY -loopback_VertexAttrib3fvNV(GLuint index, const GLfloat *v) -{ - ATTRIB3(index, v[0], v[1], v[2]); + ATTRIB3NV(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]); } static void GLAPIENTRY loopback_VertexAttrib3dvNV(GLuint index, const GLdouble *v) { - ATTRIB3(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]); + ATTRIB3NV(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]); } static void GLAPIENTRY loopback_VertexAttrib4svNV(GLuint index, const GLshort *v) { - ATTRIB4(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], + ATTRIB4NV(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat)v[3]); } static void GLAPIENTRY -loopback_VertexAttrib4fvNV(GLuint index, const GLfloat *v) -{ - ATTRIB4(index, v[0], v[1], v[2], v[3]); -} - -static void GLAPIENTRY loopback_VertexAttrib4dvNV(GLuint index, const GLdouble *v) { - ATTRIB4(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); + ATTRIB4NV(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); } static void GLAPIENTRY loopback_VertexAttrib4ubvNV(GLuint index, const GLubyte *v) { - ATTRIB4(index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), + ATTRIB4NV(index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3])); } @@ -1194,7 +1154,7 @@ loopback_VertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat *v) { GLint i; for (i = n - 1; i >= 0; i--) - loopback_VertexAttrib1fvNV(index + i, v + i); + ATTRIB1NV(index + i, v[i]); } static void GLAPIENTRY @@ -1218,7 +1178,7 @@ loopback_VertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat *v) { GLint i; for (i = n - 1; i >= 0; i--) - loopback_VertexAttrib2fvNV(index + i, v + 2 * i); + ATTRIB2NV(index + i, v[2 * i], v[2 * i + 1]); } static void GLAPIENTRY @@ -1242,7 +1202,7 @@ loopback_VertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat *v) { GLint i; for (i = n - 1; i >= 0; i--) - loopback_VertexAttrib3fvNV(index + i, v + 3 * i); + ATTRIB3NV(index + i, v[3 * i], v[3 * i + 1], v[3 * i + 2]); } static void GLAPIENTRY @@ -1266,7 +1226,7 @@ loopback_VertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat *v) { GLint i; for (i = n - 1; i >= 0; i--) - loopback_VertexAttrib4fvNV(index + i, v + 4 * i); + ATTRIB4NV(index + i, v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3]); } static void GLAPIENTRY @@ -1288,70 +1248,182 @@ loopback_VertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte *v) /* * GL_ARB_vertex_program + * Always loop-back to one of the VertexAttrib[1234]f[v]ARB functions. */ static void GLAPIENTRY +loopback_VertexAttrib1sARB(GLuint index, GLshort x) +{ + ATTRIB1ARB(index, (GLfloat) x); +} + +static void GLAPIENTRY +loopback_VertexAttrib1dARB(GLuint index, GLdouble x) +{ + ATTRIB1ARB(index, (GLfloat) x); +} + +static void GLAPIENTRY +loopback_VertexAttrib2sARB(GLuint index, GLshort x, GLshort y) +{ + ATTRIB2ARB(index, (GLfloat) x, y); +} + +static void GLAPIENTRY +loopback_VertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y) +{ + ATTRIB2ARB(index, (GLfloat) x, (GLfloat) y); +} + +static void GLAPIENTRY +loopback_VertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z) +{ + ATTRIB3ARB(index, (GLfloat) x, (GLfloat) y, (GLfloat) z); +} + +static void GLAPIENTRY +loopback_VertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + ATTRIB4ARB(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F); +} + +static void GLAPIENTRY +loopback_VertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + ATTRIB4ARB(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w); +} + +static void GLAPIENTRY +loopback_VertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + ATTRIB4ARB(index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w); +} + +static void GLAPIENTRY +loopback_VertexAttrib1svARB(GLuint index, const GLshort *v) +{ + ATTRIB1ARB(index, (GLfloat) v[0]); +} + +static void GLAPIENTRY +loopback_VertexAttrib1dvARB(GLuint index, const GLdouble *v) +{ + ATTRIB1ARB(index, (GLfloat) v[0]); +} + +static void GLAPIENTRY +loopback_VertexAttrib2svARB(GLuint index, const GLshort *v) +{ + ATTRIB2ARB(index, (GLfloat) v[0], (GLfloat) v[1]); +} + +static void GLAPIENTRY +loopback_VertexAttrib2dvARB(GLuint index, const GLdouble *v) +{ + ATTRIB2ARB(index, (GLfloat) v[0], (GLfloat) v[1]); +} + +static void GLAPIENTRY +loopback_VertexAttrib3svARB(GLuint index, const GLshort *v) +{ + ATTRIB3ARB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]); +} + +static void GLAPIENTRY +loopback_VertexAttrib3dvARB(GLuint index, const GLdouble *v) +{ + ATTRIB3ARB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]); +} + +static void GLAPIENTRY +loopback_VertexAttrib4svARB(GLuint index, const GLshort *v) +{ + ATTRIB4ARB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], + (GLfloat)v[3]); +} + +static void GLAPIENTRY +loopback_VertexAttrib4dvARB(GLuint index, const GLdouble *v) +{ + ATTRIB4ARB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); +} + +static void GLAPIENTRY loopback_VertexAttrib4bvARB(GLuint index, const GLbyte * v) { - ATTRIB4(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); + ATTRIB4ARB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); } static void GLAPIENTRY loopback_VertexAttrib4ivARB(GLuint index, const GLint * v) { - ATTRIB4(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); + ATTRIB4ARB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); } static void GLAPIENTRY loopback_VertexAttrib4ubvARB(GLuint index, const GLubyte * v) { - ATTRIB4(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); + ATTRIB4ARB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); } static void GLAPIENTRY loopback_VertexAttrib4usvARB(GLuint index, const GLushort * v) { - ATTRIB4(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); + ATTRIB4ARB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); } static void GLAPIENTRY loopback_VertexAttrib4uivARB(GLuint index, const GLuint * v) { - ATTRIB4(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); + ATTRIB4ARB(index, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]); } static void GLAPIENTRY loopback_VertexAttrib4NbvARB(GLuint index, const GLbyte * v) { - ATTRIB4(index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), + ATTRIB4ARB(index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3])); } static void GLAPIENTRY loopback_VertexAttrib4NsvARB(GLuint index, const GLshort * v) { - ATTRIB4(index, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), + ATTRIB4ARB(index, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3])); } static void GLAPIENTRY loopback_VertexAttrib4NivARB(GLuint index, const GLint * v) { - ATTRIB4(index, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), + ATTRIB4ARB(index, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3])); } static void GLAPIENTRY +loopback_VertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + ATTRIB4ARB(index, UBYTE_TO_FLOAT(x), UBYTE_TO_FLOAT(y), + UBYTE_TO_FLOAT(z), UBYTE_TO_FLOAT(w)); +} + +static void GLAPIENTRY +loopback_VertexAttrib4NubvARB(GLuint index, const GLubyte * v) +{ + ATTRIB4ARB(index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), + UBYTE_TO_FLOAT(v[2]), UBYTE_TO_FLOAT(v[3])); +} + +static void GLAPIENTRY loopback_VertexAttrib4NusvARB(GLuint index, const GLushort * v) { - ATTRIB4(index, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]), + ATTRIB4ARB(index, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]), USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3])); } static void GLAPIENTRY loopback_VertexAttrib4NuivARB(GLuint index, const GLuint * v) { - ATTRIB4(index, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]), + ATTRIB4ARB(index, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]), UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3])); } @@ -1511,32 +1583,23 @@ _mesa_loopback_init_api_table( struct _glapi_table *dest ) dest->FogCoorddvEXT = loopback_FogCoorddvEXT; dest->VertexAttrib1sNV = loopback_VertexAttrib1sNV; - dest->VertexAttrib1fNV = loopback_VertexAttrib1fNV; dest->VertexAttrib1dNV = loopback_VertexAttrib1dNV; dest->VertexAttrib2sNV = loopback_VertexAttrib2sNV; - dest->VertexAttrib2fNV = loopback_VertexAttrib2fNV; dest->VertexAttrib2dNV = loopback_VertexAttrib2dNV; dest->VertexAttrib3sNV = loopback_VertexAttrib3sNV; - dest->VertexAttrib3fNV = loopback_VertexAttrib3fNV; dest->VertexAttrib3dNV = loopback_VertexAttrib3dNV; dest->VertexAttrib4sNV = loopback_VertexAttrib4sNV; dest->VertexAttrib4dNV = loopback_VertexAttrib4dNV; dest->VertexAttrib4ubNV = loopback_VertexAttrib4ubNV; - dest->VertexAttrib1svNV = loopback_VertexAttrib1svNV; - dest->VertexAttrib1fvNV = loopback_VertexAttrib1fvNV; dest->VertexAttrib1dvNV = loopback_VertexAttrib1dvNV; dest->VertexAttrib2svNV = loopback_VertexAttrib2svNV; - dest->VertexAttrib2fvNV = loopback_VertexAttrib2fvNV; dest->VertexAttrib2dvNV = loopback_VertexAttrib2dvNV; dest->VertexAttrib3svNV = loopback_VertexAttrib3svNV; - dest->VertexAttrib3fvNV = loopback_VertexAttrib3fvNV; dest->VertexAttrib3dvNV = loopback_VertexAttrib3dvNV; dest->VertexAttrib4svNV = loopback_VertexAttrib4svNV; - dest->VertexAttrib4fvNV = loopback_VertexAttrib4fvNV; dest->VertexAttrib4dvNV = loopback_VertexAttrib4dvNV; dest->VertexAttrib4ubvNV = loopback_VertexAttrib4ubvNV; - dest->VertexAttribs1svNV = loopback_VertexAttribs1svNV; dest->VertexAttribs1fvNV = loopback_VertexAttribs1fvNV; dest->VertexAttribs1dvNV = loopback_VertexAttribs1dvNV; @@ -1551,6 +1614,24 @@ _mesa_loopback_init_api_table( struct _glapi_table *dest ) dest->VertexAttribs4dvNV = loopback_VertexAttribs4dvNV; dest->VertexAttribs4ubvNV = loopback_VertexAttribs4ubvNV; + dest->VertexAttrib1sARB = loopback_VertexAttrib1sARB; + dest->VertexAttrib1dARB = loopback_VertexAttrib1dARB; + dest->VertexAttrib2sARB = loopback_VertexAttrib2sARB; + dest->VertexAttrib2dARB = loopback_VertexAttrib2dARB; + dest->VertexAttrib3sARB = loopback_VertexAttrib3sARB; + dest->VertexAttrib3dARB = loopback_VertexAttrib3dARB; + dest->VertexAttrib4sARB = loopback_VertexAttrib4sARB; + dest->VertexAttrib4dARB = loopback_VertexAttrib4dARB; + dest->VertexAttrib1svARB = loopback_VertexAttrib1svARB; + dest->VertexAttrib1dvARB = loopback_VertexAttrib1dvARB; + dest->VertexAttrib2svARB = loopback_VertexAttrib2svARB; + dest->VertexAttrib2dvARB = loopback_VertexAttrib2dvARB; + dest->VertexAttrib3svARB = loopback_VertexAttrib3svARB; + dest->VertexAttrib3dvARB = loopback_VertexAttrib3dvARB; + dest->VertexAttrib4svARB = loopback_VertexAttrib4svARB; + dest->VertexAttrib4dvARB = loopback_VertexAttrib4dvARB; + dest->VertexAttrib4NubARB = loopback_VertexAttrib4NubARB; + dest->VertexAttrib4NubvARB = loopback_VertexAttrib4NubvARB; dest->VertexAttrib4bvARB = loopback_VertexAttrib4bvARB; dest->VertexAttrib4ivARB = loopback_VertexAttrib4ivARB; dest->VertexAttrib4ubvARB = loopback_VertexAttrib4ubvARB; diff --git a/src/mesa/main/api_noop.c b/src/mesa/main/api_noop.c index d09a449..661a720 100644 --- a/src/mesa/main/api_noop.c +++ b/src/mesa/main/api_noop.c @@ -394,7 +394,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib1fNV( GLuint index, GLfloat x ) ASSIGN_4V(ctx->Current.Attrib[index], x, 0, 0, 1); } else - _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib1f" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib1fNV" ); } void GLAPIENTRY _mesa_noop_VertexAttrib1fvNV( GLuint index, const GLfloat *v ) @@ -404,7 +404,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib1fvNV( GLuint index, const GLfloat *v ) ASSIGN_4V(ctx->Current.Attrib[index], v[0], 0, 0, 1); } else - _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib1fv" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib1fvNV" ); } void GLAPIENTRY _mesa_noop_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y ) @@ -414,7 +414,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y ASSIGN_4V(ctx->Current.Attrib[index], x, y, 0, 1); } else - _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib2f" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib2fNV" ); } void GLAPIENTRY _mesa_noop_VertexAttrib2fvNV( GLuint index, const GLfloat *v ) @@ -424,7 +424,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib2fvNV( GLuint index, const GLfloat *v ) ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], 0, 1); } else - _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib2fv" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib2fvNV" ); } void GLAPIENTRY _mesa_noop_VertexAttrib3fNV( GLuint index, GLfloat x, @@ -435,7 +435,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib3fNV( GLuint index, GLfloat x, ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, 1); } else - _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib3f" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib3fNV" ); } void GLAPIENTRY _mesa_noop_VertexAttrib3fvNV( GLuint index, const GLfloat *v ) @@ -445,7 +445,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib3fvNV( GLuint index, const GLfloat *v ) ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], 1); } else - _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib3fv" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib3fvNV" ); } void GLAPIENTRY _mesa_noop_VertexAttrib4fNV( GLuint index, GLfloat x, @@ -456,7 +456,7 @@ void GLAPIENTRY _mesa_noop_VertexAttrib4fNV( GLuint index, GLfloat x, ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, w); } else - _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib4f" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib4fNV" ); } void GLAPIENTRY _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat *v ) @@ -466,9 +466,98 @@ void GLAPIENTRY _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat *v ) ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], v[3]); } else - _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib4fv" ); + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib4fvNV" ); } + +/* + * XXX Un-alias attribs here + */ + +void GLAPIENTRY _mesa_noop_VertexAttrib1fARB( GLuint index, GLfloat x ) +{ + GET_CURRENT_CONTEXT(ctx); + if (index < VERT_ATTRIB_MAX) { + ASSIGN_4V(ctx->Current.Attrib[index], x, 0, 0, 1); + } + else + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib1fARB" ); +} + +void GLAPIENTRY _mesa_noop_VertexAttrib1fvARB( GLuint index, const GLfloat *v ) +{ + GET_CURRENT_CONTEXT(ctx); + if (index < VERT_ATTRIB_MAX) { + ASSIGN_4V(ctx->Current.Attrib[index], v[0], 0, 0, 1); + } + else + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib1fvARB" ); +} + +void GLAPIENTRY _mesa_noop_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y ) +{ + GET_CURRENT_CONTEXT(ctx); + if (index < VERT_ATTRIB_MAX) { + ASSIGN_4V(ctx->Current.Attrib[index], x, y, 0, 1); + } + else + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib2fARB" ); +} + +void GLAPIENTRY _mesa_noop_VertexAttrib2fvARB( GLuint index, const GLfloat *v ) +{ + GET_CURRENT_CONTEXT(ctx); + if (index < VERT_ATTRIB_MAX) { + ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], 0, 1); + } + else + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib2fvARB" ); +} + +void GLAPIENTRY _mesa_noop_VertexAttrib3fARB( GLuint index, GLfloat x, + GLfloat y, GLfloat z ) +{ + GET_CURRENT_CONTEXT(ctx); + if (index < VERT_ATTRIB_MAX) { + ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, 1); + } + else + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib3fARB" ); +} + +void GLAPIENTRY _mesa_noop_VertexAttrib3fvARB( GLuint index, const GLfloat *v ) +{ + GET_CURRENT_CONTEXT(ctx); + if (index < VERT_ATTRIB_MAX) { + ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], 1); + } + else + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib3fvARB" ); +} + +void GLAPIENTRY _mesa_noop_VertexAttrib4fARB( GLuint index, GLfloat x, + GLfloat y, GLfloat z, GLfloat w ) +{ + GET_CURRENT_CONTEXT(ctx); + if (index < VERT_ATTRIB_MAX) { + ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, w); + } + else + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib4fARB" ); +} + +void GLAPIENTRY _mesa_noop_VertexAttrib4fvARB( GLuint index, const GLfloat *v ) +{ + GET_CURRENT_CONTEXT(ctx); + if (index < VERT_ATTRIB_MAX) { + ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], v[3]); + } + else + _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttrib4fvARB" ); +} + + + /* Material */ void GLAPIENTRY _mesa_noop_Materialfv( GLenum face, GLenum pname, const GLfloat *params ) @@ -855,6 +944,14 @@ void _mesa_noop_vtxfmt_init( GLvertexformat *vfmt ) vfmt->VertexAttrib3fvNV = _mesa_noop_VertexAttrib3fvNV; vfmt->VertexAttrib4fNV = _mesa_noop_VertexAttrib4fNV; vfmt->VertexAttrib4fvNV = _mesa_noop_VertexAttrib4fvNV; + vfmt->VertexAttrib1fARB = _mesa_noop_VertexAttrib1fARB; + vfmt->VertexAttrib1fvARB = _mesa_noop_VertexAttrib1fvARB; + vfmt->VertexAttrib2fARB = _mesa_noop_VertexAttrib2fARB; + vfmt->VertexAttrib2fvARB = _mesa_noop_VertexAttrib2fvARB; + vfmt->VertexAttrib3fARB = _mesa_noop_VertexAttrib3fARB; + vfmt->VertexAttrib3fvARB = _mesa_noop_VertexAttrib3fvARB; + vfmt->VertexAttrib4fARB = _mesa_noop_VertexAttrib4fARB; + vfmt->VertexAttrib4fvARB = _mesa_noop_VertexAttrib4fvARB; vfmt->Rectf = _mesa_noop_Rectf; diff --git a/src/mesa/main/api_noop.h b/src/mesa/main/api_noop.h index 7bb9c88..56d930e 100644 --- a/src/mesa/main/api_noop.h +++ b/src/mesa/main/api_noop.h @@ -39,109 +39,76 @@ * */ extern void GLAPIENTRY _mesa_noop_EdgeFlag( GLboolean b ); - extern void GLAPIENTRY _mesa_noop_EdgeFlagv( const GLboolean *b ); extern void GLAPIENTRY _mesa_noop_FogCoordfEXT( GLfloat a ); - extern void GLAPIENTRY _mesa_noop_FogCoordfvEXT( const GLfloat *v ); extern void GLAPIENTRY _mesa_noop_Indexf( GLfloat i ); - extern void GLAPIENTRY _mesa_noop_Indexfv( const GLfloat *v ); extern void GLAPIENTRY _mesa_noop_Normal3f( GLfloat a, GLfloat b, GLfloat c ); - extern void GLAPIENTRY _mesa_noop_Normal3fv( const GLfloat *v ); extern void GLAPIENTRY _mesa_noop_Materialfv( GLenum face, GLenum pname, const GLfloat *param ); extern void _mesa_noop_Color4ub( GLubyte a, GLubyte b, GLubyte c, GLubyte d ); - extern void _mesa_noop_Color4ubv( const GLubyte *v ); - extern void GLAPIENTRY _mesa_noop_Color4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d ); - extern void GLAPIENTRY _mesa_noop_Color4fv( const GLfloat *v ); - extern void _mesa_noop_Color3ub( GLubyte a, GLubyte b, GLubyte c ); - extern void _mesa_noop_Color3ubv( const GLubyte *v ); - extern void GLAPIENTRY _mesa_noop_Color3f( GLfloat a, GLfloat b, GLfloat c ); - extern void GLAPIENTRY _mesa_noop_Color3fv( const GLfloat *v ); extern void GLAPIENTRY _mesa_noop_MultiTexCoord1fARB( GLenum target, GLfloat a ); - extern void GLAPIENTRY _mesa_noop_MultiTexCoord1fvARB( GLenum target, const GLfloat *v ); - -extern void GLAPIENTRY _mesa_noop_MultiTexCoord2fARB( GLenum target, GLfloat a, - GLfloat b ); - +extern void GLAPIENTRY _mesa_noop_MultiTexCoord2fARB( GLenum target, GLfloat a, GLfloat b ); extern void GLAPIENTRY _mesa_noop_MultiTexCoord2fvARB( GLenum target, const GLfloat *v ); - -extern void GLAPIENTRY _mesa_noop_MultiTexCoord3fARB( GLenum target, GLfloat a, - GLfloat b, GLfloat c); - +extern void GLAPIENTRY _mesa_noop_MultiTexCoord3fARB( GLenum target, GLfloat a, GLfloat b, GLfloat c); extern void GLAPIENTRY _mesa_noop_MultiTexCoord3fvARB( GLenum target, const GLfloat *v ); - -extern void GLAPIENTRY _mesa_noop_MultiTexCoord4fARB( GLenum target, GLfloat a, - GLfloat b, GLfloat c, GLfloat d ); - +extern void GLAPIENTRY _mesa_noop_MultiTexCoord4fARB( GLenum target, GLfloat a, GLfloat b, GLfloat c, GLfloat d ); extern void GLAPIENTRY _mesa_noop_MultiTexCoord4fvARB( GLenum target, const GLfloat *v ); -extern void _mesa_noop_SecondaryColor3ubEXT( GLubyte a, GLubyte b, GLubyte c ); - -extern void _mesa_noop_SecondaryColor3ubvEXT( const GLubyte *v ); - +extern void GLAPIENTRY _mesa_noop_SecondaryColor3ubEXT( GLubyte a, GLubyte b, GLubyte c ); +extern void GLAPIENTRY _mesa_noop_SecondaryColor3ubvEXT( const GLubyte *v ); extern void GLAPIENTRY _mesa_noop_SecondaryColor3fEXT( GLfloat a, GLfloat b, GLfloat c ); - extern void GLAPIENTRY _mesa_noop_SecondaryColor3fvEXT( const GLfloat *v ); extern void GLAPIENTRY _mesa_noop_TexCoord1f( GLfloat a ); - extern void GLAPIENTRY _mesa_noop_TexCoord1fv( const GLfloat *v ); - extern void GLAPIENTRY _mesa_noop_TexCoord2f( GLfloat a, GLfloat b ); - extern void GLAPIENTRY _mesa_noop_TexCoord2fv( const GLfloat *v ); - extern void GLAPIENTRY _mesa_noop_TexCoord3f( GLfloat a, GLfloat b, GLfloat c ); - extern void GLAPIENTRY _mesa_noop_TexCoord3fv( const GLfloat *v ); - extern void GLAPIENTRY _mesa_noop_TexCoord4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d ); - extern void GLAPIENTRY _mesa_noop_TexCoord4fv( const GLfloat *v ); -extern void GLAPIENTRY _mesa_noop_Vertex2fv( const GLfloat *v ); - -extern void GLAPIENTRY _mesa_noop_Vertex3fv( const GLfloat *v ); - -extern void GLAPIENTRY _mesa_noop_Vertex4fv( const GLfloat *v ); - extern void GLAPIENTRY _mesa_noop_Vertex2f( GLfloat a, GLfloat b ); - +extern void GLAPIENTRY _mesa_noop_Vertex2fv( const GLfloat *v ); extern void GLAPIENTRY _mesa_noop_Vertex3f( GLfloat a, GLfloat b, GLfloat c ); - +extern void GLAPIENTRY _mesa_noop_Vertex3fv( const GLfloat *v ); extern void GLAPIENTRY _mesa_noop_Vertex4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d ); +extern void GLAPIENTRY _mesa_noop_Vertex4fv( const GLfloat *v ); extern void GLAPIENTRY _mesa_noop_VertexAttrib1fNV( GLuint index, GLfloat x ); - extern void GLAPIENTRY _mesa_noop_VertexAttrib1fvNV( GLuint index, const GLfloat *v ); - extern void GLAPIENTRY _mesa_noop_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y ); extern void GLAPIENTRY _mesa_noop_VertexAttrib2fvNV( GLuint index, const GLfloat *v ); - -extern void GLAPIENTRY _mesa_noop_VertexAttrib3fNV( GLuint index, GLfloat x, - GLfloat y, GLfloat z ); +extern void GLAPIENTRY _mesa_noop_VertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z ); extern void GLAPIENTRY _mesa_noop_VertexAttrib3fvNV( GLuint index, const GLfloat *v ); - -extern void GLAPIENTRY _mesa_noop_VertexAttrib4fNV( GLuint index, GLfloat x, - GLfloat y, GLfloat z, GLfloat w ); +extern void GLAPIENTRY _mesa_noop_VertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ); extern void GLAPIENTRY _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat *v ); +extern void GLAPIENTRY _mesa_noop_VertexAttrib1fARB( GLuint index, GLfloat x ); +extern void GLAPIENTRY _mesa_noop_VertexAttrib1fvARB( GLuint index, const GLfloat *v ); +extern void GLAPIENTRY _mesa_noop_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y ); +extern void GLAPIENTRY _mesa_noop_VertexAttrib2fvARB( GLuint index, const GLfloat *v ); +extern void GLAPIENTRY _mesa_noop_VertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z ); +extern void GLAPIENTRY _mesa_noop_VertexAttrib3fvARB( GLuint index, const GLfloat *v ); +extern void GLAPIENTRY _mesa_noop_VertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ); +extern void GLAPIENTRY _mesa_noop_VertexAttrib4fvARB( GLuint index, const GLfloat *v ); + extern void GLAPIENTRY _mesa_noop_End( void ); extern void GLAPIENTRY _mesa_noop_Begin( GLenum mode ); diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h index 68e6273..23ec458 100644 --- a/src/mesa/main/dd.h +++ b/src/mesa/main/dd.h @@ -5,7 +5,7 @@ /* * Mesa 3-D graphics library - * Version: 6.1 + * Version: 6.3 * * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. * @@ -956,6 +956,14 @@ typedef struct { void (GLAPIENTRYP VertexAttrib3fvNV)( GLuint index, const GLfloat *v ); void (GLAPIENTRYP VertexAttrib4fNV)( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ); void (GLAPIENTRYP VertexAttrib4fvNV)( GLuint index, const GLfloat *v ); + void (GLAPIENTRYP VertexAttrib1fARB)( GLuint index, GLfloat x ); + void (GLAPIENTRYP VertexAttrib1fvARB)( GLuint index, const GLfloat *v ); + void (GLAPIENTRYP VertexAttrib2fARB)( GLuint index, GLfloat x, GLfloat y ); + void (GLAPIENTRYP VertexAttrib2fvARB)( GLuint index, const GLfloat *v ); + void (GLAPIENTRYP VertexAttrib3fARB)( GLuint index, GLfloat x, GLfloat y, GLfloat z ); + void (GLAPIENTRYP VertexAttrib3fvARB)( GLuint index, const GLfloat *v ); + void (GLAPIENTRYP VertexAttrib4fARB)( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ); + void (GLAPIENTRYP VertexAttrib4fvARB)( GLuint index, const GLfloat *v ); /*@}*/ /* diff --git a/src/mesa/main/dlist.c b/src/mesa/main/dlist.c index 9da97d8..348ba49 100644 --- a/src/mesa/main/dlist.c +++ b/src/mesa/main/dlist.c @@ -1,6 +1,6 @@ /* * Mesa 3-D graphics library - * Version: 6.1 + * Version: 6.3 * * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. * @@ -320,10 +320,14 @@ typedef enum { /* Vertex attributes -- fallback for when optimized display * list build isn't active. */ - OPCODE_ATTR_1F, - OPCODE_ATTR_2F, - OPCODE_ATTR_3F, - OPCODE_ATTR_4F, + OPCODE_ATTR_1F_NV, + OPCODE_ATTR_2F_NV, + OPCODE_ATTR_3F_NV, + OPCODE_ATTR_4F_NV, + OPCODE_ATTR_1F_ARB, + OPCODE_ATTR_2F_ARB, + OPCODE_ATTR_3F_ARB, + OPCODE_ATTR_4F_ARB, OPCODE_MATERIAL, OPCODE_INDEX, OPCODE_EDGEFLAG, @@ -785,10 +789,14 @@ _mesa_init_lists( void ) InstSize[OPCODE_END_QUERY_ARB] = 2; #endif InstSize[OPCODE_DRAW_BUFFERS_ARB] = 2 + MAX_DRAW_BUFFERS; - InstSize[OPCODE_ATTR_1F] = 3; - InstSize[OPCODE_ATTR_2F] = 4; - InstSize[OPCODE_ATTR_3F] = 5; - InstSize[OPCODE_ATTR_4F] = 6; + InstSize[OPCODE_ATTR_1F_NV] = 3; + InstSize[OPCODE_ATTR_2F_NV] = 4; + InstSize[OPCODE_ATTR_3F_NV] = 5; + InstSize[OPCODE_ATTR_4F_NV] = 6; + InstSize[OPCODE_ATTR_1F_ARB] = 3; + InstSize[OPCODE_ATTR_2F_ARB] = 4; + InstSize[OPCODE_ATTR_3F_ARB] = 5; + InstSize[OPCODE_ATTR_4F_ARB] = 6; InstSize[OPCODE_MATERIAL] = 7; InstSize[OPCODE_INDEX] = 2; InstSize[OPCODE_EDGEFLAG] = 2; @@ -4708,12 +4716,12 @@ save_DrawBuffersARB(GLsizei count, const GLenum *buffers) } -static void save_Attr1f( GLenum attr, GLfloat x ) +static void save_Attr1fNV( GLenum attr, GLfloat x ) { GET_CURRENT_CONTEXT(ctx); Node *n; SAVE_FLUSH_VERTICES( ctx ); - n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_1F, 2 ); + n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_1F_NV, 2 ); if (n) { n[1].e = attr; n[2].f = x; @@ -4728,12 +4736,12 @@ static void save_Attr1f( GLenum attr, GLfloat x ) } } -static void save_Attr2f( GLenum attr, GLfloat x, GLfloat y ) +static void save_Attr2fNV( GLenum attr, GLfloat x, GLfloat y ) { GET_CURRENT_CONTEXT(ctx); Node *n; SAVE_FLUSH_VERTICES( ctx ); - n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_2F, 3 ); + n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_2F_NV, 3 ); if (n) { n[1].e = attr; n[2].f = x; @@ -4749,12 +4757,12 @@ static void save_Attr2f( GLenum attr, GLfloat x, GLfloat y ) } } -static void save_Attr3f( GLenum attr, GLfloat x, GLfloat y, GLfloat z ) +static void save_Attr3fNV( GLenum attr, GLfloat x, GLfloat y, GLfloat z ) { GET_CURRENT_CONTEXT(ctx); Node *n; SAVE_FLUSH_VERTICES( ctx ); - n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_3F, 4 ); + n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_3F_NV, 4 ); if (n) { n[1].e = attr; n[2].f = x; @@ -4771,13 +4779,13 @@ static void save_Attr3f( GLenum attr, GLfloat x, GLfloat y, GLfloat z ) } } -static void save_Attr4f( GLenum attr, GLfloat x, GLfloat y, GLfloat z, - GLfloat w ) +static void save_Attr4fNV( GLenum attr, GLfloat x, GLfloat y, GLfloat z, + GLfloat w ) { GET_CURRENT_CONTEXT(ctx); Node *n; SAVE_FLUSH_VERTICES( ctx ); - n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_4F, 5 ); + n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_4F_NV, 5 ); if (n) { n[1].e = attr; n[2].f = x; @@ -4795,6 +4803,95 @@ static void save_Attr4f( GLenum attr, GLfloat x, GLfloat y, GLfloat z, } } + +static void save_Attr1fARB( GLenum attr, GLfloat x ) +{ + GET_CURRENT_CONTEXT(ctx); + Node *n; + SAVE_FLUSH_VERTICES( ctx ); + n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_1F_ARB, 2 ); + if (n) { + n[1].e = attr; + n[2].f = x; + } + + ASSERT(attr < VERT_ATTRIB_MAX); + ctx->ListState.ActiveAttribSize[attr] = 1; + ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1); + + if (ctx->ExecuteFlag) { + (*ctx->Exec->VertexAttrib1fARB)( attr, x ); + } +} + +static void save_Attr2fARB( GLenum attr, GLfloat x, GLfloat y ) +{ + GET_CURRENT_CONTEXT(ctx); + Node *n; + SAVE_FLUSH_VERTICES( ctx ); + n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_2F_ARB, 3 ); + if (n) { + n[1].e = attr; + n[2].f = x; + n[3].f = y; + } + + ASSERT(attr < VERT_ATTRIB_MAX); + ctx->ListState.ActiveAttribSize[attr] = 2; + ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, y, 0, 1); + + if (ctx->ExecuteFlag) { + (*ctx->Exec->VertexAttrib2fARB)( attr, x, y ); + } +} + +static void save_Attr3fARB( GLenum attr, GLfloat x, GLfloat y, GLfloat z ) +{ + GET_CURRENT_CONTEXT(ctx); + Node *n; + SAVE_FLUSH_VERTICES( ctx ); + n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_3F_ARB, 4 ); + if (n) { + n[1].e = attr; + n[2].f = x; + n[3].f = y; + n[4].f = z; + } + + ASSERT(attr < VERT_ATTRIB_MAX); + ctx->ListState.ActiveAttribSize[attr] = 3; + ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, y, z, 1); + + if (ctx->ExecuteFlag) { + (*ctx->Exec->VertexAttrib3fARB)( attr, x, y, z ); + } +} + +static void save_Attr4fARB( GLenum attr, GLfloat x, GLfloat y, GLfloat z, + GLfloat w ) +{ + GET_CURRENT_CONTEXT(ctx); + Node *n; + SAVE_FLUSH_VERTICES( ctx ); + n = ALLOC_INSTRUCTION( ctx, OPCODE_ATTR_4F_ARB, 5 ); + if (n) { + n[1].e = attr; + n[2].f = x; + n[3].f = y; + n[4].f = z; + n[5].f = w; + } + + ASSERT(attr < VERT_ATTRIB_MAX); + ctx->ListState.ActiveAttribSize[attr] = 4; + ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, y, z, w); + + if (ctx->ExecuteFlag) { + (*ctx->Exec->VertexAttrib4fARB)( attr, x, y, z, w ); + } +} + + static void GLAPIENTRY save_EvalCoord1f( GLfloat x ) { GET_CURRENT_CONTEXT(ctx); @@ -5024,8 +5121,7 @@ static void GLAPIENTRY save_End( void ) } } -static void GLAPIENTRY save_Rectf( GLfloat a, GLfloat b, - GLfloat c, GLfloat d ) +static void GLAPIENTRY save_Rectf( GLfloat a, GLfloat b, GLfloat c, GLfloat d ) { GET_CURRENT_CONTEXT(ctx); Node *n; @@ -5042,126 +5138,125 @@ static void GLAPIENTRY save_Rectf( GLfloat a, GLfloat b, } } -/* - */ + static void GLAPIENTRY save_Vertex2f( GLfloat x, GLfloat y ) { - save_Attr2f( VERT_ATTRIB_POS, x, y ); + save_Attr2fNV( VERT_ATTRIB_POS, x, y ); } static void GLAPIENTRY save_Vertex2fv( const GLfloat *v ) { - save_Attr2f( VERT_ATTRIB_POS, v[0], v[1] ); + save_Attr2fNV( VERT_ATTRIB_POS, v[0], v[1] ); } static void GLAPIENTRY save_Vertex3f( GLfloat x, GLfloat y, GLfloat z ) { - save_Attr3f( VERT_ATTRIB_POS, x, y, z ); + save_Attr3fNV( VERT_ATTRIB_POS, x, y, z ); } static void GLAPIENTRY save_Vertex3fv( const GLfloat *v ) { - save_Attr3f( VERT_ATTRIB_POS, v[0], v[1], v[2] ); + save_Attr3fNV( VERT_ATTRIB_POS, v[0], v[1], v[2] ); } static void GLAPIENTRY save_Vertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - save_Attr4f( VERT_ATTRIB_POS, x, y, z, w ); + save_Attr4fNV( VERT_ATTRIB_POS, x, y, z, w ); } static void GLAPIENTRY save_Vertex4fv( const GLfloat *v ) { - save_Attr4f( VERT_ATTRIB_POS, v[0], v[1], v[2], v[3] ); + save_Attr4fNV( VERT_ATTRIB_POS, v[0], v[1], v[2], v[3] ); } static void GLAPIENTRY save_TexCoord1f( GLfloat x ) { - save_Attr1f( VERT_ATTRIB_TEX0, x ); + save_Attr1fNV( VERT_ATTRIB_TEX0, x ); } static void GLAPIENTRY save_TexCoord1fv( const GLfloat *v ) { - save_Attr1f( VERT_ATTRIB_TEX0, v[0] ); + save_Attr1fNV( VERT_ATTRIB_TEX0, v[0] ); } static void GLAPIENTRY save_TexCoord2f( GLfloat x, GLfloat y ) { - save_Attr2f( VERT_ATTRIB_TEX0, x, y ); + save_Attr2fNV( VERT_ATTRIB_TEX0, x, y ); } static void GLAPIENTRY save_TexCoord2fv( const GLfloat *v ) { - save_Attr2f( VERT_ATTRIB_TEX0, v[0], v[1] ); + save_Attr2fNV( VERT_ATTRIB_TEX0, v[0], v[1] ); } static void GLAPIENTRY save_TexCoord3f( GLfloat x, GLfloat y, GLfloat z ) { - save_Attr3f( VERT_ATTRIB_TEX0, x, y, z ); + save_Attr3fNV( VERT_ATTRIB_TEX0, x, y, z ); } static void GLAPIENTRY save_TexCoord3fv( const GLfloat *v ) { - save_Attr3f( VERT_ATTRIB_TEX0, v[0], v[1], v[2] ); + save_Attr3fNV( VERT_ATTRIB_TEX0, v[0], v[1], v[2] ); } static void GLAPIENTRY save_TexCoord4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - save_Attr4f( VERT_ATTRIB_TEX0, x, y, z, w ); + save_Attr4fNV( VERT_ATTRIB_TEX0, x, y, z, w ); } static void GLAPIENTRY save_TexCoord4fv( const GLfloat *v ) { - save_Attr4f( VERT_ATTRIB_TEX0, v[0], v[1], v[2], v[3] ); + save_Attr4fNV( VERT_ATTRIB_TEX0, v[0], v[1], v[2], v[3] ); } static void GLAPIENTRY save_Normal3f( GLfloat x, GLfloat y, GLfloat z ) { - save_Attr3f( VERT_ATTRIB_NORMAL, x, y, z ); + save_Attr3fNV( VERT_ATTRIB_NORMAL, x, y, z ); } static void GLAPIENTRY save_Normal3fv( const GLfloat *v ) { - save_Attr3f( VERT_ATTRIB_NORMAL, v[0], v[1], v[2] ); + save_Attr3fNV( VERT_ATTRIB_NORMAL, v[0], v[1], v[2] ); } static void GLAPIENTRY save_FogCoordfEXT( GLfloat x ) { - save_Attr1f( VERT_ATTRIB_FOG, x ); + save_Attr1fNV( VERT_ATTRIB_FOG, x ); } static void GLAPIENTRY save_FogCoordfvEXT( const GLfloat *v ) { - save_Attr1f( VERT_ATTRIB_FOG, v[0] ); + save_Attr1fNV( VERT_ATTRIB_FOG, v[0] ); } static void GLAPIENTRY save_Color3f( GLfloat x, GLfloat y, GLfloat z ) { - save_Attr3f( VERT_ATTRIB_COLOR0, x, y, z ); + save_Attr3fNV( VERT_ATTRIB_COLOR0, x, y, z ); } static void GLAPIENTRY save_Color3fv( const GLfloat *v ) { - save_Attr3f( VERT_ATTRIB_COLOR0, v[0], v[1], v[2] ); + save_Attr3fNV( VERT_ATTRIB_COLOR0, v[0], v[1], v[2] ); } static void GLAPIENTRY save_Color4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - save_Attr4f( VERT_ATTRIB_COLOR0, x, y, z, w ); + save_Attr4fNV( VERT_ATTRIB_COLOR0, x, y, z, w ); } static void GLAPIENTRY save_Color4fv( const GLfloat *v ) { - save_Attr4f( VERT_ATTRIB_COLOR0, v[0], v[1], v[2], v[3] ); + save_Attr4fNV( VERT_ATTRIB_COLOR0, v[0], v[1], v[2], v[3] ); } static void GLAPIENTRY save_SecondaryColor3fEXT( GLfloat x, GLfloat y, GLfloat z ) { - save_Attr3f( VERT_ATTRIB_COLOR1, x, y, z ); + save_Attr3fNV( VERT_ATTRIB_COLOR1, x, y, z ); } static void GLAPIENTRY save_SecondaryColor3fvEXT( const GLfloat *v ) { - save_Attr3f( VERT_ATTRIB_COLOR1, v[0], v[1], v[2] ); + save_Attr3fNV( VERT_ATTRIB_COLOR1, v[0], v[1], v[2] ); } @@ -5170,51 +5265,51 @@ static void GLAPIENTRY save_SecondaryColor3fvEXT( const GLfloat *v ) static void GLAPIENTRY save_MultiTexCoord1f( GLenum target, GLfloat x ) { GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0; - save_Attr1f( attr, x ); + save_Attr1fNV( attr, x ); } static void GLAPIENTRY save_MultiTexCoord1fv( GLenum target, const GLfloat *v ) { GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0; - save_Attr1f( attr, v[0] ); + save_Attr1fNV( attr, v[0] ); } static void GLAPIENTRY save_MultiTexCoord2f( GLenum target, GLfloat x, GLfloat y ) { GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0; - save_Attr2f( attr, x, y ); + save_Attr2fNV( attr, x, y ); } static void GLAPIENTRY save_MultiTexCoord2fv( GLenum target, const GLfloat *v ) { GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0; - save_Attr2f( attr, v[0], v[1] ); + save_Attr2fNV( attr, v[0], v[1] ); } static void GLAPIENTRY save_MultiTexCoord3f( GLenum target, GLfloat x, GLfloat y, GLfloat z) { GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0; - save_Attr3f( attr, x, y, z ); + save_Attr3fNV( attr, x, y, z ); } static void GLAPIENTRY save_MultiTexCoord3fv( GLenum target, const GLfloat *v ) { GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0; - save_Attr3f( attr, v[0], v[1], v[2] ); + save_Attr3fNV( attr, v[0], v[1], v[2] ); } static void GLAPIENTRY save_MultiTexCoord4f( GLenum target, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0; - save_Attr4f( attr, x, y, z, w ); + save_Attr4fNV( attr, x, y, z, w ); } static void GLAPIENTRY save_MultiTexCoord4fv( GLenum target, const GLfloat *v ) { GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0; - save_Attr4f( attr, v[0], v[1], v[2], v[3] ); + save_Attr4fNV( attr, v[0], v[1], v[2], v[3] ); } @@ -5231,7 +5326,7 @@ static void enum_error( void ) static void GLAPIENTRY save_VertexAttrib1fNV( GLuint index, GLfloat x ) { if (index < VERT_ATTRIB_MAX) - save_Attr1f( index, x ); + save_Attr1fNV( index, x ); else enum_error(); } @@ -5239,7 +5334,7 @@ static void GLAPIENTRY save_VertexAttrib1fNV( GLuint index, GLfloat x ) static void GLAPIENTRY save_VertexAttrib1fvNV( GLuint index, const GLfloat *v ) { if (index < VERT_ATTRIB_MAX) - save_Attr1f( index, v[0] ); + save_Attr1fNV( index, v[0] ); else enum_error(); } @@ -5247,7 +5342,7 @@ static void GLAPIENTRY save_VertexAttrib1fvNV( GLuint index, const GLfloat *v ) static void GLAPIENTRY save_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y ) { if (index < VERT_ATTRIB_MAX) - save_Attr2f( index, x, y ); + save_Attr2fNV( index, x, y ); else enum_error(); } @@ -5255,7 +5350,7 @@ static void GLAPIENTRY save_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y static void GLAPIENTRY save_VertexAttrib2fvNV( GLuint index, const GLfloat *v ) { if (index < VERT_ATTRIB_MAX) - save_Attr2f( index, v[0], v[1] ); + save_Attr2fNV( index, v[0], v[1] ); else enum_error(); } @@ -5264,7 +5359,7 @@ static void GLAPIENTRY save_VertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y GLfloat z ) { if (index < VERT_ATTRIB_MAX) - save_Attr3f( index, x, y, z ); + save_Attr3fNV( index, x, y, z ); else enum_error(); } @@ -5272,7 +5367,7 @@ static void GLAPIENTRY save_VertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y static void GLAPIENTRY save_VertexAttrib3fvNV( GLuint index, const GLfloat *v ) { if (index < VERT_ATTRIB_MAX) - save_Attr3f( index, v[0], v[1], v[2] ); + save_Attr3fNV( index, v[0], v[1], v[2] ); else enum_error(); } @@ -5281,7 +5376,7 @@ static void GLAPIENTRY save_VertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y GLfloat z, GLfloat w ) { if (index < VERT_ATTRIB_MAX) - save_Attr4f( index, x, y, z, w ); + save_Attr4fNV( index, x, y, z, w ); else enum_error(); } @@ -5289,7 +5384,82 @@ static void GLAPIENTRY save_VertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y static void GLAPIENTRY save_VertexAttrib4fvNV( GLuint index, const GLfloat *v ) { if (index < VERT_ATTRIB_MAX) - save_Attr4f( index, v[0], v[1], v[2], v[3] ); + save_Attr4fNV( index, v[0], v[1], v[2], v[3] ); + else + enum_error(); +} + + + + +static void GLAPIENTRY +save_VertexAttrib1fARB( GLuint index, GLfloat x ) +{ + if (index < VERT_ATTRIB_MAX) + save_Attr1fARB( index, x ); + else + enum_error(); +} + +static void GLAPIENTRY +save_VertexAttrib1fvARB( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + save_Attr1fARB( index, v[0] ); + else + enum_error(); +} + +static void GLAPIENTRY +save_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y ) +{ + if (index < VERT_ATTRIB_MAX) + save_Attr2fARB( index, x, y ); + else + enum_error(); +} + +static void GLAPIENTRY +save_VertexAttrib2fvARB( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + save_Attr2fARB( index, v[0], v[1] ); + else + enum_error(); +} + +static void GLAPIENTRY +save_VertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z ) +{ + if (index < VERT_ATTRIB_MAX) + save_Attr3fARB( index, x, y, z ); + else + enum_error(); +} + +static void GLAPIENTRY +save_VertexAttrib3fvARB( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + save_Attr3fARB( index, v[0], v[1], v[2] ); + else + enum_error(); +} + +static void GLAPIENTRY +save_VertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) +{ + if (index < VERT_ATTRIB_MAX) + save_Attr4fARB( index, x, y, z, w ); + else + enum_error(); +} + +static void GLAPIENTRY +save_VertexAttrib4fvARB( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + save_Attr4fARB( index, v[0], v[1], v[2], v[3] ); else enum_error(); } @@ -6076,10 +6246,10 @@ execute_list( GLcontext *ctx, GLuint list ) ctx->Exec->DrawBuffersARB(n[1].i, buffers); } break; - case OPCODE_ATTR_1F: + case OPCODE_ATTR_1F_NV: (*ctx->Exec->VertexAttrib1fNV)(n[1].e, n[2].f); break; - case OPCODE_ATTR_2F: + case OPCODE_ATTR_2F_NV: /* Really shouldn't have to do this - the Node structure * is convenient, but it would be better to store the data * packed appropriately so that it can be sent directly @@ -6091,20 +6261,49 @@ execute_list( GLcontext *ctx, GLuint list ) else (*ctx->Exec->VertexAttrib2fNV)(n[1].e, n[2].f, n[3].f); break; - case OPCODE_ATTR_3F: + case OPCODE_ATTR_3F_NV: if (sizeof(Node)==sizeof(GLfloat)) (*ctx->Exec->VertexAttrib3fvNV)(n[1].e, &n[2].f); else (*ctx->Exec->VertexAttrib3fNV)(n[1].e, n[2].f, n[3].f, n[4].f); break; - case OPCODE_ATTR_4F: + case OPCODE_ATTR_4F_NV: if (sizeof(Node)==sizeof(GLfloat)) (*ctx->Exec->VertexAttrib4fvNV)(n[1].e, &n[2].f); else (*ctx->Exec->VertexAttrib4fNV)(n[1].e, n[2].f, n[3].f, n[4].f, n[5].f); break; + case OPCODE_ATTR_1F_ARB: + (*ctx->Exec->VertexAttrib1fARB)(n[1].e, n[2].f); + break; + case OPCODE_ATTR_2F_ARB: + /* Really shouldn't have to do this - the Node structure + * is convenient, but it would be better to store the data + * packed appropriately so that it can be sent directly + * on. With x86_64 becoming common, this will start to + * matter more. + */ + if (sizeof(Node)==sizeof(GLfloat)) + (*ctx->Exec->VertexAttrib2fvARB)(n[1].e, &n[2].f); + else + (*ctx->Exec->VertexAttrib2fARB)(n[1].e, n[2].f, n[3].f); + break; + case OPCODE_ATTR_3F_ARB: + if (sizeof(Node)==sizeof(GLfloat)) + (*ctx->Exec->VertexAttrib3fvARB)(n[1].e, &n[2].f); + else + (*ctx->Exec->VertexAttrib3fARB)(n[1].e, n[2].f, n[3].f, + n[4].f); + break; + case OPCODE_ATTR_4F_ARB: + if (sizeof(Node)==sizeof(GLfloat)) + (*ctx->Exec->VertexAttrib4fvARB)(n[1].e, &n[2].f); + else + (*ctx->Exec->VertexAttrib4fARB)(n[1].e, n[2].f, n[3].f, + n[4].f, n[5].f); + break; case OPCODE_MATERIAL: if (sizeof(Node)==sizeof(GLfloat)) (*ctx->Exec->Materialfv)(n[1].e, n[2].e, &n[3].f); @@ -7847,24 +8046,39 @@ static void GLAPIENTRY print_list( GLcontext *ctx, GLuint list ) n[1].i, n[2].i, n[3].i, n[4].i); break; - - - case OPCODE_ATTR_1F: - _mesa_printf("ATTR_1F attr %d: %f\n", + case OPCODE_ATTR_1F_NV: + _mesa_printf("ATTR_1F_NV attr %d: %f\n", + n[1].i, n[2].f); + break; + case OPCODE_ATTR_2F_NV: + _mesa_printf("ATTR_2F_NV attr %d: %f %f\n", + n[1].i, n[2].f, n[3].f); + break; + case OPCODE_ATTR_3F_NV: + _mesa_printf("ATTR_3F_NV attr %d: %f %f %f\n", + n[1].i, n[2].f, n[3].f, n[4].f); + break; + case OPCODE_ATTR_4F_NV: + _mesa_printf("ATTR_4F_NV attr %d: %f %f %f %f\n", + n[1].i, n[2].f, n[3].f, n[4].f, n[5].f); + break; + case OPCODE_ATTR_1F_ARB: + _mesa_printf("ATTR_1F_ARB attr %d: %f\n", n[1].i, n[2].f); break; - case OPCODE_ATTR_2F: - _mesa_printf("ATTR_2F attr %d: %f %f\n", + case OPCODE_ATTR_2F_ARB: + _mesa_printf("ATTR_2F_ARB attr %d: %f %f\n", n[1].i, n[2].f, n[3].f); break; - case OPCODE_ATTR_3F: - _mesa_printf("ATTR_3F attr %d: %f %f %f\n", + case OPCODE_ATTR_3F_ARB: + _mesa_printf("ATTR_3F_ARB attr %d: %f %f %f\n", n[1].i, n[2].f, n[3].f, n[4].f); break; - case OPCODE_ATTR_4F: - _mesa_printf("ATTR_4F attr %d: %f %f %f %f\n", + case OPCODE_ATTR_4F_ARB: + _mesa_printf("ATTR_4F_ARB attr %d: %f %f %f %f\n", n[1].i, n[2].f, n[3].f, n[4].f, n[5].f); break; + case OPCODE_MATERIAL: _mesa_printf("MATERIAL %x %x: %f %f %f %f\n", n[1].i, n[2].i, n[3].f, n[4].f, n[5].f, n[6].f); @@ -8009,6 +8223,14 @@ void _mesa_save_vtxfmt_init( GLvertexformat *vfmt ) vfmt->VertexAttrib3fvNV = save_VertexAttrib3fvNV; vfmt->VertexAttrib4fNV = save_VertexAttrib4fNV; vfmt->VertexAttrib4fvNV = save_VertexAttrib4fvNV; + vfmt->VertexAttrib1fARB = save_VertexAttrib1fARB; + vfmt->VertexAttrib1fvARB = save_VertexAttrib1fvARB; + vfmt->VertexAttrib2fARB = save_VertexAttrib2fARB; + vfmt->VertexAttrib2fvARB = save_VertexAttrib2fvARB; + vfmt->VertexAttrib3fARB = save_VertexAttrib3fARB; + vfmt->VertexAttrib3fvARB = save_VertexAttrib3fvARB; + vfmt->VertexAttrib4fARB = save_VertexAttrib4fARB; + vfmt->VertexAttrib4fvARB = save_VertexAttrib4fvARB; vfmt->EvalMesh1 = _mesa_save_EvalMesh1; vfmt->EvalMesh2 = _mesa_save_EvalMesh2; diff --git a/src/mesa/main/state.c b/src/mesa/main/state.c index babc186..76724c0 100644 --- a/src/mesa/main/state.c +++ b/src/mesa/main/state.c @@ -649,9 +649,9 @@ _mesa_init_exec_table(struct _glapi_table *exec) /* glDeleteProgramsARB aliases glDeleteProgramsNV */ /* glGenProgramsARB aliases glGenProgramsNV */ /* glIsProgramARB aliases glIsProgramNV */ - /* glGetVertexAttribdvARB aliases glGetVertexAttribdvNV */ - /* glGetVertexAttribfvARB aliases glGetVertexAttribfvNV */ - /* glGetVertexAttribivARB aliases glGetVertexAttribivNV */ + exec->GetVertexAttribdvARB = _mesa_GetVertexAttribdvARB; + exec->GetVertexAttribfvARB = _mesa_GetVertexAttribfvARB; + exec->GetVertexAttribivARB = _mesa_GetVertexAttribivARB; /* glGetVertexAttribPointervARB aliases glGetVertexAttribPointervNV */ exec->ProgramEnvParameter4dARB = _mesa_ProgramEnvParameter4dARB; exec->ProgramEnvParameter4dvARB = _mesa_ProgramEnvParameter4dvARB; diff --git a/src/mesa/main/vtxfmt.c b/src/mesa/main/vtxfmt.c index e45e5ca..3aaf7da 100644 --- a/src/mesa/main/vtxfmt.c +++ b/src/mesa/main/vtxfmt.c @@ -1,6 +1,6 @@ /* * Mesa 3-D graphics library - * Version: 6.1 + * Version: 6.3 * * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. * @@ -131,6 +131,14 @@ install_vtxfmt( struct _glapi_table *tab, const GLvertexformat *vfmt ) tab->VertexAttrib3fvNV = vfmt->VertexAttrib3fvNV; tab->VertexAttrib4fNV = vfmt->VertexAttrib4fNV; tab->VertexAttrib4fvNV = vfmt->VertexAttrib4fvNV; + tab->VertexAttrib1fARB = vfmt->VertexAttrib1fARB; + tab->VertexAttrib1fvARB = vfmt->VertexAttrib1fvARB; + tab->VertexAttrib2fARB = vfmt->VertexAttrib2fARB; + tab->VertexAttrib2fvARB = vfmt->VertexAttrib2fvARB; + tab->VertexAttrib3fARB = vfmt->VertexAttrib3fARB; + tab->VertexAttrib3fvARB = vfmt->VertexAttrib3fvARB; + tab->VertexAttrib4fARB = vfmt->VertexAttrib4fARB; + tab->VertexAttrib4fvARB = vfmt->VertexAttrib4fvARB; tab->Rectf = vfmt->Rectf; tab->DrawArrays = vfmt->DrawArrays; tab->DrawElements = vfmt->DrawElements; diff --git a/src/mesa/main/vtxfmt_tmp.h b/src/mesa/main/vtxfmt_tmp.h index 22a4b35..8b0bd79 100644 --- a/src/mesa/main/vtxfmt_tmp.h +++ b/src/mesa/main/vtxfmt_tmp.h @@ -1,9 +1,8 @@ - /* * Mesa 3-D graphics library - * Version: 4.1 + * Version: 6.3 * - * Copyright (C) 1999-2002 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2004 Brian Paul 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"), @@ -409,6 +408,55 @@ static void GLAPIENTRY TAG(VertexAttrib4fvNV)( GLuint index, const GLfloat *v ) } +static void GLAPIENTRY TAG(VertexAttrib1fARB)( GLuint index, GLfloat x ) +{ + PRE_LOOPBACK( VertexAttrib1fARB ); + GL_CALL(VertexAttrib1fARB)( index, x ); +} + +static void GLAPIENTRY TAG(VertexAttrib1fvARB)( GLuint index, const GLfloat *v ) +{ + PRE_LOOPBACK( VertexAttrib1fvARB ); + GL_CALL(VertexAttrib1fvARB)( index, v ); +} + +static void GLAPIENTRY TAG(VertexAttrib2fARB)( GLuint index, GLfloat x, GLfloat y ) +{ + PRE_LOOPBACK( VertexAttrib2fARB ); + GL_CALL(VertexAttrib2fARB)( index, x, y ); +} + +static void GLAPIENTRY TAG(VertexAttrib2fvARB)( GLuint index, const GLfloat *v ) +{ + PRE_LOOPBACK( VertexAttrib2fvARB ); + GL_CALL(VertexAttrib2fvARB)( index, v ); +} + +static void GLAPIENTRY TAG(VertexAttrib3fARB)( GLuint index, GLfloat x, GLfloat y, GLfloat z ) +{ + PRE_LOOPBACK( VertexAttrib3fARB ); + GL_CALL(VertexAttrib3fARB)( index, x, y, z ); +} + +static void GLAPIENTRY TAG(VertexAttrib3fvARB)( GLuint index, const GLfloat *v ) +{ + PRE_LOOPBACK( VertexAttrib3fvARB ); + GL_CALL(VertexAttrib3fvARB)( index, v ); +} + +static void GLAPIENTRY TAG(VertexAttrib4fARB)( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) +{ + PRE_LOOPBACK( VertexAttrib4fARB ); + GL_CALL(VertexAttrib4fARB)( index, x, y, z, w ); +} + +static void GLAPIENTRY TAG(VertexAttrib4fvARB)( GLuint index, const GLfloat *v ) +{ + PRE_LOOPBACK( VertexAttrib4fvARB ); + GL_CALL(VertexAttrib4fvARB)( index, v ); +} + + static GLvertexformat TAG(vtxfmt) = { TAG(ArrayElement), TAG(Color3f), @@ -466,6 +514,14 @@ static GLvertexformat TAG(vtxfmt) = { TAG(VertexAttrib3fvNV), TAG(VertexAttrib4fNV), TAG(VertexAttrib4fvNV), + TAG(VertexAttrib1fARB), + TAG(VertexAttrib1fvARB), + TAG(VertexAttrib2fARB), + TAG(VertexAttrib2fvARB), + TAG(VertexAttrib3fARB), + TAG(VertexAttrib3fvARB), + TAG(VertexAttrib4fARB), + TAG(VertexAttrib4fvARB), TAG(Rectf), TAG(DrawArrays), TAG(DrawElements), diff --git a/src/mesa/swrast/s_lines.c b/src/mesa/swrast/s_lines.c index 4d9fe58..a5a6123 100644 --- a/src/mesa/swrast/s_lines.c +++ b/src/mesa/swrast/s_lines.c @@ -258,7 +258,7 @@ _mesa_print_line_function(GLcontext *ctx) else if (swrast->Line == multitextured_line) _mesa_printf("multitextured_line\n"); else - _mesa_printf("Driver func %p\n", (void *) swrast->Line); + _mesa_printf("Driver func %p\n", (void *(*)()) swrast->Line); } #endif diff --git a/src/mesa/tnl/t_save_api.c b/src/mesa/tnl/t_save_api.c index 5a7e6b5..81b68f7 100644 --- a/src/mesa/tnl/t_save_api.c +++ b/src/mesa/tnl/t_save_api.c @@ -991,6 +991,79 @@ static void GLAPIENTRY _save_VertexAttrib4fvNV( GLuint index, const GLfloat *v ) } +static void GLAPIENTRY +_save_VertexAttrib1fARB( GLuint index, GLfloat x ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR1F( index, x ); + else + enum_error(); +} + +static void GLAPIENTRY +_save_VertexAttrib1fvARB( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR1FV( index, v ); + else + enum_error(); +} + +static void GLAPIENTRY +_save_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR2F( index, x, y ); + else + enum_error(); +} + +static void GLAPIENTRY +_save_VertexAttrib2fvARB( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR2FV( index, v ); + else + enum_error(); +} + +static void GLAPIENTRY +_save_VertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR3F( index, x, y, z ); + else + enum_error(); +} + +static void GLAPIENTRY +_save_VertexAttrib3fvARB( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR3FV( index, v ); + else + enum_error(); +} + +static void GLAPIENTRY +_save_VertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR4F( index, x, y, z, w ); + else + enum_error(); +} + +static void GLAPIENTRY +_save_VertexAttrib4fvARB( GLuint index, const GLfloat *v ) +{ + if (index < VERT_ATTRIB_MAX) + DISPATCH_ATTR4FV( index, v ); + else + enum_error(); +} + + /* Materials: * * These are treated as per-vertex attributes, at indices above where @@ -1427,6 +1500,14 @@ static void _save_vtxfmt_init( GLcontext *ctx ) vfmt->VertexAttrib3fvNV = _save_VertexAttrib3fvNV; vfmt->VertexAttrib4fNV = _save_VertexAttrib4fNV; vfmt->VertexAttrib4fvNV = _save_VertexAttrib4fvNV; + vfmt->VertexAttrib1fARB = _save_VertexAttrib1fARB; + vfmt->VertexAttrib1fvARB = _save_VertexAttrib1fvARB; + vfmt->VertexAttrib2fARB = _save_VertexAttrib2fARB; + vfmt->VertexAttrib2fvARB = _save_VertexAttrib2fvARB; + vfmt->VertexAttrib3fARB = _save_VertexAttrib3fARB; + vfmt->VertexAttrib3fvARB = _save_VertexAttrib3fvARB; + vfmt->VertexAttrib4fARB = _save_VertexAttrib4fARB; + vfmt->VertexAttrib4fvARB = _save_VertexAttrib4fvARB; /* This will all require us to fallback to saving the list as opcodes: */ diff --git a/src/mesa/tnl/t_save_loopback.c b/src/mesa/tnl/t_save_loopback.c index 2e752c8..66def96 100644 --- a/src/mesa/tnl/t_save_loopback.c +++ b/src/mesa/tnl/t_save_loopback.c @@ -1,9 +1,8 @@ - /* * Mesa 3-D graphics library - * Version: 5.1 + * Version: 6.3 * - * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2004 Brian Paul 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"), @@ -97,6 +96,39 @@ static attr_func vert_attrfunc[4] = { }; +static void VertexAttrib1fvARB(GLcontext *ctx, GLint target, const GLfloat *v) +{ + ctx->Exec->VertexAttrib1fvARB(target, v); +} + +static void VertexAttrib2fvARB(GLcontext *ctx, GLint target, const GLfloat *v) +{ + ctx->Exec->VertexAttrib2fvARB(target, v); +} + +static void VertexAttrib3fvARB(GLcontext *ctx, GLint target, const GLfloat *v) +{ + ctx->Exec->VertexAttrib3fvARB(target, v); +} + +static void VertexAttrib4fvARB(GLcontext *ctx, GLint target, const GLfloat *v) +{ + ctx->Exec->VertexAttrib4fvARB(target, v); +} + +static attr_func vert_attrfunc_arb[4] = { + VertexAttrib1fvARB, + VertexAttrib2fvARB, + VertexAttrib3fvARB, + VertexAttrib4fvARB +}; + + + + + + + static void mat_attr1fv( GLcontext *ctx, GLint target, const GLfloat *v ) { switch (target) { @@ -298,6 +330,8 @@ void _tnl_loopback_vertex_list( GLcontext *ctx, nr++; } + /* XXX ARB vertex attribs */ + for (i = 0 ; i < list->prim_count ; i++) { if (list->prim[i].mode & PRIM_WEAK) loopback_weak_prim( ctx, list, i, la, nr ); diff --git a/src/mesa/tnl/t_vtx_generic.c b/src/mesa/tnl/t_vtx_generic.c index daa7dea..0422fcd 100644 --- a/src/mesa/tnl/t_vtx_generic.c +++ b/src/mesa/tnl/t_vtx_generic.c @@ -361,6 +361,7 @@ static void GLAPIENTRY _tnl_MultiTexCoord4fv( GLenum target, DISPATCH_ATTR4FV( attr, v ); } + static void GLAPIENTRY _tnl_VertexAttrib1fNV( GLuint index, GLfloat x ) { if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; @@ -418,6 +419,67 @@ static void GLAPIENTRY _tnl_VertexAttrib4fvNV( GLuint index, } +/* + * XXX adjust index + */ + +static void GLAPIENTRY _tnl_VertexAttrib1fARB( GLuint index, GLfloat x ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR1F( index, x ); +} + +static void GLAPIENTRY _tnl_VertexAttrib1fvARB( GLuint index, + const GLfloat *v ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR1FV( index, v ); +} + +static void GLAPIENTRY _tnl_VertexAttrib2fARB( GLuint index, GLfloat x, + GLfloat y ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR2F( index, x, y ); +} + +static void GLAPIENTRY _tnl_VertexAttrib2fvARB( GLuint index, + const GLfloat *v ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR2FV( index, v ); +} + +static void GLAPIENTRY _tnl_VertexAttrib3fARB( GLuint index, GLfloat x, + GLfloat y, GLfloat z ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR3F( index, x, y, z ); +} + +static void GLAPIENTRY _tnl_VertexAttrib3fvARB( GLuint index, + const GLfloat *v ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR3FV( index, v ); +} + +static void GLAPIENTRY _tnl_VertexAttrib4fARB( GLuint index, GLfloat x, + GLfloat y, GLfloat z, + GLfloat w ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR4F( index, x, y, z, w ); +} + +static void GLAPIENTRY _tnl_VertexAttrib4fvARB( GLuint index, + const GLfloat *v ) +{ + if (index >= VERT_ATTRIB_MAX) index = ERROR_ATTRIB; + DISPATCH_ATTR4FV( index, v ); +} + + /* Install the generic versions of the 2nd level dispatch * functions. Some of these have a codegen alternative. */ @@ -465,4 +527,12 @@ void _tnl_generic_exec_vtxfmt_init( GLcontext *ctx ) vfmt->VertexAttrib3fvNV = _tnl_VertexAttrib3fvNV; vfmt->VertexAttrib4fNV = _tnl_VertexAttrib4fNV; vfmt->VertexAttrib4fvNV = _tnl_VertexAttrib4fvNV; + vfmt->VertexAttrib1fARB = _tnl_VertexAttrib1fARB; + vfmt->VertexAttrib1fvARB = _tnl_VertexAttrib1fvARB; + vfmt->VertexAttrib2fARB = _tnl_VertexAttrib2fARB; + vfmt->VertexAttrib2fvARB = _tnl_VertexAttrib2fvARB; + vfmt->VertexAttrib3fARB = _tnl_VertexAttrib3fARB; + vfmt->VertexAttrib3fvARB = _tnl_VertexAttrib3fvARB; + vfmt->VertexAttrib4fARB = _tnl_VertexAttrib4fARB; + vfmt->VertexAttrib4fvARB = _tnl_VertexAttrib4fvARB; } diff --git a/src/mesa/x86/glapi_x86.S b/src/mesa/x86/glapi_x86.S index 85ed65e..fb64025 100644 --- a/src/mesa/x86/glapi_x86.S +++ b/src/mesa/x86/glapi_x86.S @@ -704,9 +704,9 @@ GLNAME(gl_dispatch_functions_start): GL_STUB(GetProgramivNV, _gloffset_GetProgramivNV, GetProgramivNV@12) GL_STUB(GetProgramStringNV, _gloffset_GetProgramStringNV, GetProgramStringNV@12) GL_STUB(GetTrackMatrixivNV, _gloffset_GetTrackMatrixivNV, GetTrackMatrixivNV@16) - GL_STUB(GetVertexAttribdvNV, _gloffset_GetVertexAttribdvNV, GetVertexAttribdvNV@12) - GL_STUB(GetVertexAttribfvNV, _gloffset_GetVertexAttribfvNV, GetVertexAttribfvNV@12) - GL_STUB(GetVertexAttribivNV, _gloffset_GetVertexAttribivNV, GetVertexAttribivNV@12) + GL_STUB(GetVertexAttribdvARB, _gloffset_GetVertexAttribdvARB, GetVertexAttribdvARB@12) + GL_STUB(GetVertexAttribfvARB, _gloffset_GetVertexAttribfvARB, GetVertexAttribfvARB@12) + GL_STUB(GetVertexAttribivARB, _gloffset_GetVertexAttribivARB, GetVertexAttribivARB@12) GL_STUB(GetVertexAttribPointervNV, _gloffset_GetVertexAttribPointervNV, GetVertexAttribPointervNV@12) GL_STUB(IsProgramNV, _gloffset_IsProgramNV, IsProgramNV@4) GL_STUB(LoadProgramNV, _gloffset_LoadProgramNV, LoadProgramNV@16) @@ -719,32 +719,32 @@ GLNAME(gl_dispatch_functions_start): GL_STUB(RequestResidentProgramsNV, _gloffset_RequestResidentProgramsNV, RequestResidentProgramsNV@8) GL_STUB(TrackMatrixNV, _gloffset_TrackMatrixNV, TrackMatrixNV@16) GL_STUB(VertexAttribPointerNV, _gloffset_VertexAttribPointerNV, VertexAttribPointerNV@20) - GL_STUB(VertexAttrib1dNV, _gloffset_VertexAttrib1dNV, VertexAttrib1dNV@12) - GL_STUB(VertexAttrib1dvNV, _gloffset_VertexAttrib1dvNV, VertexAttrib1dvNV@8) - GL_STUB(VertexAttrib1fNV, _gloffset_VertexAttrib1fNV, VertexAttrib1fNV@8) - GL_STUB(VertexAttrib1fvNV, _gloffset_VertexAttrib1fvNV, VertexAttrib1fvNV@8) - GL_STUB(VertexAttrib1sNV, _gloffset_VertexAttrib1sNV, VertexAttrib1sNV@8) - GL_STUB(VertexAttrib1svNV, _gloffset_VertexAttrib1svNV, VertexAttrib1svNV@8) - GL_STUB(VertexAttrib2dNV, _gloffset_VertexAttrib2dNV, VertexAttrib2dNV@20) - GL_STUB(VertexAttrib2dvNV, _gloffset_VertexAttrib2dvNV, VertexAttrib2dvNV@8) - GL_STUB(VertexAttrib2fNV, _gloffset_VertexAttrib2fNV, VertexAttrib2fNV@12) - GL_STUB(VertexAttrib2fvNV, _gloffset_VertexAttrib2fvNV, VertexAttrib2fvNV@8) - GL_STUB(VertexAttrib2sNV, _gloffset_VertexAttrib2sNV, VertexAttrib2sNV@12) - GL_STUB(VertexAttrib2svNV, _gloffset_VertexAttrib2svNV, VertexAttrib2svNV@8) - GL_STUB(VertexAttrib3dNV, _gloffset_VertexAttrib3dNV, VertexAttrib3dNV@28) - GL_STUB(VertexAttrib3dvNV, _gloffset_VertexAttrib3dvNV, VertexAttrib3dvNV@8) - GL_STUB(VertexAttrib3fNV, _gloffset_VertexAttrib3fNV, VertexAttrib3fNV@16) - GL_STUB(VertexAttrib3fvNV, _gloffset_VertexAttrib3fvNV, VertexAttrib3fvNV@8) - GL_STUB(VertexAttrib3sNV, _gloffset_VertexAttrib3sNV, VertexAttrib3sNV@16) - GL_STUB(VertexAttrib3svNV, _gloffset_VertexAttrib3svNV, VertexAttrib3svNV@8) - GL_STUB(VertexAttrib4dNV, _gloffset_VertexAttrib4dNV, VertexAttrib4dNV@36) - GL_STUB(VertexAttrib4dvNV, _gloffset_VertexAttrib4dvNV, VertexAttrib4dvNV@8) - GL_STUB(VertexAttrib4fNV, _gloffset_VertexAttrib4fNV, VertexAttrib4fNV@20) - GL_STUB(VertexAttrib4fvNV, _gloffset_VertexAttrib4fvNV, VertexAttrib4fvNV@8) - GL_STUB(VertexAttrib4sNV, _gloffset_VertexAttrib4sNV, VertexAttrib4sNV@20) - GL_STUB(VertexAttrib4svNV, _gloffset_VertexAttrib4svNV, VertexAttrib4svNV@8) - GL_STUB(VertexAttrib4ubNV, _gloffset_VertexAttrib4ubNV, VertexAttrib4ubNV@20) - GL_STUB(VertexAttrib4ubvNV, _gloffset_VertexAttrib4ubvNV, VertexAttrib4ubvNV@8) + GL_STUB(VertexAttrib1dARB, _gloffset_VertexAttrib1dARB, VertexAttrib1dARB@12) + GL_STUB(VertexAttrib1dvARB, _gloffset_VertexAttrib1dvARB, VertexAttrib1dvARB@8) + GL_STUB(VertexAttrib1fARB, _gloffset_VertexAttrib1fARB, VertexAttrib1fARB@8) + GL_STUB(VertexAttrib1fvARB, _gloffset_VertexAttrib1fvARB, VertexAttrib1fvARB@8) + GL_STUB(VertexAttrib1sARB, _gloffset_VertexAttrib1sARB, VertexAttrib1sARB@8) + GL_STUB(VertexAttrib1svARB, _gloffset_VertexAttrib1svARB, VertexAttrib1svARB@8) + GL_STUB(VertexAttrib2dARB, _gloffset_VertexAttrib2dARB, VertexAttrib2dARB@20) + GL_STUB(VertexAttrib2dvARB, _gloffset_VertexAttrib2dvARB, VertexAttrib2dvARB@8) + GL_STUB(VertexAttrib2fARB, _gloffset_VertexAttrib2fARB, VertexAttrib2fARB@12) + GL_STUB(VertexAttrib2fvARB, _gloffset_VertexAttrib2fvARB, VertexAttrib2fvARB@8) + GL_STUB(VertexAttrib2sARB, _gloffset_VertexAttrib2sARB, VertexAttrib2sARB@12) + GL_STUB(VertexAttrib2svARB, _gloffset_VertexAttrib2svARB, VertexAttrib2svARB@8) + GL_STUB(VertexAttrib3dARB, _gloffset_VertexAttrib3dARB, VertexAttrib3dARB@28) + GL_STUB(VertexAttrib3dvARB, _gloffset_VertexAttrib3dvARB, VertexAttrib3dvARB@8) + GL_STUB(VertexAttrib3fARB, _gloffset_VertexAttrib3fARB, VertexAttrib3fARB@16) + GL_STUB(VertexAttrib3fvARB, _gloffset_VertexAttrib3fvARB, VertexAttrib3fvARB@8) + GL_STUB(VertexAttrib3sARB, _gloffset_VertexAttrib3sARB, VertexAttrib3sARB@16) + GL_STUB(VertexAttrib3svARB, _gloffset_VertexAttrib3svARB, VertexAttrib3svARB@8) + GL_STUB(VertexAttrib4dARB, _gloffset_VertexAttrib4dARB, VertexAttrib4dARB@36) + GL_STUB(VertexAttrib4dvARB, _gloffset_VertexAttrib4dvARB, VertexAttrib4dvARB@8) + GL_STUB(VertexAttrib4fARB, _gloffset_VertexAttrib4fARB, VertexAttrib4fARB@20) + GL_STUB(VertexAttrib4fvARB, _gloffset_VertexAttrib4fvARB, VertexAttrib4fvARB@8) + GL_STUB(VertexAttrib4sARB, _gloffset_VertexAttrib4sARB, VertexAttrib4sARB@20) + GL_STUB(VertexAttrib4svARB, _gloffset_VertexAttrib4svARB, VertexAttrib4svARB@8) + GL_STUB(VertexAttrib4NubARB, _gloffset_VertexAttrib4NubARB, VertexAttrib4NubARB@20) + GL_STUB(VertexAttrib4NubvARB, _gloffset_VertexAttrib4NubvARB, VertexAttrib4NubvARB@8) GL_STUB(VertexAttribs1dvNV, _gloffset_VertexAttribs1dvNV, VertexAttribs1dvNV@12) GL_STUB(VertexAttribs1fvNV, _gloffset_VertexAttribs1fvNV, VertexAttribs1fvNV@12) GL_STUB(VertexAttribs1svNV, _gloffset_VertexAttribs1svNV, VertexAttribs1svNV@12) @@ -869,6 +869,35 @@ GLNAME(gl_dispatch_functions_start): GL_STUB(BindAttribLocationARB, _gloffset_BindAttribLocationARB, BindAttribLocationARB@12) GL_STUB(GetActiveAttribARB, _gloffset_GetActiveAttribARB, GetActiveAttribARB@28) GL_STUB(GetAttribLocationARB, _gloffset_GetAttribLocationARB, GetAttribLocationARB@8) + GL_STUB(GetVertexAttribdvNV, _gloffset_GetVertexAttribdvNV, GetVertexAttribdvNV@12) + GL_STUB(GetVertexAttribfvNV, _gloffset_GetVertexAttribfvNV, GetVertexAttribfvNV@12) + GL_STUB(GetVertexAttribivNV, _gloffset_GetVertexAttribivNV, GetVertexAttribivNV@12) + GL_STUB(VertexAttrib1dNV, _gloffset_VertexAttrib1dNV, VertexAttrib1dNV@12) + GL_STUB(VertexAttrib1dvNV, _gloffset_VertexAttrib1dvNV, VertexAttrib1dvNV@8) + GL_STUB(VertexAttrib1fNV, _gloffset_VertexAttrib1fNV, VertexAttrib1fNV@8) + GL_STUB(VertexAttrib1fvNV, _gloffset_VertexAttrib1fvNV, VertexAttrib1fvNV@8) + GL_STUB(VertexAttrib1sNV, _gloffset_VertexAttrib1sNV, VertexAttrib1sNV@8) + GL_STUB(VertexAttrib1svNV, _gloffset_VertexAttrib1svNV, VertexAttrib1svNV@8) + GL_STUB(VertexAttrib2dNV, _gloffset_VertexAttrib2dNV, VertexAttrib2dNV@20) + GL_STUB(VertexAttrib2dvNV, _gloffset_VertexAttrib2dvNV, VertexAttrib2dvNV@8) + GL_STUB(VertexAttrib2fNV, _gloffset_VertexAttrib2fNV, VertexAttrib2fNV@12) + GL_STUB(VertexAttrib2fvNV, _gloffset_VertexAttrib2fvNV, VertexAttrib2fvNV@8) + GL_STUB(VertexAttrib2sNV, _gloffset_VertexAttrib2sNV, VertexAttrib2sNV@12) + GL_STUB(VertexAttrib2svNV, _gloffset_VertexAttrib2svNV, VertexAttrib2svNV@8) + GL_STUB(VertexAttrib3dNV, _gloffset_VertexAttrib3dNV, VertexAttrib3dNV@28) + GL_STUB(VertexAttrib3dvNV, _gloffset_VertexAttrib3dvNV, VertexAttrib3dvNV@8) + GL_STUB(VertexAttrib3fNV, _gloffset_VertexAttrib3fNV, VertexAttrib3fNV@16) + GL_STUB(VertexAttrib3fvNV, _gloffset_VertexAttrib3fvNV, VertexAttrib3fvNV@8) + GL_STUB(VertexAttrib3sNV, _gloffset_VertexAttrib3sNV, VertexAttrib3sNV@16) + GL_STUB(VertexAttrib3svNV, _gloffset_VertexAttrib3svNV, VertexAttrib3svNV@8) + GL_STUB(VertexAttrib4dNV, _gloffset_VertexAttrib4dNV, VertexAttrib4dNV@36) + GL_STUB(VertexAttrib4dvNV, _gloffset_VertexAttrib4dvNV, VertexAttrib4dvNV@8) + GL_STUB(VertexAttrib4fNV, _gloffset_VertexAttrib4fNV, VertexAttrib4fNV@20) + GL_STUB(VertexAttrib4fvNV, _gloffset_VertexAttrib4fvNV, VertexAttrib4fvNV@8) + GL_STUB(VertexAttrib4sNV, _gloffset_VertexAttrib4sNV, VertexAttrib4sNV@20) + GL_STUB(VertexAttrib4svNV, _gloffset_VertexAttrib4svNV, VertexAttrib4svNV@8) + GL_STUB(VertexAttrib4ubNV, _gloffset_VertexAttrib4ubNV, VertexAttrib4ubNV@20) + GL_STUB(VertexAttrib4ubvNV, _gloffset_VertexAttrib4ubvNV, VertexAttrib4ubvNV@8) GL_STUB(ActiveTexture, _gloffset_ActiveTextureARB, ActiveTexture@4) GL_STUB(ClientActiveTexture, _gloffset_ClientActiveTextureARB, ClientActiveTexture@4) GL_STUB(MultiTexCoord1d, _gloffset_MultiTexCoord1dARB, MultiTexCoord1d@12) @@ -997,39 +1026,10 @@ GLNAME(gl_dispatch_functions_start): GL_STUB(WindowPos3fvARB, _gloffset_WindowPos3fvMESA, WindowPos3fvARB@4) GL_STUB(WindowPos3ivARB, _gloffset_WindowPos3ivMESA, WindowPos3ivARB@4) GL_STUB(WindowPos3svARB, _gloffset_WindowPos3svMESA, WindowPos3svARB@4) - GL_STUB(VertexAttrib1sARB, _gloffset_VertexAttrib1sNV, VertexAttrib1sARB@8) - GL_STUB(VertexAttrib1fARB, _gloffset_VertexAttrib1fNV, VertexAttrib1fARB@8) - GL_STUB(VertexAttrib1dARB, _gloffset_VertexAttrib1dNV, VertexAttrib1dARB@12) - GL_STUB(VertexAttrib2sARB, _gloffset_VertexAttrib2sNV, VertexAttrib2sARB@12) - GL_STUB(VertexAttrib2fARB, _gloffset_VertexAttrib2fNV, VertexAttrib2fARB@12) - GL_STUB(VertexAttrib2dARB, _gloffset_VertexAttrib2dNV, VertexAttrib2dARB@20) - GL_STUB(VertexAttrib3sARB, _gloffset_VertexAttrib3sNV, VertexAttrib3sARB@16) - GL_STUB(VertexAttrib3fARB, _gloffset_VertexAttrib3fNV, VertexAttrib3fARB@16) - GL_STUB(VertexAttrib3dARB, _gloffset_VertexAttrib3dNV, VertexAttrib3dARB@28) - GL_STUB(VertexAttrib4sARB, _gloffset_VertexAttrib4sNV, VertexAttrib4sARB@20) - GL_STUB(VertexAttrib4fARB, _gloffset_VertexAttrib4fNV, VertexAttrib4fARB@20) - GL_STUB(VertexAttrib4dARB, _gloffset_VertexAttrib4dNV, VertexAttrib4dARB@36) - GL_STUB(VertexAttrib4NubARB, _gloffset_VertexAttrib4ubNV, VertexAttrib4NubARB@20) - GL_STUB(VertexAttrib1svARB, _gloffset_VertexAttrib1svNV, VertexAttrib1svARB@8) - GL_STUB(VertexAttrib1fvARB, _gloffset_VertexAttrib1fvNV, VertexAttrib1fvARB@8) - GL_STUB(VertexAttrib1dvARB, _gloffset_VertexAttrib1dvNV, VertexAttrib1dvARB@8) - GL_STUB(VertexAttrib2svARB, _gloffset_VertexAttrib2svNV, VertexAttrib2svARB@8) - GL_STUB(VertexAttrib2fvARB, _gloffset_VertexAttrib2fvNV, VertexAttrib2fvARB@8) - GL_STUB(VertexAttrib2dvARB, _gloffset_VertexAttrib2dvNV, VertexAttrib2dvARB@8) - GL_STUB(VertexAttrib3svARB, _gloffset_VertexAttrib3svNV, VertexAttrib3svARB@8) - GL_STUB(VertexAttrib3fvARB, _gloffset_VertexAttrib3fvNV, VertexAttrib3fvARB@8) - GL_STUB(VertexAttrib3dvARB, _gloffset_VertexAttrib3dvNV, VertexAttrib3dvARB@8) - GL_STUB(VertexAttrib4svARB, _gloffset_VertexAttrib4svNV, VertexAttrib4svARB@8) - GL_STUB(VertexAttrib4fvARB, _gloffset_VertexAttrib4fvNV, VertexAttrib4fvARB@8) - GL_STUB(VertexAttrib4dvARB, _gloffset_VertexAttrib4dvNV, VertexAttrib4dvARB@8) - GL_STUB(VertexAttrib4NubvARB, _gloffset_VertexAttrib4ubvNV, VertexAttrib4NubvARB@8) GL_STUB(BindProgramARB, _gloffset_BindProgramNV, BindProgramARB@8) GL_STUB(DeleteProgramsARB, _gloffset_DeleteProgramsNV, DeleteProgramsARB@8) GL_STUB(GenProgramsARB, _gloffset_GenProgramsNV, GenProgramsARB@8) GL_STUB(IsProgramARB, _gloffset_IsProgramNV, IsProgramARB@4) - GL_STUB(GetVertexAttribdvARB, _gloffset_GetVertexAttribdvNV, GetVertexAttribdvARB@12) - GL_STUB(GetVertexAttribfvARB, _gloffset_GetVertexAttribfvNV, GetVertexAttribfvARB@12) - GL_STUB(GetVertexAttribivARB, _gloffset_GetVertexAttribivNV, GetVertexAttribivARB@12) GL_STUB(GetVertexAttribPointervARB, _gloffset_GetVertexAttribPointervNV, GetVertexAttribPointervARB@12) GL_STUB(BlendColorEXT, _gloffset_BlendColor, BlendColorEXT@16) GL_STUB(TexImage3DEXT, _gloffset_TexImage3D, TexImage3DEXT@40) -- 2.7.4