X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fapi_arrayelt.c;h=d124c724c99473527e92c24df4a6024d5a2171ef;hb=99b77d05d2e8c4af5f7d752d6827c21fd6c4d5ee;hp=01ca30cbffdbf07c1bc5bd50e42ae80fcd573ecd;hpb=1e3d868ffbec46eecb85b4aaf6990d9ad69e830f;p=mesa.git diff --git a/src/mesa/main/api_arrayelt.c b/src/mesa/main/api_arrayelt.c index 01ca30cbffd..d124c724c99 100644 --- a/src/mesa/main/api_arrayelt.c +++ b/src/mesa/main/api_arrayelt.c @@ -1,8 +1,8 @@ /* * Mesa 3-D graphics library - * Version: 6.1 + * Version: 6.5.1 * - * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2006 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"), @@ -29,16 +29,16 @@ #include "glheader.h" #include "api_arrayelt.h" #include "context.h" -#include "glapi.h" #include "imports.h" #include "macros.h" -#include "mtypes.h" +#include "glapi/glapioffsets.h" +#include "glapi/dispatch.h" typedef void (GLAPIENTRY *array_func)( const void * ); typedef struct { const struct gl_client_array *array; - array_func func; + int offset; } AEarray; typedef void (GLAPIENTRY *attrib_func)( GLuint indx, const void *data ); @@ -53,596 +53,973 @@ typedef struct { AEarray arrays[32]; AEattrib attribs[VERT_ATTRIB_MAX + 1]; GLuint NewState; + + struct gl_buffer_object *vbo[VERT_ATTRIB_MAX]; + GLuint nr_vbos; + GLboolean mapped_vbos; + } AEcontext; #define AE_CONTEXT(ctx) ((AEcontext *)(ctx)->aelt_context) + /* * Convert GL_BYTE, GL_UNSIGNED_BYTE, .. GL_DOUBLE into an integer * in the range [0, 7]. Luckily these type tokens are sequentially - * numbered in gl.h + * numbered in gl.h, except for GL_DOUBLE. */ -#define TYPE_IDX(t) ((t) & 0xf) - - -static void (GLAPIENTRY *colorfuncs[2][8])( const void * ) = { - { (array_func)glColor3bv, - (array_func)glColor3ubv, - (array_func)glColor3sv, - (array_func)glColor3usv, - (array_func)glColor3iv, - (array_func)glColor3uiv, - (array_func)glColor3fv, - (array_func)glColor3dv }, - - { (array_func)glColor4bv, - (array_func)glColor4ubv, - (array_func)glColor4sv, - (array_func)glColor4usv, - (array_func)glColor4iv, - (array_func)glColor4uiv, - (array_func)glColor4fv, - (array_func)glColor4dv } +#define TYPE_IDX(t) ( (t) == GL_DOUBLE ? 7 : (t) & 7 ) + +static const int ColorFuncs[2][8] = { + { + _gloffset_Color3bv, + _gloffset_Color3ubv, + _gloffset_Color3sv, + _gloffset_Color3usv, + _gloffset_Color3iv, + _gloffset_Color3uiv, + _gloffset_Color3fv, + _gloffset_Color3dv, + }, + { + _gloffset_Color4bv, + _gloffset_Color4ubv, + _gloffset_Color4sv, + _gloffset_Color4usv, + _gloffset_Color4iv, + _gloffset_Color4uiv, + _gloffset_Color4fv, + _gloffset_Color4dv, + }, }; -static void (GLAPIENTRY *vertexfuncs[3][8])( const void * ) = { - { 0, - 0, - (array_func)glVertex2sv, - 0, - (array_func)glVertex2iv, - 0, - (array_func)glVertex2fv, - (array_func)glVertex2dv }, - - { 0, - 0, - (array_func)glVertex3sv, - 0, - (array_func)glVertex3iv, - 0, - (array_func)glVertex3fv, - (array_func)glVertex3dv }, - - { 0, - 0, - (array_func)glVertex4sv, - 0, - (array_func)glVertex4iv, - 0, - (array_func)glVertex4fv, - (array_func)glVertex4dv } +static const int VertexFuncs[3][8] = { + { + -1, + -1, + _gloffset_Vertex2sv, + -1, + _gloffset_Vertex2iv, + -1, + _gloffset_Vertex2fv, + _gloffset_Vertex2dv, + }, + { + -1, + -1, + _gloffset_Vertex3sv, + -1, + _gloffset_Vertex3iv, + -1, + _gloffset_Vertex3fv, + _gloffset_Vertex3dv, + }, + { + -1, + -1, + _gloffset_Vertex4sv, + -1, + _gloffset_Vertex4iv, + -1, + _gloffset_Vertex4fv, + _gloffset_Vertex4dv, + }, }; -static void (GLAPIENTRY *indexfuncs[8])( const void * ) = { - 0, - (array_func)glIndexubv, - (array_func)glIndexsv, - 0, - (array_func)glIndexiv, - 0, - (array_func)glIndexfv, - (array_func)glIndexdv +static const int IndexFuncs[8] = { + -1, + _gloffset_Indexubv, + _gloffset_Indexsv, + -1, + _gloffset_Indexiv, + -1, + _gloffset_Indexfv, + _gloffset_Indexdv, }; -static void (GLAPIENTRY *normalfuncs[8])( const void * ) = { - (array_func)glNormal3bv, - 0, - (array_func)glNormal3sv, - 0, - (array_func)glNormal3iv, - 0, - (array_func)glNormal3fv, - (array_func)glNormal3dv, +static const int NormalFuncs[8] = { + _gloffset_Normal3bv, + -1, + _gloffset_Normal3sv, + -1, + _gloffset_Normal3iv, + -1, + _gloffset_Normal3fv, + _gloffset_Normal3dv, }; +/* Note: _gloffset_* for these may not be a compile-time constant. */ +static int SecondaryColorFuncs[8]; +static int FogCoordFuncs[8]; -/* Wrapper functions in case glSecondaryColor*EXT doesn't exist */ -static void SecondaryColor3bvEXT(const GLbyte *c) + +/** + ** GL_NV_vertex_program + **/ + +/* GL_BYTE attributes */ + +static void GLAPIENTRY VertexAttrib1NbvNV(GLuint index, const GLbyte *v) { - _glapi_Dispatch->SecondaryColor3bvEXT(c); + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0]))); } -static void SecondaryColor3ubvEXT(const GLubyte *c) +static void GLAPIENTRY VertexAttrib1bvNV(GLuint index, const GLbyte *v) { - _glapi_Dispatch->SecondaryColor3ubvEXT(c); + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, (GLfloat)v[0])); } -static void SecondaryColor3svEXT(const GLshort *c) +static void GLAPIENTRY VertexAttrib2NbvNV(GLuint index, const GLbyte *v) { - _glapi_Dispatch->SecondaryColor3svEXT(c); + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]))); } -static void SecondaryColor3usvEXT(const GLushort *c) +static void GLAPIENTRY VertexAttrib2bvNV(GLuint index, const GLbyte *v) { - _glapi_Dispatch->SecondaryColor3usvEXT(c); + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); } -static void SecondaryColor3ivEXT(const GLint *c) +static void GLAPIENTRY VertexAttrib3NbvNV(GLuint index, const GLbyte *v) { - _glapi_Dispatch->SecondaryColor3ivEXT(c); + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0]), + BYTE_TO_FLOAT(v[1]), + BYTE_TO_FLOAT(v[2]))); } -static void SecondaryColor3uivEXT(const GLuint *c) +static void GLAPIENTRY VertexAttrib3bvNV(GLuint index, const GLbyte *v) { - _glapi_Dispatch->SecondaryColor3uivEXT(c); + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); } -static void SecondaryColor3fvEXT(const GLfloat *c) +static void GLAPIENTRY VertexAttrib4NbvNV(GLuint index, const GLbyte *v) { - _glapi_Dispatch->SecondaryColor3fvEXT(c); + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0]), + BYTE_TO_FLOAT(v[1]), + BYTE_TO_FLOAT(v[2]), + BYTE_TO_FLOAT(v[3]))); } -static void SecondaryColor3dvEXT(const GLdouble *c) +static void GLAPIENTRY VertexAttrib4bvNV(GLuint index, const GLbyte *v) { - _glapi_Dispatch->SecondaryColor3dvEXT(c); + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); } -static void (GLAPIENTRY *secondarycolorfuncs[8])( const void * ) = { - (array_func) SecondaryColor3bvEXT, - (array_func) SecondaryColor3ubvEXT, - (array_func) SecondaryColor3svEXT, - (array_func) SecondaryColor3usvEXT, - (array_func) SecondaryColor3ivEXT, - (array_func) SecondaryColor3uivEXT, - (array_func) SecondaryColor3fvEXT, - (array_func) SecondaryColor3dvEXT, -}; +/* GL_UNSIGNED_BYTE attributes */ +static void GLAPIENTRY VertexAttrib1NubvNV(GLuint index, const GLubyte *v) +{ + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, UBYTE_TO_FLOAT(v[0]))); +} -/* Again, wrapper functions in case glSecondaryColor*EXT doesn't exist */ -static void FogCoordfvEXT(const GLfloat *f) +static void GLAPIENTRY VertexAttrib1ubvNV(GLuint index, const GLubyte *v) { - _glapi_Dispatch->FogCoordfvEXT(f); + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, (GLfloat)v[0])); } -static void FogCoorddvEXT(const GLdouble *f) +static void GLAPIENTRY VertexAttrib2NubvNV(GLuint index, const GLubyte *v) +{ + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, UBYTE_TO_FLOAT(v[0]), + UBYTE_TO_FLOAT(v[1]))); +} + +static void GLAPIENTRY VertexAttrib2ubvNV(GLuint index, const GLubyte *v) +{ + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); +} + +static void GLAPIENTRY VertexAttrib3NubvNV(GLuint index, const GLubyte *v) +{ + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, UBYTE_TO_FLOAT(v[0]), + UBYTE_TO_FLOAT(v[1]), + UBYTE_TO_FLOAT(v[2]))); +} +static void GLAPIENTRY VertexAttrib3ubvNV(GLuint index, const GLubyte *v) { - _glapi_Dispatch->FogCoorddvEXT(f); + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); } -static void (GLAPIENTRY *fogcoordfuncs[8])( const void * ) = { - 0, - 0, - 0, - 0, - 0, - 0, - (array_func) FogCoordfvEXT, - (array_func) FogCoorddvEXT +static void GLAPIENTRY VertexAttrib4NubvNV(GLuint index, const GLubyte *v) +{ + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, UBYTE_TO_FLOAT(v[0]), + UBYTE_TO_FLOAT(v[1]), + UBYTE_TO_FLOAT(v[2]), + UBYTE_TO_FLOAT(v[3]))); +} + +static void GLAPIENTRY VertexAttrib4ubvNV(GLuint index, const GLubyte *v) +{ + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); +} + +/* GL_SHORT attributes */ + +static void GLAPIENTRY VertexAttrib1NsvNV(GLuint index, const GLshort *v) +{ + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0]))); +} + +static void GLAPIENTRY VertexAttrib1svNV(GLuint index, const GLshort *v) +{ + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, (GLfloat)v[0])); +} + +static void GLAPIENTRY VertexAttrib2NsvNV(GLuint index, const GLshort *v) +{ + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0]), + SHORT_TO_FLOAT(v[1]))); +} + +static void GLAPIENTRY VertexAttrib2svNV(GLuint index, const GLshort *v) +{ + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); +} + +static void GLAPIENTRY VertexAttrib3NsvNV(GLuint index, const GLshort *v) +{ + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0]), + SHORT_TO_FLOAT(v[1]), + SHORT_TO_FLOAT(v[2]))); +} + +static void GLAPIENTRY VertexAttrib3svNV(GLuint index, const GLshort *v) +{ + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); +} + +static void GLAPIENTRY VertexAttrib4NsvNV(GLuint index, const GLshort *v) +{ + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0]), + SHORT_TO_FLOAT(v[1]), + SHORT_TO_FLOAT(v[2]), + SHORT_TO_FLOAT(v[3]))); +} + +static void GLAPIENTRY VertexAttrib4svNV(GLuint index, const GLshort *v) +{ + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); +} + +/* GL_UNSIGNED_SHORT attributes */ + +static void GLAPIENTRY VertexAttrib1NusvNV(GLuint index, const GLushort *v) +{ + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, USHORT_TO_FLOAT(v[0]))); +} + +static void GLAPIENTRY VertexAttrib1usvNV(GLuint index, const GLushort *v) +{ + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, (GLfloat)v[0])); +} + +static void GLAPIENTRY VertexAttrib2NusvNV(GLuint index, const GLushort *v) +{ + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, USHORT_TO_FLOAT(v[0]), + USHORT_TO_FLOAT(v[1]))); +} + +static void GLAPIENTRY VertexAttrib2usvNV(GLuint index, const GLushort *v) +{ + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); +} + +static void GLAPIENTRY VertexAttrib3NusvNV(GLuint index, const GLushort *v) +{ + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, USHORT_TO_FLOAT(v[0]), + USHORT_TO_FLOAT(v[1]), + USHORT_TO_FLOAT(v[2]))); +} + +static void GLAPIENTRY VertexAttrib3usvNV(GLuint index, const GLushort *v) +{ + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); +} + +static void GLAPIENTRY VertexAttrib4NusvNV(GLuint index, const GLushort *v) +{ + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, USHORT_TO_FLOAT(v[0]), + USHORT_TO_FLOAT(v[1]), + USHORT_TO_FLOAT(v[2]), + USHORT_TO_FLOAT(v[3]))); +} + +static void GLAPIENTRY VertexAttrib4usvNV(GLuint index, const GLushort *v) +{ + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); +} + +/* GL_INT attributes */ + +static void GLAPIENTRY VertexAttrib1NivNV(GLuint index, const GLint *v) +{ + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, INT_TO_FLOAT(v[0]))); +} + +static void GLAPIENTRY VertexAttrib1ivNV(GLuint index, const GLint *v) +{ + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, (GLfloat)v[0])); +} + +static void GLAPIENTRY VertexAttrib2NivNV(GLuint index, const GLint *v) +{ + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, INT_TO_FLOAT(v[0]), + INT_TO_FLOAT(v[1]))); +} + +static void GLAPIENTRY VertexAttrib2ivNV(GLuint index, const GLint *v) +{ + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); +} + +static void GLAPIENTRY VertexAttrib3NivNV(GLuint index, const GLint *v) +{ + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, INT_TO_FLOAT(v[0]), + INT_TO_FLOAT(v[1]), + INT_TO_FLOAT(v[2]))); +} + +static void GLAPIENTRY VertexAttrib3ivNV(GLuint index, const GLint *v) +{ + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); +} + +static void GLAPIENTRY VertexAttrib4NivNV(GLuint index, const GLint *v) +{ + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, INT_TO_FLOAT(v[0]), + INT_TO_FLOAT(v[1]), + INT_TO_FLOAT(v[2]), + INT_TO_FLOAT(v[3]))); +} + +static void GLAPIENTRY VertexAttrib4ivNV(GLuint index, const GLint *v) +{ + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); +} + +/* GL_UNSIGNED_INT attributes */ + +static void GLAPIENTRY VertexAttrib1NuivNV(GLuint index, const GLuint *v) +{ + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, UINT_TO_FLOAT(v[0]))); +} + +static void GLAPIENTRY VertexAttrib1uivNV(GLuint index, const GLuint *v) +{ + CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, (GLfloat)v[0])); +} + +static void GLAPIENTRY VertexAttrib2NuivNV(GLuint index, const GLuint *v) +{ + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, UINT_TO_FLOAT(v[0]), + UINT_TO_FLOAT(v[1]))); +} + +static void GLAPIENTRY VertexAttrib2uivNV(GLuint index, const GLuint *v) +{ + CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); +} + +static void GLAPIENTRY VertexAttrib3NuivNV(GLuint index, const GLuint *v) +{ + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, UINT_TO_FLOAT(v[0]), + UINT_TO_FLOAT(v[1]), + UINT_TO_FLOAT(v[2]))); +} + +static void GLAPIENTRY VertexAttrib3uivNV(GLuint index, const GLuint *v) +{ + CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); +} + +static void GLAPIENTRY VertexAttrib4NuivNV(GLuint index, const GLuint *v) +{ + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, UINT_TO_FLOAT(v[0]), + UINT_TO_FLOAT(v[1]), + UINT_TO_FLOAT(v[2]), + UINT_TO_FLOAT(v[3]))); +} + +static void GLAPIENTRY VertexAttrib4uivNV(GLuint index, const GLuint *v) +{ + CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); +} + +/* GL_FLOAT attributes */ + +static void GLAPIENTRY VertexAttrib1fvNV(GLuint index, const GLfloat *v) +{ + CALL_VertexAttrib1fvNV(GET_DISPATCH(), (index, v)); +} + +static void GLAPIENTRY VertexAttrib2fvNV(GLuint index, const GLfloat *v) +{ + CALL_VertexAttrib2fvNV(GET_DISPATCH(), (index, v)); +} + +static void GLAPIENTRY VertexAttrib3fvNV(GLuint index, const GLfloat *v) +{ + CALL_VertexAttrib3fvNV(GET_DISPATCH(), (index, v)); +} + +static void GLAPIENTRY VertexAttrib4fvNV(GLuint index, const GLfloat *v) +{ + CALL_VertexAttrib4fvNV(GET_DISPATCH(), (index, v)); +} + +/* GL_DOUBLE attributes */ + +static void GLAPIENTRY VertexAttrib1dvNV(GLuint index, const GLdouble *v) +{ + CALL_VertexAttrib1dvNV(GET_DISPATCH(), (index, v)); +} + +static void GLAPIENTRY VertexAttrib2dvNV(GLuint index, const GLdouble *v) +{ + CALL_VertexAttrib2dvNV(GET_DISPATCH(), (index, v)); +} + +static void GLAPIENTRY VertexAttrib3dvNV(GLuint index, const GLdouble *v) +{ + CALL_VertexAttrib3dvNV(GET_DISPATCH(), (index, v)); +} + +static void GLAPIENTRY VertexAttrib4dvNV(GLuint index, const GLdouble *v) +{ + CALL_VertexAttrib4dvNV(GET_DISPATCH(), (index, v)); +} + + +/* + * Array [size][type] of VertexAttrib functions + */ +static attrib_func AttribFuncsNV[2][4][8] = { + { + /* non-normalized */ + { + /* size 1 */ + (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) 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) 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) 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) 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) 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) 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) VertexAttrib4NbvNV, + (attrib_func) VertexAttrib4NubvNV, + (attrib_func) VertexAttrib4NsvNV, + (attrib_func) VertexAttrib4NusvNV, + (attrib_func) VertexAttrib4NivNV, + (attrib_func) VertexAttrib4NuivNV, + (attrib_func) VertexAttrib4fvNV, + (attrib_func) VertexAttrib4dvNV + } + } }; -/**********************************************************************/ +/** + ** GL_ARB_vertex_program + **/ /* GL_BYTE attributes */ -static void VertexAttrib1Nbv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib1NbvARB(GLuint index, const GLbyte *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, BYTE_TO_FLOAT(v[0])); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0]))); } -static void VertexAttrib1bv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib1bvARB(GLuint index, const GLbyte *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, v[0]); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, (GLfloat)v[0])); } -static void VertexAttrib2Nbv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib2NbvARB(GLuint index, const GLbyte *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, BYTE_TO_FLOAT(v[0]), - BYTE_TO_FLOAT(v[1])); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]))); } -static void VertexAttrib2bv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib2bvARB(GLuint index, const GLbyte *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, v[0], v[1]); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); } -static void VertexAttrib3Nbv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib3NbvARB(GLuint index, const GLbyte *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, BYTE_TO_FLOAT(v[0]), - BYTE_TO_FLOAT(v[1]), - BYTE_TO_FLOAT(v[2])); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0]), + BYTE_TO_FLOAT(v[1]), + BYTE_TO_FLOAT(v[2]))); } -static void VertexAttrib3bv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib3bvARB(GLuint index, const GLbyte *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, v[0], v[1], v[2]); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); } -static void VertexAttrib4Nbv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib4NbvARB(GLuint index, const GLbyte *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, BYTE_TO_FLOAT(v[0]), - BYTE_TO_FLOAT(v[1]), - BYTE_TO_FLOAT(v[2]), - BYTE_TO_FLOAT(v[3])); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0]), + BYTE_TO_FLOAT(v[1]), + BYTE_TO_FLOAT(v[2]), + BYTE_TO_FLOAT(v[3]))); } -static void VertexAttrib4bv(GLuint index, const GLbyte *v) +static void GLAPIENTRY VertexAttrib4bvARB(GLuint index, const GLbyte *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, v[0], v[1], v[2], v[3]); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); } /* GL_UNSIGNED_BYTE attributes */ -static void VertexAttrib1Nubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib1NubvARB(GLuint index, const GLubyte *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, UBYTE_TO_FLOAT(v[0])); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, UBYTE_TO_FLOAT(v[0]))); } -static void VertexAttrib1ubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib1ubvARB(GLuint index, const GLubyte *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, v[0]); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, (GLfloat)v[0])); } -static void VertexAttrib2Nubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib2NubvARB(GLuint index, const GLubyte *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, UBYTE_TO_FLOAT(v[0]), - UBYTE_TO_FLOAT(v[1])); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, UBYTE_TO_FLOAT(v[0]), + UBYTE_TO_FLOAT(v[1]))); } -static void VertexAttrib2ubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib2ubvARB(GLuint index, const GLubyte *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, v[0], v[1]); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); } -static void VertexAttrib3Nubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib3NubvARB(GLuint index, const GLubyte *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, UBYTE_TO_FLOAT(v[0]), - UBYTE_TO_FLOAT(v[1]), - UBYTE_TO_FLOAT(v[2])); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, UBYTE_TO_FLOAT(v[0]), + UBYTE_TO_FLOAT(v[1]), + UBYTE_TO_FLOAT(v[2]))); } -static void VertexAttrib3ubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib3ubvARB(GLuint index, const GLubyte *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, v[0], v[1], v[2]); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); } -static void VertexAttrib4Nubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib4NubvARB(GLuint index, const GLubyte *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, UBYTE_TO_FLOAT(v[0]), + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, UBYTE_TO_FLOAT(v[0]), UBYTE_TO_FLOAT(v[1]), UBYTE_TO_FLOAT(v[2]), - UBYTE_TO_FLOAT(v[3])); + UBYTE_TO_FLOAT(v[3]))); } -static void VertexAttrib4ubv(GLuint index, const GLubyte *v) +static void GLAPIENTRY VertexAttrib4ubvARB(GLuint index, const GLubyte *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, v[0], v[1], v[2], v[3]); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); } /* GL_SHORT attributes */ -static void VertexAttrib1Nsv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib1NsvARB(GLuint index, const GLshort *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, SHORT_TO_FLOAT(v[0])); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0]))); } -static void VertexAttrib1sv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib1svARB(GLuint index, const GLshort *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, v[0]); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, (GLfloat)v[0])); } -static void VertexAttrib2Nsv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib2NsvARB(GLuint index, const GLshort *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, SHORT_TO_FLOAT(v[0]), - SHORT_TO_FLOAT(v[1])); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0]), + SHORT_TO_FLOAT(v[1]))); } -static void VertexAttrib2sv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib2svARB(GLuint index, const GLshort *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, v[0], v[1]); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); } -static void VertexAttrib3Nsv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib3NsvARB(GLuint index, const GLshort *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, SHORT_TO_FLOAT(v[0]), - SHORT_TO_FLOAT(v[1]), - SHORT_TO_FLOAT(v[2])); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0]), + SHORT_TO_FLOAT(v[1]), + SHORT_TO_FLOAT(v[2]))); } -static void VertexAttrib3sv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib3svARB(GLuint index, const GLshort *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, v[0], v[1], v[2]); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); } -static void VertexAttrib4Nsv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib4NsvARB(GLuint index, const GLshort *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, SHORT_TO_FLOAT(v[0]), - SHORT_TO_FLOAT(v[1]), - SHORT_TO_FLOAT(v[2]), - SHORT_TO_FLOAT(v[3])); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0]), + SHORT_TO_FLOAT(v[1]), + SHORT_TO_FLOAT(v[2]), + SHORT_TO_FLOAT(v[3]))); } -static void VertexAttrib4sv(GLuint index, const GLshort *v) +static void GLAPIENTRY VertexAttrib4svARB(GLuint index, const GLshort *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, v[0], v[1], v[2], v[3]); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); } /* GL_UNSIGNED_SHORT attributes */ -static void VertexAttrib1Nusv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib1NusvARB(GLuint index, const GLushort *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, USHORT_TO_FLOAT(v[0])); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, USHORT_TO_FLOAT(v[0]))); } -static void VertexAttrib1usv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib1usvARB(GLuint index, const GLushort *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, v[0]); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, (GLfloat)v[0])); } -static void VertexAttrib2Nusv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib2NusvARB(GLuint index, const GLushort *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, USHORT_TO_FLOAT(v[0]), - USHORT_TO_FLOAT(v[1])); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, USHORT_TO_FLOAT(v[0]), + USHORT_TO_FLOAT(v[1]))); } -static void VertexAttrib2usv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib2usvARB(GLuint index, const GLushort *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, v[0], v[1]); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); } -static void VertexAttrib3Nusv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib3NusvARB(GLuint index, const GLushort *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, USHORT_TO_FLOAT(v[0]), - USHORT_TO_FLOAT(v[1]), - USHORT_TO_FLOAT(v[2])); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, USHORT_TO_FLOAT(v[0]), + USHORT_TO_FLOAT(v[1]), + USHORT_TO_FLOAT(v[2]))); } -static void VertexAttrib3usv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib3usvARB(GLuint index, const GLushort *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, v[0], v[1], v[2]); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); } -static void VertexAttrib4Nusv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib4NusvARB(GLuint index, const GLushort *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, USHORT_TO_FLOAT(v[0]), - USHORT_TO_FLOAT(v[1]), - USHORT_TO_FLOAT(v[2]), - USHORT_TO_FLOAT(v[3])); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, USHORT_TO_FLOAT(v[0]), + USHORT_TO_FLOAT(v[1]), + USHORT_TO_FLOAT(v[2]), + USHORT_TO_FLOAT(v[3]))); } -static void VertexAttrib4usv(GLuint index, const GLushort *v) +static void GLAPIENTRY VertexAttrib4usvARB(GLuint index, const GLushort *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, v[0], v[1], v[2], v[3]); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); } /* GL_INT attributes */ -static void VertexAttrib1Niv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib1NivARB(GLuint index, const GLint *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, INT_TO_FLOAT(v[0])); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, INT_TO_FLOAT(v[0]))); } -static void VertexAttrib1iv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib1ivARB(GLuint index, const GLint *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, v[0]); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, (GLfloat)v[0])); } -static void VertexAttrib2Niv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib2NivARB(GLuint index, const GLint *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, INT_TO_FLOAT(v[0]), - INT_TO_FLOAT(v[1])); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, INT_TO_FLOAT(v[0]), + INT_TO_FLOAT(v[1]))); } -static void VertexAttrib2iv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib2ivARB(GLuint index, const GLint *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, v[0], v[1]); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); } -static void VertexAttrib3Niv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib3NivARB(GLuint index, const GLint *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, INT_TO_FLOAT(v[0]), - INT_TO_FLOAT(v[1]), - INT_TO_FLOAT(v[2])); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, INT_TO_FLOAT(v[0]), + INT_TO_FLOAT(v[1]), + INT_TO_FLOAT(v[2]))); } -static void VertexAttrib3iv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib3ivARB(GLuint index, const GLint *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, v[0], v[1], v[2]); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); } -static void VertexAttrib4Niv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib4NivARB(GLuint index, const GLint *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, INT_TO_FLOAT(v[0]), - INT_TO_FLOAT(v[1]), - INT_TO_FLOAT(v[2]), - INT_TO_FLOAT(v[3])); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, INT_TO_FLOAT(v[0]), + INT_TO_FLOAT(v[1]), + INT_TO_FLOAT(v[2]), + INT_TO_FLOAT(v[3]))); } -static void VertexAttrib4iv(GLuint index, const GLint *v) +static void GLAPIENTRY VertexAttrib4ivARB(GLuint index, const GLint *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, v[0], v[1], v[2], v[3]); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); } /* GL_UNSIGNED_INT attributes */ -static void VertexAttrib1Nuiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib1NuivARB(GLuint index, const GLuint *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, UINT_TO_FLOAT(v[0])); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, UINT_TO_FLOAT(v[0]))); } -static void VertexAttrib1uiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib1uivARB(GLuint index, const GLuint *v) { - _glapi_Dispatch->VertexAttrib1fNV(index, v[0]); + CALL_VertexAttrib1fARB(GET_DISPATCH(), (index, (GLfloat)v[0])); } -static void VertexAttrib2Nuiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib2NuivARB(GLuint index, const GLuint *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, UINT_TO_FLOAT(v[0]), - UINT_TO_FLOAT(v[1])); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, UINT_TO_FLOAT(v[0]), + UINT_TO_FLOAT(v[1]))); } -static void VertexAttrib2uiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib2uivARB(GLuint index, const GLuint *v) { - _glapi_Dispatch->VertexAttrib2fNV(index, v[0], v[1]); + CALL_VertexAttrib2fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1])); } -static void VertexAttrib3Nuiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib3NuivARB(GLuint index, const GLuint *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, UINT_TO_FLOAT(v[0]), - UINT_TO_FLOAT(v[1]), - UINT_TO_FLOAT(v[2])); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, UINT_TO_FLOAT(v[0]), + UINT_TO_FLOAT(v[1]), + UINT_TO_FLOAT(v[2]))); } -static void VertexAttrib3uiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib3uivARB(GLuint index, const GLuint *v) { - _glapi_Dispatch->VertexAttrib3fNV(index, v[0], v[1], v[2]); + CALL_VertexAttrib3fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2])); } -static void VertexAttrib4Nuiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib4NuivARB(GLuint index, const GLuint *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, UINT_TO_FLOAT(v[0]), - UINT_TO_FLOAT(v[1]), - UINT_TO_FLOAT(v[2]), - UINT_TO_FLOAT(v[3])); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, UINT_TO_FLOAT(v[0]), + UINT_TO_FLOAT(v[1]), + UINT_TO_FLOAT(v[2]), + UINT_TO_FLOAT(v[3]))); } -static void VertexAttrib4uiv(GLuint index, const GLuint *v) +static void GLAPIENTRY VertexAttrib4uivARB(GLuint index, const GLuint *v) { - _glapi_Dispatch->VertexAttrib4fNV(index, v[0], v[1], v[2], v[3]); + CALL_VertexAttrib4fARB(GET_DISPATCH(), (index, (GLfloat)v[0], (GLfloat)v[1], (GLfloat)v[2], (GLfloat)v[3])); } /* GL_FLOAT attributes */ -static void VertexAttrib1fv(GLuint index, const GLfloat *v) +static void GLAPIENTRY VertexAttrib1fvARB(GLuint index, const GLfloat *v) { - _glapi_Dispatch->VertexAttrib1fvNV(index, v); + CALL_VertexAttrib1fvARB(GET_DISPATCH(), (index, v)); } -static void VertexAttrib2fv(GLuint index, const GLfloat *v) +static void GLAPIENTRY VertexAttrib2fvARB(GLuint index, const GLfloat *v) { - _glapi_Dispatch->VertexAttrib2fvNV(index, v); + CALL_VertexAttrib2fvARB(GET_DISPATCH(), (index, v)); } -static void VertexAttrib3fv(GLuint index, const GLfloat *v) +static void GLAPIENTRY VertexAttrib3fvARB(GLuint index, const GLfloat *v) { - _glapi_Dispatch->VertexAttrib3fvNV(index, v); + CALL_VertexAttrib3fvARB(GET_DISPATCH(), (index, v)); } -static void VertexAttrib4fv(GLuint index, const GLfloat *v) +static void GLAPIENTRY VertexAttrib4fvARB(GLuint index, const GLfloat *v) { - _glapi_Dispatch->VertexAttrib4fvNV(index, v); + CALL_VertexAttrib4fvARB(GET_DISPATCH(), (index, v)); } /* GL_DOUBLE attributes */ -static void VertexAttrib1dv(GLuint index, const GLdouble *v) +static void GLAPIENTRY VertexAttrib1dvARB(GLuint index, const GLdouble *v) { - _glapi_Dispatch->VertexAttrib1dvNV(index, v); + CALL_VertexAttrib1dvARB(GET_DISPATCH(), (index, v)); } -static void VertexAttrib2dv(GLuint index, const GLdouble *v) +static void GLAPIENTRY VertexAttrib2dvARB(GLuint index, const GLdouble *v) { - _glapi_Dispatch->VertexAttrib2dvNV(index, v); + CALL_VertexAttrib2dvARB(GET_DISPATCH(), (index, v)); } -static void VertexAttrib3dv(GLuint index, const GLdouble *v) +static void GLAPIENTRY VertexAttrib3dvARB(GLuint index, const GLdouble *v) { - _glapi_Dispatch->VertexAttrib3dvNV(index, v); + CALL_VertexAttrib3dvARB(GET_DISPATCH(), (index, v)); } -static void VertexAttrib4dv(GLuint index, const GLdouble *v) +static void GLAPIENTRY VertexAttrib4dvARB(GLuint index, const GLdouble *v) { - _glapi_Dispatch->VertexAttrib4dvNV(index, v); + CALL_VertexAttrib4dvARB(GET_DISPATCH(), (index, v)); } /* * Array [size][type] of VertexAttrib functions */ -static void (GLAPIENTRY *attribfuncs[2][4][8])( GLuint, const void * ) = { +static attrib_func AttribFuncsARB[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) VertexAttrib1bvARB, + (attrib_func) VertexAttrib1ubvARB, + (attrib_func) VertexAttrib1svARB, + (attrib_func) VertexAttrib1usvARB, + (attrib_func) VertexAttrib1ivARB, + (attrib_func) VertexAttrib1uivARB, + (attrib_func) VertexAttrib1fvARB, + (attrib_func) VertexAttrib1dvARB }, { /* 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) VertexAttrib2bvARB, + (attrib_func) VertexAttrib2ubvARB, + (attrib_func) VertexAttrib2svARB, + (attrib_func) VertexAttrib2usvARB, + (attrib_func) VertexAttrib2ivARB, + (attrib_func) VertexAttrib2uivARB, + (attrib_func) VertexAttrib2fvARB, + (attrib_func) VertexAttrib2dvARB }, { /* 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) VertexAttrib3bvARB, + (attrib_func) VertexAttrib3ubvARB, + (attrib_func) VertexAttrib3svARB, + (attrib_func) VertexAttrib3usvARB, + (attrib_func) VertexAttrib3ivARB, + (attrib_func) VertexAttrib3uivARB, + (attrib_func) VertexAttrib3fvARB, + (attrib_func) VertexAttrib3dvARB }, { /* 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) VertexAttrib4bvARB, + (attrib_func) VertexAttrib4ubvARB, + (attrib_func) VertexAttrib4svARB, + (attrib_func) VertexAttrib4usvARB, + (attrib_func) VertexAttrib4ivARB, + (attrib_func) VertexAttrib4uivARB, + (attrib_func) VertexAttrib4fvARB, + (attrib_func) VertexAttrib4dvARB } }, { /* 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) VertexAttrib1NbvARB, + (attrib_func) VertexAttrib1NubvARB, + (attrib_func) VertexAttrib1NsvARB, + (attrib_func) VertexAttrib1NusvARB, + (attrib_func) VertexAttrib1NivARB, + (attrib_func) VertexAttrib1NuivARB, + (attrib_func) VertexAttrib1fvARB, + (attrib_func) VertexAttrib1dvARB }, { /* 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) VertexAttrib2NbvARB, + (attrib_func) VertexAttrib2NubvARB, + (attrib_func) VertexAttrib2NsvARB, + (attrib_func) VertexAttrib2NusvARB, + (attrib_func) VertexAttrib2NivARB, + (attrib_func) VertexAttrib2NuivARB, + (attrib_func) VertexAttrib2fvARB, + (attrib_func) VertexAttrib2dvARB }, { /* 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) VertexAttrib3NbvARB, + (attrib_func) VertexAttrib3NubvARB, + (attrib_func) VertexAttrib3NsvARB, + (attrib_func) VertexAttrib3NusvARB, + (attrib_func) VertexAttrib3NivARB, + (attrib_func) VertexAttrib3NuivARB, + (attrib_func) VertexAttrib3fvARB, + (attrib_func) VertexAttrib3dvARB }, { /* 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) VertexAttrib4NbvARB, + (attrib_func) VertexAttrib4NubvARB, + (attrib_func) VertexAttrib4NsvARB, + (attrib_func) VertexAttrib4NusvARB, + (attrib_func) VertexAttrib4NivARB, + (attrib_func) VertexAttrib4NuivARB, + (attrib_func) VertexAttrib4fvARB, + (attrib_func) VertexAttrib4dvARB } } }; @@ -655,7 +1032,26 @@ GLboolean _ae_create_context( GLcontext *ctx ) if (ctx->aelt_context) return GL_TRUE; - ctx->aelt_context = MALLOC( sizeof(AEcontext) ); + /* These _gloffset_* values may not be compile-time constants */ + SecondaryColorFuncs[0] = _gloffset_SecondaryColor3bvEXT; + SecondaryColorFuncs[1] = _gloffset_SecondaryColor3ubvEXT; + SecondaryColorFuncs[2] = _gloffset_SecondaryColor3svEXT; + SecondaryColorFuncs[3] = _gloffset_SecondaryColor3usvEXT; + SecondaryColorFuncs[4] = _gloffset_SecondaryColor3ivEXT; + SecondaryColorFuncs[5] = _gloffset_SecondaryColor3uivEXT; + SecondaryColorFuncs[6] = _gloffset_SecondaryColor3fvEXT; + SecondaryColorFuncs[7] = _gloffset_SecondaryColor3dvEXT; + + FogCoordFuncs[0] = -1; + FogCoordFuncs[1] = -1; + FogCoordFuncs[2] = -1; + FogCoordFuncs[3] = -1; + FogCoordFuncs[4] = -1; + FogCoordFuncs[5] = -1; + FogCoordFuncs[6] = _gloffset_FogCoordfvEXT; + FogCoordFuncs[7] = _gloffset_FogCoorddvEXT; + + ctx->aelt_context = CALLOC( sizeof(AEcontext) ); if (!ctx->aelt_context) return GL_FALSE; @@ -668,7 +1064,20 @@ void _ae_destroy_context( GLcontext *ctx ) { if ( AE_CONTEXT( ctx ) ) { FREE( ctx->aelt_context ); - ctx->aelt_context = 0; + ctx->aelt_context = NULL; + } +} + +static void check_vbo( AEcontext *actx, + struct gl_buffer_object *vbo ) +{ + if (vbo->Name && !vbo->Pointer) { + GLuint i; + for (i = 0; i < actx->nr_vbos; i++) + if (actx->vbo[i] == vbo) + return; + assert(actx->nr_vbos < VERT_ATTRIB_MAX); + actx->vbo[actx->nr_vbos++] = vbo; } } @@ -686,91 +1095,156 @@ static void _ae_update_state( GLcontext *ctx ) AEattrib *at = actx->attribs; GLuint i; + actx->nr_vbos = 0; + /* conventional vertex arrays */ - if (ctx->Array.Index.Enabled) { - aa->array = &ctx->Array.Index; - aa->func = indexfuncs[TYPE_IDX(aa->array->Type)]; + if (ctx->Array.ArrayObj->Index.Enabled) { + aa->array = &ctx->Array.ArrayObj->Index; + aa->offset = IndexFuncs[TYPE_IDX(aa->array->Type)]; + check_vbo(actx, aa->array->BufferObj); aa++; } - if (ctx->Array.EdgeFlag.Enabled) { - aa->array = &ctx->Array.EdgeFlag; - aa->func = (array_func) glEdgeFlagv; + if (ctx->Array.ArrayObj->EdgeFlag.Enabled) { + aa->array = &ctx->Array.ArrayObj->EdgeFlag; + aa->offset = _gloffset_EdgeFlagv; + check_vbo(actx, aa->array->BufferObj); aa++; } - if (ctx->Array.Normal.Enabled) { - aa->array = &ctx->Array.Normal; - aa->func = normalfuncs[TYPE_IDX(aa->array->Type)]; + if (ctx->Array.ArrayObj->Normal.Enabled) { + aa->array = &ctx->Array.ArrayObj->Normal; + aa->offset = NormalFuncs[TYPE_IDX(aa->array->Type)]; + check_vbo(actx, aa->array->BufferObj); aa++; } - if (ctx->Array.Color.Enabled) { - aa->array = &ctx->Array.Color; - aa->func = colorfuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)]; + if (ctx->Array.ArrayObj->Color.Enabled) { + aa->array = &ctx->Array.ArrayObj->Color; + aa->offset = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)]; + check_vbo(actx, aa->array->BufferObj); aa++; } - if (ctx->Array.SecondaryColor.Enabled) { - aa->array = &ctx->Array.SecondaryColor; - aa->func = secondarycolorfuncs[TYPE_IDX(aa->array->Type)]; + if (ctx->Array.ArrayObj->SecondaryColor.Enabled) { + aa->array = &ctx->Array.ArrayObj->SecondaryColor; + aa->offset = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)]; + check_vbo(actx, aa->array->BufferObj); aa++; } - if (ctx->Array.FogCoord.Enabled) { - aa->array = &ctx->Array.FogCoord; - aa->func = fogcoordfuncs[TYPE_IDX(aa->array->Type)]; + if (ctx->Array.ArrayObj->FogCoord.Enabled) { + aa->array = &ctx->Array.ArrayObj->FogCoord; + aa->offset = FogCoordFuncs[TYPE_IDX(aa->array->Type)]; + check_vbo(actx, aa->array->BufferObj); aa++; } for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { - if (ctx->Array.TexCoord[i].Enabled) { - /* NOTE: we use generic glVertexAttrib functions here. - * If we ever de-alias conventional/generic vertex attribs this - * will have to change. + struct gl_client_array *attribArray = &ctx->Array.ArrayObj->TexCoord[i]; + if (attribArray->Enabled) { + /* NOTE: we use generic glVertexAttribNV functions here. + * If we ever remove GL_NV_vertex_program this will have to change. */ - 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->index = i; + ASSERT(!at->array->Normalized); + at->func = AttribFuncsNV[at->array->Normalized] + [at->array->Size-1] + [TYPE_IDX(at->array->Type)]; + at->index = VERT_ATTRIB_TEX0 + i; + check_vbo(actx, at->array->BufferObj); at++; } } - /* generic vertex attribute arrays */ + /* generic vertex attribute arrays */ for (i = 1; i < VERT_ATTRIB_MAX; i++) { /* skip zero! */ - if (ctx->Array.VertexAttrib[i].Enabled) { - struct gl_client_array *attribArray = &ctx->Array.VertexAttrib[i]; + struct gl_client_array *attribArray = &ctx->Array.ArrayObj->VertexAttrib[i]; + if (attribArray->Enabled) { at->array = attribArray; /* Note: we can't grab the _glapi_Dispatch->VertexAttrib1fvNV * function pointer here (for float arrays) since the pointer may * 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)]; + if (ctx->VertexProgram._Enabled + && ctx->VertexProgram.Current->IsNVProgram) { + at->func = AttribFuncsNV[at->array->Normalized] + [at->array->Size-1] + [TYPE_IDX(at->array->Type)]; + } + else { + at->func = AttribFuncsARB[at->array->Normalized] + [at->array->Size-1] + [TYPE_IDX(at->array->Type)]; + } at->index = i; + check_vbo(actx, at->array->BufferObj); at++; } } /* finally, vertex position */ - if (ctx->Array.VertexAttrib[0].Enabled) { + if (ctx->Array.ArrayObj->VertexAttrib[0].Enabled) { /* Use glVertex(v) instead of glVertexAttrib(0, v) to be sure it's - * issued as the last (proviking) attribute). + * issued as the last (provoking) attribute). */ - aa->array = &ctx->Array.VertexAttrib[0]; + aa->array = &ctx->Array.ArrayObj->VertexAttrib[0]; assert(aa->array->Size >= 2); /* XXX fix someday? */ - aa->func = vertexfuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; + aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; + check_vbo(actx, aa->array->BufferObj); aa++; } - else if (ctx->Array.Vertex.Enabled) { - aa->array = &ctx->Array.Vertex; - aa->func = vertexfuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; + else if (ctx->Array.ArrayObj->Vertex.Enabled) { + aa->array = &ctx->Array.ArrayObj->Vertex; + aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)]; + check_vbo(actx, aa->array->BufferObj); aa++; } + check_vbo(actx, ctx->Array.ElementArrayBufferObj); + ASSERT(at - actx->attribs <= VERT_ATTRIB_MAX); ASSERT(aa - actx->arrays < 32); at->func = NULL; /* terminate the list */ - aa->func = NULL; /* terminate the list */ + aa->offset = -1; /* terminate the list */ actx->NewState = 0; } +void _ae_map_vbos( GLcontext *ctx ) +{ + AEcontext *actx = AE_CONTEXT(ctx); + GLuint i; + + if (actx->mapped_vbos) + return; + + if (actx->NewState) + _ae_update_state(ctx); + + for (i = 0; i < actx->nr_vbos; i++) + ctx->Driver.MapBuffer(ctx, + GL_ARRAY_BUFFER_ARB, + GL_DYNAMIC_DRAW_ARB, + actx->vbo[i]); + + if (actx->nr_vbos) + actx->mapped_vbos = GL_TRUE; +} + +void _ae_unmap_vbos( GLcontext *ctx ) +{ + AEcontext *actx = AE_CONTEXT(ctx); + GLuint i; + + if (!actx->mapped_vbos) + return; + + assert (!actx->NewState); + + for (i = 0; i < actx->nr_vbos; i++) + ctx->Driver.UnmapBuffer(ctx, + GL_ARRAY_BUFFER_ARB, + actx->vbo[i]); + + actx->mapped_vbos = GL_FALSE; +} + /** * Called via glArrayElement() and glDrawArrays(). @@ -784,30 +1258,60 @@ void GLAPIENTRY _ae_loopback_array_elt( GLint elt ) const AEcontext *actx = AE_CONTEXT(ctx); const AEarray *aa; const AEattrib *at; + const struct _glapi_table * const disp = GET_DISPATCH(); + GLboolean do_map; - if (actx->NewState) + if (actx->NewState) { + assert(!actx->mapped_vbos); _ae_update_state( ctx ); + } + + do_map = actx->nr_vbos && !actx->mapped_vbos; + /* + */ + if (do_map) + _ae_map_vbos(ctx); + /* generic attributes */ for (at = actx->attribs; at->func; at++) { - const GLubyte *src = at->array->BufferObj->Data - + (GLuint) at->array->Ptr - + elt * at->array->StrideB; + const GLubyte *src + = ADD_POINTERS(at->array->BufferObj->Pointer, at->array->Ptr) + + elt * at->array->StrideB; at->func( at->index, src ); } /* conventional arrays */ - for (aa = actx->arrays; aa->func ; aa++) { - const GLubyte *src = aa->array->BufferObj->Data - + (GLuint) aa->array->Ptr - + elt * aa->array->StrideB; - aa->func( src ); + for (aa = actx->arrays; aa->offset != -1 ; aa++) { + const GLubyte *src + = ADD_POINTERS(aa->array->BufferObj->Pointer, aa->array->Ptr) + + elt * aa->array->StrideB; + CALL_by_offset( disp, (array_func), aa->offset, + ((const void *) src) ); } -} + if (do_map) + _ae_unmap_vbos(ctx); +} void _ae_invalidate_state( GLcontext *ctx, GLuint new_state ) { - AE_CONTEXT(ctx)->NewState |= new_state; + AEcontext *actx = AE_CONTEXT(ctx); + + + /* Only interested in this subset of mesa state. Need to prune + * this down as both tnl/ and the drivers can raise statechanges + * for arcane reasons in the middle of seemingly atomic operations + * like DrawElements, over which we'd like to keep a known set of + * arrays and vbo's mapped. + * + * Luckily, neither the drivers nor tnl muck with the state that + * concerns us here: + */ + new_state &= _NEW_ARRAY | _NEW_PROGRAM; + if (new_state) { + assert(!actx->mapped_vbos); + actx->NewState |= new_state; + } }