}
if (ctx->Light.EnabledList.next == ctx->Light.EnabledList.prev) {
- ctx->Exec->Normal3f = norm_tab[index].normal3f_single;
- ctx->Exec->Normal3fv = norm_tab[index].normal3fv_single;
+ SET_Normal3f(ctx->Exec, norm_tab[index].normal3f_single);
+ SET_Normal3fv(ctx->Exec, norm_tab[index].normal3fv_single);
} else {
- ctx->Exec->Normal3f = norm_tab[index].normal3f_multi;
- ctx->Exec->Normal3fv = norm_tab[index].normal3fv_multi;
+ SET_Normal3f(ctx->Exec, norm_tab[index].normal3f_multi);
+ SET_Normal3fv(ctx->Exec, norm_tab[index].normal3fv_multi);
}
} else {
- ctx->Exec->Normal3f = _mesa_noop_Normal3f;
- ctx->Exec->Normal3fv = _mesa_noop_Normal3fv;
+ SET_Normal3f(ctx->Exec, _mesa_noop_Normal3f);
+ SET_Normal3fv(ctx->Exec, _mesa_noop_Normal3fv);
}
}
static void ffb_choose_Normal3f(GLfloat x, GLfloat y, GLfloat z)
{
choose_normals();
- GL_CALL(Normal3f)(x, y, z);
+ CALL_Normal3f(GET_DISPATCH(), (x, y, z));
}
static void ffb_choose_Normal3fv(const GLfloat *v)
{
choose_normals();
- GL_CALL(Normal3fv)(v);
+ CALL_Normal3fv(GET_DISPATCH(), (v));
}
/* Vertex functions: */
* correctly:
*/
if (fmesa->imm.prim != PRIM_OUTSIDE_BEGIN_END )
- GL_CALL(Begin)(fmesa->imm.prim);
+ CALL_Begin(GET_DISPATCH(), (fmesa->imm.prim));
if (ctx->Light.Enabled) {
- GL_CALL(Color4fv)(ctx->Current.Color); /* Catch ColorMaterial */
- GL_CALL(Normal3fv)(current->normal);
+ /* Catch ColorMaterial */
+ CALL_Color4fv(GET_DISPATCH(), (ctx->Current.Color));
+ CALL_Normal3fv(GET_DISPATCH(), (current->normal));
} else {
- GL_CALL(Color4fv)(current->color);
+ CALL_Color4fv(GET_DISPATCH(), (current->color));
}
}
#include "tnl/t_context.h"
#include "tnl/t_array_api.h"
+#include "dispatch.h"
+
static void r200VtxFmtFlushVertices( GLcontext *, GLuint );
static void count_func( const char *name, struct dynfn *l )
{
switch( count ) {
case 3:
- GL_CALL(MultiTexCoord3fvARB)( GL_TEXTURE0+unit, f );
+ CALL_MultiTexCoord3fvARB(GET_DISPATCH(), (GL_TEXTURE0+unit, f));
break;
case 2:
- GL_CALL(MultiTexCoord2fvARB)( GL_TEXTURE0+unit, f );
+ CALL_MultiTexCoord2fvARB(GET_DISPATCH(), (GL_TEXTURE0+unit, f));
break;
case 1:
- GL_CALL(MultiTexCoord1fvARB)( GL_TEXTURE0+unit, f );
+ CALL_MultiTexCoord1fvARB(GET_DISPATCH(), (GL_TEXTURE0+unit, f));
break;
default:
assert( count == 0 );
assert(rmesa->dma.flush == 0);
rmesa->vb.fell_back = GL_TRUE;
rmesa->vb.installed = GL_FALSE;
- GL_CALL(Begin)( prim );
+ CALL_Begin(GET_DISPATCH(), (prim));
if (rmesa->vb.installed_color_3f_sz == 4)
alpha = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
GLuint offset = 3;
if (ind0 & R200_VTX_N0) {
- GL_CALL(Normal3fv)( &tmp[i][offset] );
+ CALL_Normal3fv(GET_DISPATCH(), (&tmp[i][offset]));
offset += 3;
}
if (ind0 & R200_VTX_DISCRETE_FOG) {
- GL_CALL(FogCoordfvEXT)( &tmp[i][offset] );
+ CALL_FogCoordfvEXT(GET_DISPATCH(), (&tmp[i][offset]));
offset++;
}
if (VTX_COLOR(ind0, 0) == R200_VTX_PK_RGBA) {
- GL_CALL(Color4ubv)( (GLubyte *)&tmp[i][offset] );
+ CALL_Color4ubv(GET_DISPATCH(), ((GLubyte *)&tmp[i][offset]));
offset++;
}
else if (VTX_COLOR(ind0, 0) == R200_VTX_FP_RGBA) {
- GL_CALL(Color4fv)( &tmp[i][offset] );
+ CALL_Color4fv(GET_DISPATCH(), (&tmp[i][offset]));
offset+=4;
}
else if (VTX_COLOR(ind0, 0) == R200_VTX_FP_RGB) {
- GL_CALL(Color3fv)( &tmp[i][offset] );
+ CALL_Color3fv(GET_DISPATCH(), (&tmp[i][offset]));
offset+=3;
}
if (VTX_COLOR(ind0, 1) == R200_VTX_PK_RGBA) {
- GL_CALL(SecondaryColor3ubvEXT)( (GLubyte *)&tmp[i][offset] );
+ CALL_SecondaryColor3ubvEXT(GET_DISPATCH(), ((GLubyte *)&tmp[i][offset]));
offset++;
}
offset += count;
}
- GL_CALL(Vertex3fv)( &tmp[i][0] );
+ CALL_Vertex3fv(GET_DISPATCH(), (&tmp[i][0]));
}
/* Replay current vertex
*/
if (ind0 & R200_VTX_N0)
- GL_CALL(Normal3fv)( rmesa->vb.normalptr );
+ CALL_Normal3fv(GET_DISPATCH(), (rmesa->vb.normalptr));
if (ind0 & R200_VTX_DISCRETE_FOG) {
- GL_CALL(FogCoordfvEXT)( rmesa->vb.fogptr );
+ CALL_FogCoordfvEXT(GET_DISPATCH(), (rmesa->vb.fogptr));
}
if (VTX_COLOR(ind0, 0) == R200_VTX_PK_RGBA) {
- GL_CALL(Color4ub)( rmesa->vb.colorptr->red,
- rmesa->vb.colorptr->green,
- rmesa->vb.colorptr->blue,
- rmesa->vb.colorptr->alpha );
+ CALL_Color4ub(GET_DISPATCH(), (rmesa->vb.colorptr->red,
+ rmesa->vb.colorptr->green,
+ rmesa->vb.colorptr->blue,
+ rmesa->vb.colorptr->alpha));
}
else if (VTX_COLOR(ind0, 0) == R200_VTX_FP_RGBA) {
- GL_CALL(Color4fv)( rmesa->vb.floatcolorptr );
+ CALL_Color4fv(GET_DISPATCH(), (rmesa->vb.floatcolorptr));
}
else if (VTX_COLOR(ind0, 0) == R200_VTX_FP_RGB) {
if (rmesa->vb.installed_color_3f_sz == 4 && alpha != 1.0) {
- GL_CALL(Color4f)( rmesa->vb.floatcolorptr[0],
- rmesa->vb.floatcolorptr[1],
- rmesa->vb.floatcolorptr[2],
- alpha );
+ CALL_Color4f(GET_DISPATCH(), (rmesa->vb.floatcolorptr[0],
+ rmesa->vb.floatcolorptr[1],
+ rmesa->vb.floatcolorptr[2],
+ alpha));
}
else {
- GL_CALL(Color3fv)( rmesa->vb.floatcolorptr );
+ CALL_Color3fv(GET_DISPATCH(), (rmesa->vb.floatcolorptr));
}
}
if (VTX_COLOR(ind0, 1) == R200_VTX_PK_RGBA)
- GL_CALL(SecondaryColor3ubEXT)( rmesa->vb.specptr->red,
- rmesa->vb.specptr->green,
- rmesa->vb.specptr->blue );
+ CALL_SecondaryColor3ubEXT(GET_DISPATCH(), (rmesa->vb.specptr->red,
+ rmesa->vb.specptr->green,
+ rmesa->vb.specptr->blue));
for ( unit = 0 ; unit < ctx->Const.MaxTextureUnits ; unit++ ) {
count = VTX_TEXn_COUNT( ind1, unit );
if (rmesa->vb.prim[0] != GL_POLYGON+1) {
VFMT_FALLBACK( __FUNCTION__ );
- GL_CALL(Materialfv)( face, pname, params );
+ CALL_Materialfv(GET_DISPATCH(), (face, pname, params));
return;
}
_mesa_noop_Materialfv( face, pname, params );
r200VtxfmtValidate( ctx );
if (!rmesa->vb.installed) {
- GL_CALL(Begin)( mode );
+ CALL_Begin(GET_DISPATCH(), (mode));
return;
}
#include "r200_vtxfmt.h"
#include "r200_tcl.h"
+#include "dispatch.h"
+
/* Fallback versions of all the entrypoints for situations where
* codegen isn't available. This is still a lot faster than the
* vb/pipeline implementation in Mesa.
break;
default:
VFMT_FALLBACK(__FUNCTION__);
- GL_CALL(MultiTexCoord2fARB)(target, s, t);
+ CALL_MultiTexCoord2fARB(GET_DISPATCH(), (target, s, t));
return;
}
}
break;
default:
VFMT_FALLBACK(__FUNCTION__);
- GL_CALL(MultiTexCoord3fARB)(target, s, t, r);
+ CALL_MultiTexCoord3fARB(GET_DISPATCH(), (target, s, t, r));
return;
}
}
fprintf(stderr, "%s -- cached codegen\n", __FUNCTION__ ); \
\
if (dfn) \
- ctx->Exec->FN = (FNTYPE)(dfn->code); \
+ SET_ ## FN (ctx->Exec, (FNTYPE)(dfn->code)); \
else { \
if (R200_DEBUG & DEBUG_CODEGEN) \
fprintf(stderr, "%s -- generic version\n", __FUNCTION__ ); \
- ctx->Exec->FN = r200_##FN; \
+ SET_ ## FN (ctx->Exec, r200_##FN); \
} \
\
ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
- ctx->Exec->FN ARGS2; \
+ CALL_ ## FN (ctx->Exec, ARGS2); \
}
key[1] = rmesa->vb.vtxfmt_1 & MASK1; \
\
if (VTX_COLOR(rmesa->vb.vtxfmt_0,0) == R200_VTX_PK_RGBA) { \
- ctx->Exec->FN = r200_##FN##_ub; \
+ SET_ ## FN (ctx->Exec, r200_##FN##_ub); \
} \
else if (VTX_COLOR(rmesa->vb.vtxfmt_0,0) == R200_VTX_FP_RGB) { \
\
if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) { \
r200_copy_to_current( ctx ); \
_mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt ); \
- ctx->Exec->FN ARGS2; \
+ CALL_ ## FN (ctx->Exec, ARGS2); \
return; \
} \
} \
\
- ctx->Exec->FN = r200_##FN##_3f; \
+ SET_ ## FN (ctx->Exec, r200_##FN##_3f); \
} \
else { \
- ctx->Exec->FN = r200_##FN##_4f; \
+ SET_ ## FN (ctx->Exec, r200_##FN##_4f); \
} \
\
\
if (dfn) { \
if (R200_DEBUG & DEBUG_CODEGEN) \
fprintf(stderr, "%s -- codegen version\n", __FUNCTION__ ); \
- ctx->Exec->FN = (FNTYPE)dfn->code; \
+ SET_ ## FN (ctx->Exec, (FNTYPE)dfn->code); \
} \
else if (R200_DEBUG & DEBUG_CODEGEN) \
fprintf(stderr, "%s -- 'c' version\n", __FUNCTION__ ); \
\
ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
- ctx->Exec->FN ARGS2; \
+ CALL_ ## FN (ctx->Exec, ARGS2); \
}
fprintf(stderr, "%s -- cached version\n", __FUNCTION__ ); \
\
if (dfn) \
- ctx->Exec->FN = (FNTYPE)(dfn->code); \
+ SET_ ## FN (ctx->Exec, (FNTYPE)(dfn->code)); \
else { \
if (R200_DEBUG & DEBUG_CODEGEN) \
fprintf(stderr, "%s -- generic version\n", __FUNCTION__ ); \
- ctx->Exec->FN = (VTX_COLOR(rmesa->vb.vtxfmt_0,1) == R200_VTX_PK_RGBA) \
- ? r200_##FN##_ub : r200_##FN##_3f; \
+ SET_ ## FN (ctx->Exec, (VTX_COLOR(rmesa->vb.vtxfmt_0,1) == R200_VTX_PK_RGBA) \
+ ? r200_##FN##_ub : r200_##FN##_3f); \
} \
\
ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
- ctx->Exec->FN ARGS2; \
+ CALL_ ## FN (ctx->Exec, ARGS2); \
}
#include "radeon_swtcl.h"
#include "radeon_vtxfmt.h"
+#include "dispatch.h"
+
static void radeonVtxfmtFlushVertices( GLcontext *, GLuint );
static void count_func( const char *name, struct dynfn *l )
assert(rmesa->dma.flush == 0);
rmesa->vb.fell_back = GL_TRUE;
rmesa->vb.installed = GL_FALSE;
- GL_CALL(Begin)( prim );
+ CALL_Begin(GET_DISPATCH(), (prim));
if (rmesa->vb.installed_color_3f_sz == 4)
alpha = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
for (i = 0 ; i < nrverts; i++) {
GLuint offset = 3;
if (ind & RADEON_CP_VC_FRMT_N0) {
- GL_CALL(Normal3fv)( &tmp[i][offset] );
+ CALL_Normal3fv(GET_DISPATCH(), (&tmp[i][offset]));
offset += 3;
}
if (ind & RADEON_CP_VC_FRMT_PKCOLOR) {
radeon_color_t *col = (radeon_color_t *)&tmp[i][offset];
- GL_CALL(Color4ub)( col->red, col->green, col->blue, col->alpha );
+ CALL_Color4ub(GET_DISPATCH(), (col->red, col->green, col->blue, col->alpha));
offset++;
}
else if (ind & RADEON_CP_VC_FRMT_FPALPHA) {
- GL_CALL(Color4fv)( &tmp[i][offset] );
+ CALL_Color4fv(GET_DISPATCH(), (&tmp[i][offset]));
offset+=4;
}
else if (ind & RADEON_CP_VC_FRMT_FPCOLOR) {
- GL_CALL(Color3fv)( &tmp[i][offset] );
+ CALL_Color3fv(GET_DISPATCH(), (&tmp[i][offset]));
offset+=3;
}
if (ind & RADEON_CP_VC_FRMT_PKSPEC) {
radeon_color_t *spec = (radeon_color_t *)&tmp[i][offset];
- GL_CALL(SecondaryColor3ubEXT)( spec->red, spec->green, spec->blue );
+ CALL_SecondaryColor3ubEXT(GET_DISPATCH(), (spec->red, spec->green, spec->blue));
offset++;
}
if (ind & RADEON_CP_VC_FRMT_ST0) {
- GL_CALL(TexCoord2fv)( &tmp[i][offset] );
+ CALL_TexCoord2fv(GET_DISPATCH(), (&tmp[i][offset]));
offset += 2;
}
if (ind & RADEON_CP_VC_FRMT_ST1) {
- GL_CALL(MultiTexCoord2fvARB)( GL_TEXTURE1_ARB, &tmp[i][offset] );
+ CALL_MultiTexCoord2fvARB(GET_DISPATCH(), (GL_TEXTURE1_ARB, &tmp[i][offset]));
offset += 2;
}
- GL_CALL(Vertex3fv)( &tmp[i][0] );
+ CALL_Vertex3fv(GET_DISPATCH(), (&tmp[i][0]));
}
/* Replay current vertex
*/
if (ind & RADEON_CP_VC_FRMT_N0)
- GL_CALL(Normal3fv)( rmesa->vb.normalptr );
+ CALL_Normal3fv(GET_DISPATCH(), (rmesa->vb.normalptr));
if (ind & RADEON_CP_VC_FRMT_PKCOLOR)
- GL_CALL(Color4ub)( rmesa->vb.colorptr->red, rmesa->vb.colorptr->green, rmesa->vb.colorptr->blue, rmesa->vb.colorptr->alpha );
+ CALL_Color4ub(GET_DISPATCH(), (rmesa->vb.colorptr->red, rmesa->vb.colorptr->green, rmesa->vb.colorptr->blue, rmesa->vb.colorptr->alpha));
else if (ind & RADEON_CP_VC_FRMT_FPALPHA)
- GL_CALL(Color4fv)( rmesa->vb.floatcolorptr );
+ CALL_Color4fv(GET_DISPATCH(), (rmesa->vb.floatcolorptr));
else if (ind & RADEON_CP_VC_FRMT_FPCOLOR) {
if (rmesa->vb.installed_color_3f_sz == 4 && alpha != 1.0)
- GL_CALL(Color4f)( rmesa->vb.floatcolorptr[0],
- rmesa->vb.floatcolorptr[1],
- rmesa->vb.floatcolorptr[2],
- alpha );
+ CALL_Color4f(GET_DISPATCH(), (rmesa->vb.floatcolorptr[0],
+ rmesa->vb.floatcolorptr[1],
+ rmesa->vb.floatcolorptr[2],
+ alpha));
else
- GL_CALL(Color3fv)( rmesa->vb.floatcolorptr );
+ CALL_Color3fv(GET_DISPATCH(), (rmesa->vb.floatcolorptr));
}
if (ind & RADEON_CP_VC_FRMT_PKSPEC)
- GL_CALL(SecondaryColor3ubEXT)( rmesa->vb.specptr->red, rmesa->vb.specptr->green, rmesa->vb.specptr->blue );
+ CALL_SecondaryColor3ubEXT(GET_DISPATCH(), (rmesa->vb.specptr->red, rmesa->vb.specptr->green, rmesa->vb.specptr->blue));
if (ind & RADEON_CP_VC_FRMT_ST0)
- GL_CALL(TexCoord2fv)( rmesa->vb.texcoordptr[0] );
+ CALL_TexCoord2fv(GET_DISPATCH(), (rmesa->vb.texcoordptr[0]));
if (ind & RADEON_CP_VC_FRMT_ST1)
- GL_CALL(MultiTexCoord2fvARB)( GL_TEXTURE1_ARB, rmesa->vb.texcoordptr[1] );
+ CALL_MultiTexCoord2fvARB(GET_DISPATCH(), (GL_TEXTURE1_ARB, rmesa->vb.texcoordptr[1]));
}
if (rmesa->vb.prim[0] != GL_POLYGON+1) {
VFMT_FALLBACK( __FUNCTION__ );
- GL_CALL(Materialfv)( face, pname, params );
+ CALL_Materialfv(GET_DISPATCH(), (face, pname, params));
return;
}
_mesa_noop_Materialfv( face, pname, params );
radeonVtxfmtValidate( ctx );
if (!rmesa->vb.installed) {
- GL_CALL(Begin)( mode );
+ CALL_Begin(GET_DISPATCH(), (mode));
return;
}
#include "radeon_vtxfmt.h"
+#include "dispatch.h"
+
/* Fallback versions of all the entrypoints for situations where
* codegen isn't available. This is still a lot faster than the
* vb/pipeline implementation in Mesa.
fprintf(stderr, "%s -- cached codegen\n", __FUNCTION__ ); \
\
if (dfn) \
- ctx->Exec->FN = (FNTYPE)(dfn->code); \
+ SET_ ## FN (ctx->Exec, (FNTYPE)(dfn->code)); \
else { \
if (RADEON_DEBUG & DEBUG_CODEGEN) \
fprintf(stderr, "%s -- generic version\n", __FUNCTION__ ); \
- ctx->Exec->FN = radeon_##FN; \
+ SET_ ## FN (ctx->Exec, radeon_##FN); \
} \
\
ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
- ctx->Exec->FN ARGS2; \
+ CALL_ ## FN (ctx->Exec, ARGS2); \
}
struct dynfn *dfn; \
\
if (rmesa->vb.vertex_format & ACTIVE_PKCOLOR) { \
- ctx->Exec->FN = radeon_##FN##_ub; \
+ SET_ ## FN (ctx->Exec, radeon_##FN##_ub); \
} \
else if ((rmesa->vb.vertex_format & \
(ACTIVE_FPCOLOR|ACTIVE_FPALPHA)) == ACTIVE_FPCOLOR) { \
if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) { \
radeon_copy_to_current( ctx ); \
_mesa_install_exec_vtxfmt( ctx, &rmesa->vb.vtxfmt ); \
- ctx->Exec->FN ARGS2; \
+ CALL_ ## FN (ctx->Exec, ARGS2); \
return; \
} \
} \
\
- ctx->Exec->FN = radeon_##FN##_3f; \
+ SET_ ## FN (ctx->Exec, radeon_##FN##_3f); \
} \
else { \
- ctx->Exec->FN = radeon_##FN##_4f; \
+ SET_ ## FN (ctx->Exec, radeon_##FN##_4f); \
} \
\
\
if (dfn) { \
if (RADEON_DEBUG & DEBUG_CODEGEN) \
fprintf(stderr, "%s -- codegen version\n", __FUNCTION__ ); \
- ctx->Exec->FN = (FNTYPE)dfn->code; \
+ SET_ ## FN (ctx->Exec, (FNTYPE)dfn->code); \
} \
else if (RADEON_DEBUG & DEBUG_CODEGEN) \
fprintf(stderr, "%s -- 'c' version\n", __FUNCTION__ ); \
\
ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
- ctx->Exec->FN ARGS2; \
+ CALL_ ## FN (ctx->Exec, ARGS2); \
}
fprintf(stderr, "%s -- cached version\n", __FUNCTION__ ); \
\
if (dfn) \
- ctx->Exec->FN = (FNTYPE)(dfn->code); \
+ SET_ ## FN (ctx->Exec, (FNTYPE)(dfn->code)); \
else { \
if (RADEON_DEBUG & DEBUG_CODEGEN) \
fprintf(stderr, "%s -- generic version\n", __FUNCTION__ ); \
- ctx->Exec->FN = ((rmesa->vb.vertex_format & ACTIVE_PKSPEC) != 0) \
- ? radeon_##FN##_ub : radeon_##FN##_3f; \
+ SET_ ## FN (ctx->Exec, ((rmesa->vb.vertex_format & ACTIVE_PKSPEC) != 0) \
+ ? radeon_##FN##_ub : radeon_##FN##_3f); \
} \
\
ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
- ctx->Exec->FN ARGS2; \
+ CALL_ ## FN (ctx->Exec, ARGS2); \
}
TOP = ../../..
include $(TOP)/configs/current
-OUTPUTS = glprocs.h glapitemp.h glapioffsets.h glapitable.h \
+OUTPUTS = glprocs.h glapitemp.h glapioffsets.h glapitable.h dispatch.h \
../main/enums.c \
../x86/glapi_x86.S \
../drivers/dri/common/extension_helper.h \
glapitable.h: $(COMMON) gl_table.py
$(PYTHON2) $(PYTHON_FLAGS) gl_table.py > glapitable.h
+dispatch.h: $(COMMON) gl_table.py
+ $(PYTHON2) $(PYTHON_FLAGS) gl_table.py -m remap_table > dispatch.h
+
../main/enums.c: $(COMMON) gl_enums.py
$(PYTHON2) $(PYTHON_FLAGS) gl_enums.py > ../main/enums.c
return
+class PrintRemapTable(gl_XML.gl_print_base):
+ def __init__(self):
+ gl_XML.gl_print_base.__init__(self)
+
+ self.header_tag = '_DISPATCH_H_'
+ self.name = "gl_table.py (from Mesa)"
+ self.license = license.bsd_license_template % ("(C) Copyright IBM Corporation 2005", "IBM")
+ return
+
+
+ def printRealHeader(self):
+ print """/**
+ * \\file dispatch.h
+ * Macros for handling GL dispatch tables.
+ *
+ * For each known GL function, there are 3 macros in this file. The first
+ * macro is named CALL_FuncName and is used to call that GL function using
+ * the specified dispatch table. The other 2 macros, called GET_FuncName
+ * can SET_FuncName, are used to get and set the dispatch pointer for the
+ * named function in the specified dispatch table.
+ */
+"""
+
+ return
+
+ def printBody(self, api):
+ print '#define CALL_by_offset(disp, cast, offset, parameters) \\'
+ print ' (*(cast (((_glapi_proc *)(disp))[offset]))) parameters'
+ print '#define GET_by_offset(disp, offset) \\'
+ print ' (((_glapi_proc *)(disp))[offset])'
+ print '#define SET_by_offset(disp, offset, fn) \\'
+ print ' ((((_glapi_proc *)(disp))[offset]) = fn)'
+ print ''
+
+ for f in api.functionIterateByOffset():
+ print '#define CALL_%s(disp, parameters) (*((disp)->%s)) parameters' % (f.name, f.name)
+ print '#define GET_%s(disp) ((disp)->%s)' % (f.name, f.name)
+ print '#define SET_%s(disp, fn) ((disp)->%s = fn)' % (f.name, f.name)
+ return
+
+ abi = [ "1.0", "1.1", "1.2", "GL_ARB_multitexture" ]
+
+ functions = []
+ abi_functions = []
+ count = 0
+ for f in api.functionIterateByOffset():
+ [category, num] = api.get_category_for_name( f.name )
+ if category not in abi:
+ functions.append( [f, count] )
+ count += 1
+ else:
+ abi_functions.append( f )
+
+
+ print 'struct _mesa_dispatch_remap_table {'
+
+ for [f, index] in functions:
+ print ' unsigned %s;' % (f.name)
+
+ print '};'
+ print ''
+ print '/* %u functions need remapping. */' % (count)
+ print ''
+
+ for f in abi_functions:
+ print '#define CALL_%s(disp, parameters) (*disp->%s) parameters' % (f.name, f.name)
+
+
+ for [f, index] in functions:
+ arg_string = gl_XML.create_parameter_string( f.parameters, 0 )
+ cast = '%s (GLAPIENTRYP)(%s)' % (f.return_type, arg_string)
+
+ print '#define CALL_%s(disp, parameters) (* (%s) (((_glapi_proc *)disp)[dispatch_remap.%s])) parameters' % (f.name, cast, f.name)
+
+ return
+
+
def show_usage():
- print "Usage: %s [-f input_file_name]" % sys.argv[0]
+ print "Usage: %s [-f input_file_name] [-m mode]" % sys.argv[0]
+ print " -m mode Mode can be 'table' or 'remap_table'."
sys.exit(1)
if __name__ == '__main__':
file_name = "gl_API.xml"
try:
- (args, trail) = getopt.getopt(sys.argv[1:], "f:")
+ (args, trail) = getopt.getopt(sys.argv[1:], "f:m:")
except Exception,e:
show_usage()
+ mode = "table"
for (arg,val) in args:
if arg == "-f":
file_name = val
+ elif arg == "-m":
+ mode = val
+
+ if mode == "table":
+ printer = PrintGlTable()
+ elif mode == "remap_table":
+ printer = PrintRemapTable()
+ else:
+ show_usage()
api = gl_XML.parse_GL_API( file_name )
- printer = PrintGlTable()
printer.Print( api )
extern struct _glapi_table * _glapi_DispatchTSD;
extern _glthread_TSD _gl_DispatchTSD;
-#define GL_CALL(name) \
- (((__builtin_expect( _glapi_DispatchTSD != NULL, 1 )) \
- ? _glapi_DispatchTSD : (struct _glapi_table *) pthread_getspecific(_gl_DispatchTSD.key))-> name)
+#define GET_DISPATCH() \
+ ((__builtin_expect( _glapi_DispatchTSD != NULL, 1 )) \
+ ? _glapi_DispatchTSD : (struct _glapi_table *) pthread_getspecific(_gl_DispatchTSD.key))
#endif
#endif /* PTHREADS */
extern __thread struct _glapi_table * _glapi_tls_Dispatch
__attribute__((tls_model("initial-exec")));
-# define GL_CALL(name) (*(_glapi_tls_Dispatch-> name))
+#define GET_DISPATCH() _glapi_tls_Dispatch
#elif !defined(GL_CALL)
# if defined(THREADS)
extern struct _glapi_table * _glapi_DispatchTSD;
-# define GL_CALL(name) \
- (((__builtin_expect( _glapi_DispatchTSD != NULL, 1 )) \
- ? _glapi_DispatchTSD : _glapi_get_dispatch())-> name)
+# define GET_DISPATCH() \
+ ((__builtin_expect( _glapi_DispatchTSD != NULL, 1 )) \
+ ? _glapi_DispatchTSD : _glapi_get_dispatch())
# else
-# define GL_CALL(name) (*(_glapi_Dispatch-> name))
+# define GET_DISPATCH() _glapi_Dispatch
# endif /* defined(THREADS) */
#endif /* ndef GL_CALL */
#include "imports.h"
#include "macros.h"
#include "mtypes.h"
+#include "glapioffsets.h"
+#include "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 );
#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
*/
#define TYPE_IDX(t) ( (t) == GL_DOUBLE ? 7 : (t) & 7 )
-static void GLAPIENTRY Color3bv(const GLbyte *v)
-{
- GL_CALL(Color3bv)(v);
-}
-
-static void GLAPIENTRY Color3ubv(const GLubyte *v)
-{
- GL_CALL(Color3ubv)(v);
-}
-
-static void GLAPIENTRY Color3sv(const GLshort *v)
-{
- GL_CALL(Color3sv)(v);
-}
-
-static void GLAPIENTRY Color3usv(const GLushort *v)
-{
- GL_CALL(Color3usv)(v);
-}
-
-static void GLAPIENTRY Color3iv(const GLint *v)
-{
- GL_CALL(Color3iv)(v);
-}
-
-static void GLAPIENTRY Color3uiv(const GLuint *v)
-{
- GL_CALL(Color3uiv)(v);
-}
-
-static void GLAPIENTRY Color3fv(const GLfloat *v)
-{
- GL_CALL(Color3fv)(v);
-}
-
-static void GLAPIENTRY Color3dv(const GLdouble *v)
-{
- GL_CALL(Color3dv)(v);
-}
-
-static void GLAPIENTRY Color4bv(const GLbyte *v)
-{
- GL_CALL(Color4bv)(v);
-}
-
-static void GLAPIENTRY Color4ubv(const GLubyte *v)
-{
- GL_CALL(Color4ubv)(v);
-}
-
-static void GLAPIENTRY Color4sv(const GLshort *v)
-{
- GL_CALL(Color4sv)(v);
-}
-
-static void GLAPIENTRY Color4usv(const GLushort *v)
-{
- GL_CALL(Color4usv)(v);
-}
-
-static void GLAPIENTRY Color4iv(const GLint *v)
-{
- GL_CALL(Color4iv)(v);
-}
-
-static void GLAPIENTRY Color4uiv(const GLuint *v)
-{
- GL_CALL(Color4uiv)(v);
-}
-
-static void GLAPIENTRY Color4fv(const GLfloat *v)
-{
- GL_CALL(Color4fv)(v);
-}
-
-static void GLAPIENTRY Color4dv(const GLdouble *v)
-{
- GL_CALL(Color4dv)(v);
-}
-
-static const array_func ColorFuncs[2][8] = {
+static const int ColorFuncs[2][8] = {
{
- (array_func) Color3bv,
- (array_func) Color3ubv,
- (array_func) Color3sv,
- (array_func) Color3usv,
- (array_func) Color3iv,
- (array_func) Color3uiv,
- (array_func) Color3fv,
- (array_func) Color3dv,
+ _gloffset_Color3bv,
+ _gloffset_Color3ubv,
+ _gloffset_Color3sv,
+ _gloffset_Color3usv,
+ _gloffset_Color3iv,
+ _gloffset_Color3uiv,
+ _gloffset_Color3fv,
+ _gloffset_Color3dv,
},
{
- (array_func) Color4bv,
- (array_func) Color4ubv,
- (array_func) Color4sv,
- (array_func) Color4usv,
- (array_func) Color4iv,
- (array_func) Color4uiv,
- (array_func) Color4fv,
- (array_func) Color4dv,
+ _gloffset_Color4bv,
+ _gloffset_Color4ubv,
+ _gloffset_Color4sv,
+ _gloffset_Color4usv,
+ _gloffset_Color4iv,
+ _gloffset_Color4uiv,
+ _gloffset_Color4fv,
+ _gloffset_Color4dv,
},
};
-static void GLAPIENTRY Vertex2sv(const GLshort *v)
-{
- GL_CALL(Vertex2sv)(v);
-}
-
-static void GLAPIENTRY Vertex2iv(const GLint *v)
-{
- GL_CALL(Vertex2iv)(v);
-}
-
-static void GLAPIENTRY Vertex2fv(const GLfloat *v)
-{
- GL_CALL(Vertex2fv)(v);
-}
-
-static void GLAPIENTRY Vertex2dv(const GLdouble *v)
-{
- GL_CALL(Vertex2dv)(v);
-}
-
-static void GLAPIENTRY Vertex3sv(const GLshort *v)
-{
- GL_CALL(Vertex3sv)(v);
-}
-
-static void GLAPIENTRY Vertex3iv(const GLint *v)
-{
- GL_CALL(Vertex3iv)(v);
-}
-
-static void GLAPIENTRY Vertex3fv(const GLfloat *v)
-{
- GL_CALL(Vertex3fv)(v);
-}
-
-static void GLAPIENTRY Vertex3dv(const GLdouble *v)
-{
- GL_CALL(Vertex3dv)(v);
-}
-
-static void GLAPIENTRY Vertex4sv(const GLshort *v)
-{
- GL_CALL(Vertex4sv)(v);
-}
-
-static void GLAPIENTRY Vertex4iv(const GLint *v)
-{
- GL_CALL(Vertex4iv)(v);
-}
-
-static void GLAPIENTRY Vertex4fv(const GLfloat *v)
-{
- GL_CALL(Vertex4fv)(v);
-}
-
-static void GLAPIENTRY Vertex4dv(const GLdouble *v)
-{
- GL_CALL(Vertex4dv)(v);
-}
-
-static const array_func VertexFuncs[3][8] = {
+static const int VertexFuncs[3][8] = {
{
- NULL,
- NULL,
- (array_func) Vertex2sv,
- NULL,
- (array_func) Vertex2iv,
- NULL,
- (array_func) Vertex2fv,
- (array_func) Vertex2dv,
+ -1,
+ -1,
+ _gloffset_Vertex2sv,
+ -1,
+ _gloffset_Vertex2iv,
+ -1,
+ _gloffset_Vertex2fv,
+ _gloffset_Vertex2dv,
},
{
- NULL,
- NULL,
- (array_func) Vertex3sv,
- NULL,
- (array_func) Vertex3iv,
- NULL,
- (array_func) Vertex3fv,
- (array_func) Vertex3dv,
+ -1,
+ -1,
+ _gloffset_Vertex3sv,
+ -1,
+ _gloffset_Vertex3iv,
+ -1,
+ _gloffset_Vertex3fv,
+ _gloffset_Vertex3dv,
},
{
- NULL,
- NULL,
- (array_func) Vertex4sv,
- NULL,
- (array_func) Vertex4iv,
- NULL,
- (array_func) Vertex4fv,
- (array_func) Vertex4dv,
+ -1,
+ -1,
+ _gloffset_Vertex4sv,
+ -1,
+ _gloffset_Vertex4iv,
+ -1,
+ _gloffset_Vertex4fv,
+ _gloffset_Vertex4dv,
},
};
-static void GLAPIENTRY Indexubv(const GLubyte *c)
-{
- GL_CALL(Indexubv)(c);
-}
-
-static void GLAPIENTRY Indexsv(const GLshort *c)
-{
- GL_CALL(Indexsv)(c);
-}
-
-static void GLAPIENTRY Indexiv(const GLint *c)
-{
- GL_CALL(Indexiv)(c);
-}
-
-static void GLAPIENTRY Indexfv(const GLfloat *c)
-{
- GL_CALL(Indexfv)(c);
-}
-
-static void GLAPIENTRY Indexdv(const GLdouble *c)
-{
- GL_CALL(Indexdv)(c);
-}
-
-static const array_func IndexFuncs[8] = {
- NULL,
- (array_func) Indexubv,
- (array_func) Indexsv,
- NULL,
- (array_func) Indexiv,
- NULL,
- (array_func) Indexfv,
- (array_func) Indexdv,
+static const int IndexFuncs[8] = {
+ -1,
+ _gloffset_Indexubv,
+ _gloffset_Indexsv,
+ -1,
+ _gloffset_Indexiv,
+ -1,
+ _gloffset_Indexfv,
+ _gloffset_Indexdv,
};
-static void GLAPIENTRY Normal3bv(const GLbyte *v)
-{
- GL_CALL(Normal3bv)(v);
-}
-
-static void GLAPIENTRY Normal3sv(const GLshort *v)
-{
- GL_CALL(Normal3sv)(v);
-}
-
-static void GLAPIENTRY Normal3iv(const GLint *v)
-{
- GL_CALL(Normal3iv)(v);
-}
-
-static void GLAPIENTRY Normal3fv(const GLfloat *v)
-{
- GL_CALL(Normal3fv)(v);
-}
-
-static void GLAPIENTRY Normal3dv(const GLdouble *v)
-{
- GL_CALL(Normal3dv)(v);
-}
-
-static const array_func NormalFuncs[8] = {
- (array_func) Normal3bv,
- NULL,
- (array_func) Normal3sv,
- NULL,
- (array_func) Normal3iv,
- NULL,
- (array_func) Normal3fv,
- (array_func) Normal3dv,
+static const int NormalFuncs[8] = {
+ _gloffset_Normal3bv,
+ -1,
+ _gloffset_Normal3sv,
+ -1,
+ _gloffset_Normal3iv,
+ -1,
+ _gloffset_Normal3fv,
+ _gloffset_Normal3dv,
};
-/* Wrapper functions in case glSecondaryColor*EXT doesn't exist */
-static void GLAPIENTRY SecondaryColor3bvEXT(const GLbyte *c)
-{
- GL_CALL(SecondaryColor3bvEXT)(c);
-}
-
-static void GLAPIENTRY SecondaryColor3ubvEXT(const GLubyte *c)
-{
- GL_CALL(SecondaryColor3ubvEXT)(c);
-}
-
-static void GLAPIENTRY SecondaryColor3svEXT(const GLshort *c)
-{
- GL_CALL(SecondaryColor3svEXT)(c);
-}
-
-static void GLAPIENTRY SecondaryColor3usvEXT(const GLushort *c)
-{
- GL_CALL(SecondaryColor3usvEXT)(c);
-}
-
-static void GLAPIENTRY SecondaryColor3ivEXT(const GLint *c)
-{
- GL_CALL(SecondaryColor3ivEXT)(c);
-}
-
-static void GLAPIENTRY SecondaryColor3uivEXT(const GLuint *c)
-{
- GL_CALL(SecondaryColor3uivEXT)(c);
-}
-
-static void GLAPIENTRY SecondaryColor3fvEXT(const GLfloat *c)
-{
- GL_CALL(SecondaryColor3fvEXT)(c);
-}
-
-static void GLAPIENTRY SecondaryColor3dvEXT(const GLdouble *c)
-{
- GL_CALL(SecondaryColor3dvEXT)(c);
-}
-
-static const array_func SecondaryColorFuncs[8] = {
- (array_func) SecondaryColor3bvEXT,
- (array_func) SecondaryColor3ubvEXT,
- (array_func) SecondaryColor3svEXT,
- (array_func) SecondaryColor3usvEXT,
- (array_func) SecondaryColor3ivEXT,
- (array_func) SecondaryColor3uivEXT,
- (array_func) SecondaryColor3fvEXT,
- (array_func) SecondaryColor3dvEXT,
+static const int SecondaryColorFuncs[8] = {
+ _gloffset_SecondaryColor3bvEXT,
+ _gloffset_SecondaryColor3ubvEXT,
+ _gloffset_SecondaryColor3svEXT,
+ _gloffset_SecondaryColor3usvEXT,
+ _gloffset_SecondaryColor3ivEXT,
+ _gloffset_SecondaryColor3uivEXT,
+ _gloffset_SecondaryColor3fvEXT,
+ _gloffset_SecondaryColor3dvEXT,
};
-
-/* Again, wrapper functions in case glSecondaryColor*EXT doesn't exist */
-static void GLAPIENTRY FogCoordfvEXT(const GLfloat *f)
-{
- GL_CALL(FogCoordfvEXT)(f);
-}
-
-static void GLAPIENTRY FogCoorddvEXT(const GLdouble *f)
-{
- GL_CALL(FogCoorddvEXT)(f);
-}
-
-static const array_func FogCoordFuncs[8] = {
- NULL,
- NULL,
- NULL,
- NULL,
- NULL,
- NULL,
- (array_func) FogCoordfvEXT,
- (array_func) FogCoorddvEXT
+static const int FogCoordFuncs[8] = {
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ _gloffset_FogCoordfvEXT,
+ _gloffset_FogCoorddvEXT
};
/**********************************************************************/
static void GLAPIENTRY VertexAttrib1NbvNV(GLuint index, const GLbyte *v)
{
- GL_CALL(VertexAttrib1fNV)(index, BYTE_TO_FLOAT(v[0]));
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0])));
}
static void GLAPIENTRY VertexAttrib1bvNV(GLuint index, const GLbyte *v)
{
- GL_CALL(VertexAttrib1fNV)(index, v[0]);
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, v[0]));
}
static void GLAPIENTRY VertexAttrib2NbvNV(GLuint index, const GLbyte *v)
{
- GL_CALL(VertexAttrib2fNV)(index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]));
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1])));
}
static void GLAPIENTRY VertexAttrib2bvNV(GLuint index, const GLbyte *v)
{
- GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]);
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, v[0], v[1]));
}
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]));
+ CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, BYTE_TO_FLOAT(v[0]),
+ BYTE_TO_FLOAT(v[1]),
+ BYTE_TO_FLOAT(v[2])));
}
static void GLAPIENTRY VertexAttrib3bvNV(GLuint index, const GLbyte *v)
{
- GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]);
+ CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, v[0], v[1], v[2]));
}
static void GLAPIENTRY VertexAttrib4NbvNV(GLuint index, const GLbyte *v)
{
- GL_CALL(VertexAttrib4fNV)(index, BYTE_TO_FLOAT(v[0]),
- BYTE_TO_FLOAT(v[1]),
- BYTE_TO_FLOAT(v[2]),
- BYTE_TO_FLOAT(v[3]));
+ 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 GLAPIENTRY VertexAttrib4bvNV(GLuint index, const GLbyte *v)
{
- GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]);
+ CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, v[0], v[1], v[2], v[3]));
}
/* GL_UNSIGNED_BYTE attributes */
static void GLAPIENTRY VertexAttrib1NubvNV(GLuint index, const GLubyte *v)
{
- GL_CALL(VertexAttrib1fNV)(index, UBYTE_TO_FLOAT(v[0]));
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, UBYTE_TO_FLOAT(v[0])));
}
static void GLAPIENTRY VertexAttrib1ubvNV(GLuint index, const GLubyte *v)
{
- GL_CALL(VertexAttrib1fNV)(index, v[0]);
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, v[0]));
}
static void GLAPIENTRY VertexAttrib2NubvNV(GLuint index, const GLubyte *v)
{
- GL_CALL(VertexAttrib2fNV)(index, UBYTE_TO_FLOAT(v[0]),
- UBYTE_TO_FLOAT(v[1]));
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, UBYTE_TO_FLOAT(v[0]),
+ UBYTE_TO_FLOAT(v[1])));
}
static void GLAPIENTRY VertexAttrib2ubvNV(GLuint index, const GLubyte *v)
{
- GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]);
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, v[0], v[1]));
}
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]));
+ 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)
{
- GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]);
+ CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, v[0], v[1], v[2]));
}
static void GLAPIENTRY VertexAttrib4NubvNV(GLuint index, const GLubyte *v)
{
- GL_CALL(VertexAttrib4fNV)(index, UBYTE_TO_FLOAT(v[0]),
+ 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]));
+ UBYTE_TO_FLOAT(v[3])));
}
static void GLAPIENTRY VertexAttrib4ubvNV(GLuint index, const GLubyte *v)
{
- GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]);
+ CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, v[0], v[1], v[2], v[3]));
}
/* GL_SHORT attributes */
static void GLAPIENTRY VertexAttrib1NsvNV(GLuint index, const GLshort *v)
{
- GL_CALL(VertexAttrib1fNV)(index, SHORT_TO_FLOAT(v[0]));
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0])));
}
static void GLAPIENTRY VertexAttrib1svNV(GLuint index, const GLshort *v)
{
- GL_CALL(VertexAttrib1fNV)(index, v[0]);
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, v[0]));
}
static void GLAPIENTRY VertexAttrib2NsvNV(GLuint index, const GLshort *v)
{
- GL_CALL(VertexAttrib2fNV)(index, SHORT_TO_FLOAT(v[0]),
- SHORT_TO_FLOAT(v[1]));
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0]),
+ SHORT_TO_FLOAT(v[1])));
}
static void GLAPIENTRY VertexAttrib2svNV(GLuint index, const GLshort *v)
{
- GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]);
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, v[0], v[1]));
}
static void GLAPIENTRY VertexAttrib3NsvNV(GLuint index, const GLshort *v)
{
- GL_CALL(VertexAttrib3fNV)(index, SHORT_TO_FLOAT(v[0]),
+ CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, SHORT_TO_FLOAT(v[0]),
SHORT_TO_FLOAT(v[1]),
- SHORT_TO_FLOAT(v[2]));
+ SHORT_TO_FLOAT(v[2])));
}
static void GLAPIENTRY VertexAttrib3svNV(GLuint index, const GLshort *v)
{
- GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]);
+ CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, v[0], v[1], v[2]));
}
static void GLAPIENTRY VertexAttrib4NsvNV(GLuint index, const GLshort *v)
{
- GL_CALL(VertexAttrib4fNV)(index, SHORT_TO_FLOAT(v[0]),
+ 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]));
+ SHORT_TO_FLOAT(v[3])));
}
static void GLAPIENTRY VertexAttrib4svNV(GLuint index, const GLshort *v)
{
- GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]);
+ CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, v[0], v[1], v[2], v[3]));
}
/* GL_UNSIGNED_SHORT attributes */
static void GLAPIENTRY VertexAttrib1NusvNV(GLuint index, const GLushort *v)
{
- GL_CALL(VertexAttrib1fNV)(index, USHORT_TO_FLOAT(v[0]));
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, USHORT_TO_FLOAT(v[0])));
}
static void GLAPIENTRY VertexAttrib1usvNV(GLuint index, const GLushort *v)
{
- GL_CALL(VertexAttrib1fNV)(index, v[0]);
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, v[0]));
}
static void GLAPIENTRY VertexAttrib2NusvNV(GLuint index, const GLushort *v)
{
- GL_CALL(VertexAttrib2fNV)(index, USHORT_TO_FLOAT(v[0]),
- USHORT_TO_FLOAT(v[1]));
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, USHORT_TO_FLOAT(v[0]),
+ USHORT_TO_FLOAT(v[1])));
}
static void GLAPIENTRY VertexAttrib2usvNV(GLuint index, const GLushort *v)
{
- GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]);
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, v[0], v[1]));
}
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]));
+ 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)
{
- GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]);
+ CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, v[0], v[1], v[2]));
}
static void GLAPIENTRY VertexAttrib4NusvNV(GLuint index, const GLushort *v)
{
- GL_CALL(VertexAttrib4fNV)(index, USHORT_TO_FLOAT(v[0]),
- USHORT_TO_FLOAT(v[1]),
- USHORT_TO_FLOAT(v[2]),
- USHORT_TO_FLOAT(v[3]));
+ 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)
{
- GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]);
+ CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, v[0], v[1], v[2], v[3]));
}
/* GL_INT attributes */
static void GLAPIENTRY VertexAttrib1NivNV(GLuint index, const GLint *v)
{
- GL_CALL(VertexAttrib1fNV)(index, INT_TO_FLOAT(v[0]));
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, INT_TO_FLOAT(v[0])));
}
static void GLAPIENTRY VertexAttrib1ivNV(GLuint index, const GLint *v)
{
- GL_CALL(VertexAttrib1fNV)(index, v[0]);
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, v[0]));
}
static void GLAPIENTRY VertexAttrib2NivNV(GLuint index, const GLint *v)
{
- GL_CALL(VertexAttrib2fNV)(index, INT_TO_FLOAT(v[0]),
- INT_TO_FLOAT(v[1]));
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, INT_TO_FLOAT(v[0]),
+ INT_TO_FLOAT(v[1])));
}
static void GLAPIENTRY VertexAttrib2ivNV(GLuint index, const GLint *v)
{
- GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]);
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, v[0], v[1]));
}
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]));
+ 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)
{
- GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]);
+ CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, v[0], v[1], v[2]));
}
static void GLAPIENTRY VertexAttrib4NivNV(GLuint index, const GLint *v)
{
- GL_CALL(VertexAttrib4fNV)(index, INT_TO_FLOAT(v[0]),
- INT_TO_FLOAT(v[1]),
- INT_TO_FLOAT(v[2]),
- INT_TO_FLOAT(v[3]));
+ 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)
{
- GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]);
+ CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, v[0], v[1], v[2], v[3]));
}
/* GL_UNSIGNED_INT attributes */
static void GLAPIENTRY VertexAttrib1NuivNV(GLuint index, const GLuint *v)
{
- GL_CALL(VertexAttrib1fNV)(index, UINT_TO_FLOAT(v[0]));
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, UINT_TO_FLOAT(v[0])));
}
static void GLAPIENTRY VertexAttrib1uivNV(GLuint index, const GLuint *v)
{
- GL_CALL(VertexAttrib1fNV)(index, v[0]);
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), (index, v[0]));
}
static void GLAPIENTRY VertexAttrib2NuivNV(GLuint index, const GLuint *v)
{
- GL_CALL(VertexAttrib2fNV)(index, UINT_TO_FLOAT(v[0]),
- UINT_TO_FLOAT(v[1]));
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, UINT_TO_FLOAT(v[0]),
+ UINT_TO_FLOAT(v[1])));
}
static void GLAPIENTRY VertexAttrib2uivNV(GLuint index, const GLuint *v)
{
- GL_CALL(VertexAttrib2fNV)(index, v[0], v[1]);
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), (index, v[0], v[1]));
}
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]));
+ 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)
{
- GL_CALL(VertexAttrib3fNV)(index, v[0], v[1], v[2]);
+ CALL_VertexAttrib3fNV(GET_DISPATCH(), (index, v[0], v[1], v[2]));
}
static void GLAPIENTRY VertexAttrib4NuivNV(GLuint index, const GLuint *v)
{
- GL_CALL(VertexAttrib4fNV)(index, UINT_TO_FLOAT(v[0]),
- UINT_TO_FLOAT(v[1]),
- UINT_TO_FLOAT(v[2]),
- UINT_TO_FLOAT(v[3]));
+ 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)
{
- GL_CALL(VertexAttrib4fNV)(index, v[0], v[1], v[2], v[3]);
+ CALL_VertexAttrib4fNV(GET_DISPATCH(), (index, v[0], v[1], v[2], v[3]));
}
/* GL_FLOAT attributes */
static void GLAPIENTRY VertexAttrib1fvNV(GLuint index, const GLfloat *v)
{
- GL_CALL(VertexAttrib1fvNV)(index, v);
+ CALL_VertexAttrib1fvNV(GET_DISPATCH(), (index, v));
}
static void GLAPIENTRY VertexAttrib2fvNV(GLuint index, const GLfloat *v)
{
- GL_CALL(VertexAttrib2fvNV)(index, v);
+ CALL_VertexAttrib2fvNV(GET_DISPATCH(), (index, v));
}
static void GLAPIENTRY VertexAttrib3fvNV(GLuint index, const GLfloat *v)
{
- GL_CALL(VertexAttrib3fvNV)(index, v);
+ CALL_VertexAttrib3fvNV(GET_DISPATCH(), (index, v));
}
static void GLAPIENTRY VertexAttrib4fvNV(GLuint index, const GLfloat *v)
{
- GL_CALL(VertexAttrib4fvNV)(index, v);
+ CALL_VertexAttrib4fvNV(GET_DISPATCH(), (index, v));
}
/* GL_DOUBLE attributes */
static void GLAPIENTRY VertexAttrib1dvNV(GLuint index, const GLdouble *v)
{
- GL_CALL(VertexAttrib1dvNV)(index, v);
+ CALL_VertexAttrib1dvNV(GET_DISPATCH(), (index, v));
}
static void GLAPIENTRY VertexAttrib2dvNV(GLuint index, const GLdouble *v)
{
- GL_CALL(VertexAttrib2dvNV)(index, v);
+ CALL_VertexAttrib2dvNV(GET_DISPATCH(), (index, v));
}
static void GLAPIENTRY VertexAttrib3dvNV(GLuint index, const GLdouble *v)
{
- GL_CALL(VertexAttrib3dvNV)(index, v);
+ CALL_VertexAttrib3dvNV(GET_DISPATCH(), (index, v));
}
static void GLAPIENTRY VertexAttrib4dvNV(GLuint index, const GLdouble *v)
{
- GL_CALL(VertexAttrib4dvNV)(index, v);
+ CALL_VertexAttrib4dvNV(GET_DISPATCH(), (index, v));
}
}
};
-static void GLAPIENTRY EdgeFlagv(const GLboolean *flag)
-{
- GL_CALL(EdgeFlagv)(flag);
-}
-
/**********************************************************************/
/* conventional vertex arrays */
if (ctx->Array.Index.Enabled) {
aa->array = &ctx->Array.Index;
- aa->func = IndexFuncs[TYPE_IDX(aa->array->Type)];
+ aa->offset = IndexFuncs[TYPE_IDX(aa->array->Type)];
aa++;
}
if (ctx->Array.EdgeFlag.Enabled) {
aa->array = &ctx->Array.EdgeFlag;
- aa->func = (array_func) EdgeFlagv;
+ aa->offset = _gloffset_EdgeFlagv;
aa++;
}
if (ctx->Array.Normal.Enabled) {
aa->array = &ctx->Array.Normal;
- aa->func = NormalFuncs[TYPE_IDX(aa->array->Type)];
+ aa->offset = NormalFuncs[TYPE_IDX(aa->array->Type)];
aa++;
}
if (ctx->Array.Color.Enabled) {
aa->array = &ctx->Array.Color;
- aa->func = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)];
+ aa->offset = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)];
aa++;
}
if (ctx->Array.SecondaryColor.Enabled) {
aa->array = &ctx->Array.SecondaryColor;
- aa->func = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)];
+ aa->offset = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)];
aa++;
}
if (ctx->Array.FogCoord.Enabled) {
aa->array = &ctx->Array.FogCoord;
- aa->func = FogCoordFuncs[TYPE_IDX(aa->array->Type)];
+ aa->offset = FogCoordFuncs[TYPE_IDX(aa->array->Type)];
aa++;
}
for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
*/
aa->array = &ctx->Array.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)];
aa++;
}
else if (ctx->Array.Vertex.Enabled) {
aa->array = &ctx->Array.Vertex;
- aa->func = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)];
+ aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)];
aa++;
}
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;
}
const AEcontext *actx = AE_CONTEXT(ctx);
const AEarray *aa;
const AEattrib *at;
+ const struct _glapi_table * const disp = GET_DISPATCH();
+
if (actx->NewState)
_ae_update_state( ctx );
}
/* conventional arrays */
- for (aa = actx->arrays; aa->func ; aa++) {
+ for (aa = actx->arrays; aa->offset != -1 ; aa++) {
const GLubyte *src = aa->array->BufferObj->Data
+ (uintptr_t) aa->array->Ptr
+ elt * aa->array->StrideB;
- aa->func( src );
+ fprintf( stderr, "[%s,%u] aa->offset = %d\n", __func__, __LINE__,
+ aa->offset );
+ CALL_by_offset( disp, (array_func), aa->offset,
+ ((const void *) src) );
}
}
#include "colormac.h"
#include "api_loopback.h"
#include "glthread.h"
+#include "mtypes.h"
+#include "dispatch.h"
/* KW: A set of functions to convert unusual Color/Normal/Vertex/etc
* calls to a smaller set of driver-provided formats. Currently just
* listed in dd.h. The easiest way for a driver to do this is to
* install the supplied software t&l module.
*/
-#define COLORF(r,g,b,a) GL_CALL(Color4f)(r,g,b,a)
-#define VERTEX2(x,y) GL_CALL(Vertex2f)(x,y)
-#define VERTEX3(x,y,z) GL_CALL(Vertex3f)(x,y,z)
-#define VERTEX4(x,y,z,w) GL_CALL(Vertex4f)(x,y,z,w)
-#define NORMAL(x,y,z) GL_CALL(Normal3f)(x,y,z)
-#define TEXCOORD1(s) GL_CALL(TexCoord1f)(s)
-#define TEXCOORD2(s,t) GL_CALL(TexCoord2f)(s,t)
-#define TEXCOORD3(s,t,u) GL_CALL(TexCoord3f)(s,t,u)
-#define TEXCOORD4(s,t,u,v) GL_CALL(TexCoord4f)(s,t,u,v)
-#define INDEX(c) GL_CALL(Indexf)(c)
-#define MULTI_TEXCOORD1(z,s) GL_CALL(MultiTexCoord1fARB)(z,s)
-#define MULTI_TEXCOORD2(z,s,t) GL_CALL(MultiTexCoord2fARB)(z,s,t)
-#define MULTI_TEXCOORD3(z,s,t,u) GL_CALL(MultiTexCoord3fARB)(z,s,t,u)
-#define MULTI_TEXCOORD4(z,s,t,u,v) GL_CALL(MultiTexCoord4fARB)(z,s,t,u,v)
-#define EVALCOORD1(x) GL_CALL(EvalCoord1f)(x)
-#define EVALCOORD2(x,y) GL_CALL(EvalCoord2f)(x,y)
-#define MATERIALFV(a,b,c) GL_CALL(Materialfv)(a,b,c)
-#define RECTF(a,b,c,d) GL_CALL(Rectf)(a,b,c,d)
-
-#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)
+#define COLORF(r,g,b,a) CALL_Color4f(GET_DISPATCH(), (r,g,b,a))
+#define VERTEX2(x,y) CALL_Vertex2f(GET_DISPATCH(), (x,y))
+#define VERTEX3(x,y,z) CALL_Vertex3f(GET_DISPATCH(), (x,y,z))
+#define VERTEX4(x,y,z,w) CALL_Vertex4f(GET_DISPATCH(), (x,y,z,w))
+#define NORMAL(x,y,z) CALL_Normal3f(GET_DISPATCH(), (x,y,z))
+#define TEXCOORD1(s) CALL_TexCoord1f(GET_DISPATCH(), (s))
+#define TEXCOORD2(s,t) CALL_TexCoord2f(GET_DISPATCH(), (s,t))
+#define TEXCOORD3(s,t,u) CALL_TexCoord3f(GET_DISPATCH(), (s,t,u))
+#define TEXCOORD4(s,t,u,v) CALL_TexCoord4f(GET_DISPATCH(), (s,t,u,v))
+#define INDEX(c) CALL_Indexf(GET_DISPATCH(), (c))
+#define MULTI_TEXCOORD1(z,s) CALL_MultiTexCoord1fARB(GET_DISPATCH(), (z,s))
+#define MULTI_TEXCOORD2(z,s,t) CALL_MultiTexCoord2fARB(GET_DISPATCH(), (z,s,t))
+#define MULTI_TEXCOORD3(z,s,t,u) CALL_MultiTexCoord3fARB(GET_DISPATCH(), (z,s,t,u))
+#define MULTI_TEXCOORD4(z,s,t,u,v) CALL_MultiTexCoord4fARB(GET_DISPATCH(), (z,s,t,u,v))
+#define EVALCOORD1(x) CALL_EvalCoord1f(GET_DISPATCH(), (x))
+#define EVALCOORD2(x,y) CALL_EvalCoord2f(GET_DISPATCH(), (x,y))
+#define MATERIALFV(a,b,c) CALL_Materialfv(GET_DISPATCH(), (a,b,c))
+#define RECTF(a,b,c,d) CALL_Rectf(GET_DISPATCH(), (a,b,c,d))
+
+#define ATTRIB1NV(index,x) CALL_VertexAttrib1fNV(GET_DISPATCH(), (index,x))
+#define ATTRIB2NV(index,x,y) CALL_VertexAttrib2fNV(GET_DISPATCH(), (index,x,y))
+#define ATTRIB3NV(index,x,y,z) CALL_VertexAttrib3fNV(GET_DISPATCH(), (index,x,y,z))
+#define ATTRIB4NV(index,x,y,z,w) CALL_VertexAttrib4fNV(GET_DISPATCH(), (index,x,y,z,w))
+#define ATTRIB1ARB(index,x) CALL_VertexAttrib1fARB(GET_DISPATCH(), (index,x))
+#define ATTRIB2ARB(index,x,y) CALL_VertexAttrib2fARB(GET_DISPATCH(), (index,x,y))
+#define ATTRIB3ARB(index,x,y,z) CALL_VertexAttrib3fARB(GET_DISPATCH(), (index,x,y,z))
+#define ATTRIB4ARB(index,x,y,z,w) CALL_VertexAttrib4fARB(GET_DISPATCH(), (index,x,y,z,w))
+#define FOGCOORDF(x) CALL_FogCoordfEXT(GET_DISPATCH(), (x))
+#define SECONDARYCOLORF(a,b,c) CALL_SecondaryColor3fEXT(GET_DISPATCH(), (a,b,c))
static void GLAPIENTRY
loopback_Color3b_f( GLbyte red, GLbyte green, GLbyte blue )
void
_mesa_loopback_init_api_table( struct _glapi_table *dest )
{
- dest->Color3b = loopback_Color3b_f;
- dest->Color3d = loopback_Color3d_f;
- dest->Color3i = loopback_Color3i_f;
- dest->Color3s = loopback_Color3s_f;
- dest->Color3ui = loopback_Color3ui_f;
- dest->Color3us = loopback_Color3us_f;
- dest->Color3ub = loopback_Color3ub_f;
- dest->Color4b = loopback_Color4b_f;
- dest->Color4d = loopback_Color4d_f;
- dest->Color4i = loopback_Color4i_f;
- dest->Color4s = loopback_Color4s_f;
- dest->Color4ui = loopback_Color4ui_f;
- dest->Color4us = loopback_Color4us_f;
- dest->Color4ub = loopback_Color4ub_f;
- dest->Color3bv = loopback_Color3bv_f;
- dest->Color3dv = loopback_Color3dv_f;
- dest->Color3iv = loopback_Color3iv_f;
- dest->Color3sv = loopback_Color3sv_f;
- dest->Color3uiv = loopback_Color3uiv_f;
- dest->Color3usv = loopback_Color3usv_f;
- dest->Color3ubv = loopback_Color3ubv_f;
- dest->Color4bv = loopback_Color4bv_f;
- dest->Color4dv = loopback_Color4dv_f;
- dest->Color4iv = loopback_Color4iv_f;
- dest->Color4sv = loopback_Color4sv_f;
- dest->Color4uiv = loopback_Color4uiv_f;
- dest->Color4usv = loopback_Color4usv_f;
- dest->Color4ubv = loopback_Color4ubv_f;
-
- dest->SecondaryColor3bEXT = loopback_SecondaryColor3bEXT_f;
- dest->SecondaryColor3dEXT = loopback_SecondaryColor3dEXT_f;
- dest->SecondaryColor3iEXT = loopback_SecondaryColor3iEXT_f;
- dest->SecondaryColor3sEXT = loopback_SecondaryColor3sEXT_f;
- dest->SecondaryColor3uiEXT = loopback_SecondaryColor3uiEXT_f;
- dest->SecondaryColor3usEXT = loopback_SecondaryColor3usEXT_f;
- dest->SecondaryColor3ubEXT = loopback_SecondaryColor3ubEXT_f;
- dest->SecondaryColor3bvEXT = loopback_SecondaryColor3bvEXT_f;
- dest->SecondaryColor3dvEXT = loopback_SecondaryColor3dvEXT_f;
- dest->SecondaryColor3ivEXT = loopback_SecondaryColor3ivEXT_f;
- dest->SecondaryColor3svEXT = loopback_SecondaryColor3svEXT_f;
- dest->SecondaryColor3uivEXT = loopback_SecondaryColor3uivEXT_f;
- dest->SecondaryColor3usvEXT = loopback_SecondaryColor3usvEXT_f;
- dest->SecondaryColor3ubvEXT = loopback_SecondaryColor3ubvEXT_f;
+ SET_Color3b(dest, loopback_Color3b_f);
+ SET_Color3d(dest, loopback_Color3d_f);
+ SET_Color3i(dest, loopback_Color3i_f);
+ SET_Color3s(dest, loopback_Color3s_f);
+ SET_Color3ui(dest, loopback_Color3ui_f);
+ SET_Color3us(dest, loopback_Color3us_f);
+ SET_Color3ub(dest, loopback_Color3ub_f);
+ SET_Color4b(dest, loopback_Color4b_f);
+ SET_Color4d(dest, loopback_Color4d_f);
+ SET_Color4i(dest, loopback_Color4i_f);
+ SET_Color4s(dest, loopback_Color4s_f);
+ SET_Color4ui(dest, loopback_Color4ui_f);
+ SET_Color4us(dest, loopback_Color4us_f);
+ SET_Color4ub(dest, loopback_Color4ub_f);
+ SET_Color3bv(dest, loopback_Color3bv_f);
+ SET_Color3dv(dest, loopback_Color3dv_f);
+ SET_Color3iv(dest, loopback_Color3iv_f);
+ SET_Color3sv(dest, loopback_Color3sv_f);
+ SET_Color3uiv(dest, loopback_Color3uiv_f);
+ SET_Color3usv(dest, loopback_Color3usv_f);
+ SET_Color3ubv(dest, loopback_Color3ubv_f);
+ SET_Color4bv(dest, loopback_Color4bv_f);
+ SET_Color4dv(dest, loopback_Color4dv_f);
+ SET_Color4iv(dest, loopback_Color4iv_f);
+ SET_Color4sv(dest, loopback_Color4sv_f);
+ SET_Color4uiv(dest, loopback_Color4uiv_f);
+ SET_Color4usv(dest, loopback_Color4usv_f);
+ SET_Color4ubv(dest, loopback_Color4ubv_f);
+
+ SET_SecondaryColor3bEXT(dest, loopback_SecondaryColor3bEXT_f);
+ SET_SecondaryColor3dEXT(dest, loopback_SecondaryColor3dEXT_f);
+ SET_SecondaryColor3iEXT(dest, loopback_SecondaryColor3iEXT_f);
+ SET_SecondaryColor3sEXT(dest, loopback_SecondaryColor3sEXT_f);
+ SET_SecondaryColor3uiEXT(dest, loopback_SecondaryColor3uiEXT_f);
+ SET_SecondaryColor3usEXT(dest, loopback_SecondaryColor3usEXT_f);
+ SET_SecondaryColor3ubEXT(dest, loopback_SecondaryColor3ubEXT_f);
+ SET_SecondaryColor3bvEXT(dest, loopback_SecondaryColor3bvEXT_f);
+ SET_SecondaryColor3dvEXT(dest, loopback_SecondaryColor3dvEXT_f);
+ SET_SecondaryColor3ivEXT(dest, loopback_SecondaryColor3ivEXT_f);
+ SET_SecondaryColor3svEXT(dest, loopback_SecondaryColor3svEXT_f);
+ SET_SecondaryColor3uivEXT(dest, loopback_SecondaryColor3uivEXT_f);
+ SET_SecondaryColor3usvEXT(dest, loopback_SecondaryColor3usvEXT_f);
+ SET_SecondaryColor3ubvEXT(dest, loopback_SecondaryColor3ubvEXT_f);
- dest->Indexd = loopback_Indexd;
- dest->Indexi = loopback_Indexi;
- dest->Indexs = loopback_Indexs;
- dest->Indexub = loopback_Indexub;
- dest->Indexdv = loopback_Indexdv;
- dest->Indexiv = loopback_Indexiv;
- dest->Indexsv = loopback_Indexsv;
- dest->Indexubv = loopback_Indexubv;
- dest->Normal3b = loopback_Normal3b;
- dest->Normal3d = loopback_Normal3d;
- dest->Normal3i = loopback_Normal3i;
- dest->Normal3s = loopback_Normal3s;
- dest->Normal3bv = loopback_Normal3bv;
- dest->Normal3dv = loopback_Normal3dv;
- dest->Normal3iv = loopback_Normal3iv;
- dest->Normal3sv = loopback_Normal3sv;
- dest->TexCoord1d = loopback_TexCoord1d;
- dest->TexCoord1i = loopback_TexCoord1i;
- dest->TexCoord1s = loopback_TexCoord1s;
- dest->TexCoord2d = loopback_TexCoord2d;
- dest->TexCoord2s = loopback_TexCoord2s;
- dest->TexCoord2i = loopback_TexCoord2i;
- dest->TexCoord3d = loopback_TexCoord3d;
- dest->TexCoord3i = loopback_TexCoord3i;
- dest->TexCoord3s = loopback_TexCoord3s;
- dest->TexCoord4d = loopback_TexCoord4d;
- dest->TexCoord4i = loopback_TexCoord4i;
- dest->TexCoord4s = loopback_TexCoord4s;
- dest->TexCoord1dv = loopback_TexCoord1dv;
- dest->TexCoord1iv = loopback_TexCoord1iv;
- dest->TexCoord1sv = loopback_TexCoord1sv;
- dest->TexCoord2dv = loopback_TexCoord2dv;
- dest->TexCoord2iv = loopback_TexCoord2iv;
- dest->TexCoord2sv = loopback_TexCoord2sv;
- dest->TexCoord3dv = loopback_TexCoord3dv;
- dest->TexCoord3iv = loopback_TexCoord3iv;
- dest->TexCoord3sv = loopback_TexCoord3sv;
- dest->TexCoord4dv = loopback_TexCoord4dv;
- dest->TexCoord4iv = loopback_TexCoord4iv;
- dest->TexCoord4sv = loopback_TexCoord4sv;
- dest->Vertex2d = loopback_Vertex2d;
- dest->Vertex2i = loopback_Vertex2i;
- dest->Vertex2s = loopback_Vertex2s;
- dest->Vertex3d = loopback_Vertex3d;
- dest->Vertex3i = loopback_Vertex3i;
- dest->Vertex3s = loopback_Vertex3s;
- dest->Vertex4d = loopback_Vertex4d;
- dest->Vertex4i = loopback_Vertex4i;
- dest->Vertex4s = loopback_Vertex4s;
- dest->Vertex2dv = loopback_Vertex2dv;
- dest->Vertex2iv = loopback_Vertex2iv;
- dest->Vertex2sv = loopback_Vertex2sv;
- dest->Vertex3dv = loopback_Vertex3dv;
- dest->Vertex3iv = loopback_Vertex3iv;
- dest->Vertex3sv = loopback_Vertex3sv;
- dest->Vertex4dv = loopback_Vertex4dv;
- dest->Vertex4iv = loopback_Vertex4iv;
- dest->Vertex4sv = loopback_Vertex4sv;
- dest->MultiTexCoord1dARB = loopback_MultiTexCoord1dARB;
- dest->MultiTexCoord1dvARB = loopback_MultiTexCoord1dvARB;
- dest->MultiTexCoord1iARB = loopback_MultiTexCoord1iARB;
- dest->MultiTexCoord1ivARB = loopback_MultiTexCoord1ivARB;
- dest->MultiTexCoord1sARB = loopback_MultiTexCoord1sARB;
- dest->MultiTexCoord1svARB = loopback_MultiTexCoord1svARB;
- dest->MultiTexCoord2dARB = loopback_MultiTexCoord2dARB;
- dest->MultiTexCoord2dvARB = loopback_MultiTexCoord2dvARB;
- dest->MultiTexCoord2iARB = loopback_MultiTexCoord2iARB;
- dest->MultiTexCoord2ivARB = loopback_MultiTexCoord2ivARB;
- dest->MultiTexCoord2sARB = loopback_MultiTexCoord2sARB;
- dest->MultiTexCoord2svARB = loopback_MultiTexCoord2svARB;
- dest->MultiTexCoord3dARB = loopback_MultiTexCoord3dARB;
- dest->MultiTexCoord3dvARB = loopback_MultiTexCoord3dvARB;
- dest->MultiTexCoord3iARB = loopback_MultiTexCoord3iARB;
- dest->MultiTexCoord3ivARB = loopback_MultiTexCoord3ivARB;
- dest->MultiTexCoord3sARB = loopback_MultiTexCoord3sARB;
- dest->MultiTexCoord3svARB = loopback_MultiTexCoord3svARB;
- dest->MultiTexCoord4dARB = loopback_MultiTexCoord4dARB;
- dest->MultiTexCoord4dvARB = loopback_MultiTexCoord4dvARB;
- dest->MultiTexCoord4iARB = loopback_MultiTexCoord4iARB;
- dest->MultiTexCoord4ivARB = loopback_MultiTexCoord4ivARB;
- dest->MultiTexCoord4sARB = loopback_MultiTexCoord4sARB;
- dest->MultiTexCoord4svARB = loopback_MultiTexCoord4svARB;
- dest->EvalCoord2dv = loopback_EvalCoord2dv;
- dest->EvalCoord2fv = loopback_EvalCoord2fv;
- dest->EvalCoord2d = loopback_EvalCoord2d;
- dest->EvalCoord1dv = loopback_EvalCoord1dv;
- dest->EvalCoord1fv = loopback_EvalCoord1fv;
- dest->EvalCoord1d = loopback_EvalCoord1d;
- dest->Materialf = loopback_Materialf;
- dest->Materiali = loopback_Materiali;
- dest->Materialiv = loopback_Materialiv;
- dest->Rectd = loopback_Rectd;
- dest->Rectdv = loopback_Rectdv;
- dest->Rectfv = loopback_Rectfv;
- dest->Recti = loopback_Recti;
- dest->Rectiv = loopback_Rectiv;
- dest->Rects = loopback_Rects;
- dest->Rectsv = loopback_Rectsv;
- dest->FogCoorddEXT = loopback_FogCoorddEXT;
- dest->FogCoorddvEXT = loopback_FogCoorddvEXT;
-
- dest->VertexAttrib1sNV = loopback_VertexAttrib1sNV;
- dest->VertexAttrib1dNV = loopback_VertexAttrib1dNV;
- dest->VertexAttrib2sNV = loopback_VertexAttrib2sNV;
- dest->VertexAttrib2dNV = loopback_VertexAttrib2dNV;
- dest->VertexAttrib3sNV = loopback_VertexAttrib3sNV;
- dest->VertexAttrib3dNV = loopback_VertexAttrib3dNV;
- dest->VertexAttrib4sNV = loopback_VertexAttrib4sNV;
- dest->VertexAttrib4dNV = loopback_VertexAttrib4dNV;
- dest->VertexAttrib4ubNV = loopback_VertexAttrib4ubNV;
- dest->VertexAttrib1svNV = loopback_VertexAttrib1svNV;
- dest->VertexAttrib1dvNV = loopback_VertexAttrib1dvNV;
- dest->VertexAttrib2svNV = loopback_VertexAttrib2svNV;
- dest->VertexAttrib2dvNV = loopback_VertexAttrib2dvNV;
- dest->VertexAttrib3svNV = loopback_VertexAttrib3svNV;
- dest->VertexAttrib3dvNV = loopback_VertexAttrib3dvNV;
- dest->VertexAttrib4svNV = loopback_VertexAttrib4svNV;
- dest->VertexAttrib4dvNV = loopback_VertexAttrib4dvNV;
- dest->VertexAttrib4ubvNV = loopback_VertexAttrib4ubvNV;
- dest->VertexAttribs1svNV = loopback_VertexAttribs1svNV;
- dest->VertexAttribs1fvNV = loopback_VertexAttribs1fvNV;
- dest->VertexAttribs1dvNV = loopback_VertexAttribs1dvNV;
- dest->VertexAttribs2svNV = loopback_VertexAttribs2svNV;
- dest->VertexAttribs2fvNV = loopback_VertexAttribs2fvNV;
- dest->VertexAttribs2dvNV = loopback_VertexAttribs2dvNV;
- dest->VertexAttribs3svNV = loopback_VertexAttribs3svNV;
- dest->VertexAttribs3fvNV = loopback_VertexAttribs3fvNV;
- dest->VertexAttribs3dvNV = loopback_VertexAttribs3dvNV;
- dest->VertexAttribs4svNV = loopback_VertexAttribs4svNV;
- dest->VertexAttribs4fvNV = loopback_VertexAttribs4fvNV;
- 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;
- dest->VertexAttrib4usvARB = loopback_VertexAttrib4usvARB;
- dest->VertexAttrib4uivARB = loopback_VertexAttrib4uivARB;
- dest->VertexAttrib4NbvARB = loopback_VertexAttrib4NbvARB;
- dest->VertexAttrib4NsvARB = loopback_VertexAttrib4NsvARB;
- dest->VertexAttrib4NivARB = loopback_VertexAttrib4NivARB;
- dest->VertexAttrib4NusvARB = loopback_VertexAttrib4NusvARB;
- dest->VertexAttrib4NuivARB = loopback_VertexAttrib4NuivARB;
+ SET_Indexd(dest, loopback_Indexd);
+ SET_Indexi(dest, loopback_Indexi);
+ SET_Indexs(dest, loopback_Indexs);
+ SET_Indexub(dest, loopback_Indexub);
+ SET_Indexdv(dest, loopback_Indexdv);
+ SET_Indexiv(dest, loopback_Indexiv);
+ SET_Indexsv(dest, loopback_Indexsv);
+ SET_Indexubv(dest, loopback_Indexubv);
+ SET_Normal3b(dest, loopback_Normal3b);
+ SET_Normal3d(dest, loopback_Normal3d);
+ SET_Normal3i(dest, loopback_Normal3i);
+ SET_Normal3s(dest, loopback_Normal3s);
+ SET_Normal3bv(dest, loopback_Normal3bv);
+ SET_Normal3dv(dest, loopback_Normal3dv);
+ SET_Normal3iv(dest, loopback_Normal3iv);
+ SET_Normal3sv(dest, loopback_Normal3sv);
+ SET_TexCoord1d(dest, loopback_TexCoord1d);
+ SET_TexCoord1i(dest, loopback_TexCoord1i);
+ SET_TexCoord1s(dest, loopback_TexCoord1s);
+ SET_TexCoord2d(dest, loopback_TexCoord2d);
+ SET_TexCoord2s(dest, loopback_TexCoord2s);
+ SET_TexCoord2i(dest, loopback_TexCoord2i);
+ SET_TexCoord3d(dest, loopback_TexCoord3d);
+ SET_TexCoord3i(dest, loopback_TexCoord3i);
+ SET_TexCoord3s(dest, loopback_TexCoord3s);
+ SET_TexCoord4d(dest, loopback_TexCoord4d);
+ SET_TexCoord4i(dest, loopback_TexCoord4i);
+ SET_TexCoord4s(dest, loopback_TexCoord4s);
+ SET_TexCoord1dv(dest, loopback_TexCoord1dv);
+ SET_TexCoord1iv(dest, loopback_TexCoord1iv);
+ SET_TexCoord1sv(dest, loopback_TexCoord1sv);
+ SET_TexCoord2dv(dest, loopback_TexCoord2dv);
+ SET_TexCoord2iv(dest, loopback_TexCoord2iv);
+ SET_TexCoord2sv(dest, loopback_TexCoord2sv);
+ SET_TexCoord3dv(dest, loopback_TexCoord3dv);
+ SET_TexCoord3iv(dest, loopback_TexCoord3iv);
+ SET_TexCoord3sv(dest, loopback_TexCoord3sv);
+ SET_TexCoord4dv(dest, loopback_TexCoord4dv);
+ SET_TexCoord4iv(dest, loopback_TexCoord4iv);
+ SET_TexCoord4sv(dest, loopback_TexCoord4sv);
+ SET_Vertex2d(dest, loopback_Vertex2d);
+ SET_Vertex2i(dest, loopback_Vertex2i);
+ SET_Vertex2s(dest, loopback_Vertex2s);
+ SET_Vertex3d(dest, loopback_Vertex3d);
+ SET_Vertex3i(dest, loopback_Vertex3i);
+ SET_Vertex3s(dest, loopback_Vertex3s);
+ SET_Vertex4d(dest, loopback_Vertex4d);
+ SET_Vertex4i(dest, loopback_Vertex4i);
+ SET_Vertex4s(dest, loopback_Vertex4s);
+ SET_Vertex2dv(dest, loopback_Vertex2dv);
+ SET_Vertex2iv(dest, loopback_Vertex2iv);
+ SET_Vertex2sv(dest, loopback_Vertex2sv);
+ SET_Vertex3dv(dest, loopback_Vertex3dv);
+ SET_Vertex3iv(dest, loopback_Vertex3iv);
+ SET_Vertex3sv(dest, loopback_Vertex3sv);
+ SET_Vertex4dv(dest, loopback_Vertex4dv);
+ SET_Vertex4iv(dest, loopback_Vertex4iv);
+ SET_Vertex4sv(dest, loopback_Vertex4sv);
+ SET_MultiTexCoord1dARB(dest, loopback_MultiTexCoord1dARB);
+ SET_MultiTexCoord1dvARB(dest, loopback_MultiTexCoord1dvARB);
+ SET_MultiTexCoord1iARB(dest, loopback_MultiTexCoord1iARB);
+ SET_MultiTexCoord1ivARB(dest, loopback_MultiTexCoord1ivARB);
+ SET_MultiTexCoord1sARB(dest, loopback_MultiTexCoord1sARB);
+ SET_MultiTexCoord1svARB(dest, loopback_MultiTexCoord1svARB);
+ SET_MultiTexCoord2dARB(dest, loopback_MultiTexCoord2dARB);
+ SET_MultiTexCoord2dvARB(dest, loopback_MultiTexCoord2dvARB);
+ SET_MultiTexCoord2iARB(dest, loopback_MultiTexCoord2iARB);
+ SET_MultiTexCoord2ivARB(dest, loopback_MultiTexCoord2ivARB);
+ SET_MultiTexCoord2sARB(dest, loopback_MultiTexCoord2sARB);
+ SET_MultiTexCoord2svARB(dest, loopback_MultiTexCoord2svARB);
+ SET_MultiTexCoord3dARB(dest, loopback_MultiTexCoord3dARB);
+ SET_MultiTexCoord3dvARB(dest, loopback_MultiTexCoord3dvARB);
+ SET_MultiTexCoord3iARB(dest, loopback_MultiTexCoord3iARB);
+ SET_MultiTexCoord3ivARB(dest, loopback_MultiTexCoord3ivARB);
+ SET_MultiTexCoord3sARB(dest, loopback_MultiTexCoord3sARB);
+ SET_MultiTexCoord3svARB(dest, loopback_MultiTexCoord3svARB);
+ SET_MultiTexCoord4dARB(dest, loopback_MultiTexCoord4dARB);
+ SET_MultiTexCoord4dvARB(dest, loopback_MultiTexCoord4dvARB);
+ SET_MultiTexCoord4iARB(dest, loopback_MultiTexCoord4iARB);
+ SET_MultiTexCoord4ivARB(dest, loopback_MultiTexCoord4ivARB);
+ SET_MultiTexCoord4sARB(dest, loopback_MultiTexCoord4sARB);
+ SET_MultiTexCoord4svARB(dest, loopback_MultiTexCoord4svARB);
+ SET_EvalCoord2dv(dest, loopback_EvalCoord2dv);
+ SET_EvalCoord2fv(dest, loopback_EvalCoord2fv);
+ SET_EvalCoord2d(dest, loopback_EvalCoord2d);
+ SET_EvalCoord1dv(dest, loopback_EvalCoord1dv);
+ SET_EvalCoord1fv(dest, loopback_EvalCoord1fv);
+ SET_EvalCoord1d(dest, loopback_EvalCoord1d);
+ SET_Materialf(dest, loopback_Materialf);
+ SET_Materiali(dest, loopback_Materiali);
+ SET_Materialiv(dest, loopback_Materialiv);
+ SET_Rectd(dest, loopback_Rectd);
+ SET_Rectdv(dest, loopback_Rectdv);
+ SET_Rectfv(dest, loopback_Rectfv);
+ SET_Recti(dest, loopback_Recti);
+ SET_Rectiv(dest, loopback_Rectiv);
+ SET_Rects(dest, loopback_Rects);
+ SET_Rectsv(dest, loopback_Rectsv);
+ SET_FogCoorddEXT(dest, loopback_FogCoorddEXT);
+ SET_FogCoorddvEXT(dest, loopback_FogCoorddvEXT);
+
+ SET_VertexAttrib1sNV(dest, loopback_VertexAttrib1sNV);
+ SET_VertexAttrib1dNV(dest, loopback_VertexAttrib1dNV);
+ SET_VertexAttrib2sNV(dest, loopback_VertexAttrib2sNV);
+ SET_VertexAttrib2dNV(dest, loopback_VertexAttrib2dNV);
+ SET_VertexAttrib3sNV(dest, loopback_VertexAttrib3sNV);
+ SET_VertexAttrib3dNV(dest, loopback_VertexAttrib3dNV);
+ SET_VertexAttrib4sNV(dest, loopback_VertexAttrib4sNV);
+ SET_VertexAttrib4dNV(dest, loopback_VertexAttrib4dNV);
+ SET_VertexAttrib4ubNV(dest, loopback_VertexAttrib4ubNV);
+ SET_VertexAttrib1svNV(dest, loopback_VertexAttrib1svNV);
+ SET_VertexAttrib1dvNV(dest, loopback_VertexAttrib1dvNV);
+ SET_VertexAttrib2svNV(dest, loopback_VertexAttrib2svNV);
+ SET_VertexAttrib2dvNV(dest, loopback_VertexAttrib2dvNV);
+ SET_VertexAttrib3svNV(dest, loopback_VertexAttrib3svNV);
+ SET_VertexAttrib3dvNV(dest, loopback_VertexAttrib3dvNV);
+ SET_VertexAttrib4svNV(dest, loopback_VertexAttrib4svNV);
+ SET_VertexAttrib4dvNV(dest, loopback_VertexAttrib4dvNV);
+ SET_VertexAttrib4ubvNV(dest, loopback_VertexAttrib4ubvNV);
+ SET_VertexAttribs1svNV(dest, loopback_VertexAttribs1svNV);
+ SET_VertexAttribs1fvNV(dest, loopback_VertexAttribs1fvNV);
+ SET_VertexAttribs1dvNV(dest, loopback_VertexAttribs1dvNV);
+ SET_VertexAttribs2svNV(dest, loopback_VertexAttribs2svNV);
+ SET_VertexAttribs2fvNV(dest, loopback_VertexAttribs2fvNV);
+ SET_VertexAttribs2dvNV(dest, loopback_VertexAttribs2dvNV);
+ SET_VertexAttribs3svNV(dest, loopback_VertexAttribs3svNV);
+ SET_VertexAttribs3fvNV(dest, loopback_VertexAttribs3fvNV);
+ SET_VertexAttribs3dvNV(dest, loopback_VertexAttribs3dvNV);
+ SET_VertexAttribs4svNV(dest, loopback_VertexAttribs4svNV);
+ SET_VertexAttribs4fvNV(dest, loopback_VertexAttribs4fvNV);
+ SET_VertexAttribs4dvNV(dest, loopback_VertexAttribs4dvNV);
+ SET_VertexAttribs4ubvNV(dest, loopback_VertexAttribs4ubvNV);
+
+ SET_VertexAttrib1sARB(dest, loopback_VertexAttrib1sARB);
+ SET_VertexAttrib1dARB(dest, loopback_VertexAttrib1dARB);
+ SET_VertexAttrib2sARB(dest, loopback_VertexAttrib2sARB);
+ SET_VertexAttrib2dARB(dest, loopback_VertexAttrib2dARB);
+ SET_VertexAttrib3sARB(dest, loopback_VertexAttrib3sARB);
+ SET_VertexAttrib3dARB(dest, loopback_VertexAttrib3dARB);
+ SET_VertexAttrib4sARB(dest, loopback_VertexAttrib4sARB);
+ SET_VertexAttrib4dARB(dest, loopback_VertexAttrib4dARB);
+ SET_VertexAttrib1svARB(dest, loopback_VertexAttrib1svARB);
+ SET_VertexAttrib1dvARB(dest, loopback_VertexAttrib1dvARB);
+ SET_VertexAttrib2svARB(dest, loopback_VertexAttrib2svARB);
+ SET_VertexAttrib2dvARB(dest, loopback_VertexAttrib2dvARB);
+ SET_VertexAttrib3svARB(dest, loopback_VertexAttrib3svARB);
+ SET_VertexAttrib3dvARB(dest, loopback_VertexAttrib3dvARB);
+ SET_VertexAttrib4svARB(dest, loopback_VertexAttrib4svARB);
+ SET_VertexAttrib4dvARB(dest, loopback_VertexAttrib4dvARB);
+ SET_VertexAttrib4NubARB(dest, loopback_VertexAttrib4NubARB);
+ SET_VertexAttrib4NubvARB(dest, loopback_VertexAttrib4NubvARB);
+ SET_VertexAttrib4bvARB(dest, loopback_VertexAttrib4bvARB);
+ SET_VertexAttrib4ivARB(dest, loopback_VertexAttrib4ivARB);
+ SET_VertexAttrib4ubvARB(dest, loopback_VertexAttrib4ubvARB);
+ SET_VertexAttrib4usvARB(dest, loopback_VertexAttrib4usvARB);
+ SET_VertexAttrib4uivARB(dest, loopback_VertexAttrib4uivARB);
+ SET_VertexAttrib4NbvARB(dest, loopback_VertexAttrib4NbvARB);
+ SET_VertexAttrib4NsvARB(dest, loopback_VertexAttrib4NsvARB);
+ SET_VertexAttrib4NivARB(dest, loopback_VertexAttrib4NivARB);
+ SET_VertexAttrib4NusvARB(dest, loopback_VertexAttrib4NusvARB);
+ SET_VertexAttrib4NuivARB(dest, loopback_VertexAttrib4NuivARB);
}
#include "macros.h"
#include "mtypes.h"
#include "dlist.h"
+#include "dispatch.h"
/* In states where certain vertex components are required for t&l or
ASSERT_OUTSIDE_BEGIN_END(ctx);
}
- GL_CALL(Begin)( GL_QUADS );
- GL_CALL(Vertex2f)( x1, y1 );
- GL_CALL(Vertex2f)( x2, y1 );
- GL_CALL(Vertex2f)( x2, y2 );
- GL_CALL(Vertex2f)( x1, y2 );
- GL_CALL(End)();
+ CALL_Begin(GET_DISPATCH(), (GL_QUADS));
+ CALL_Vertex2f(GET_DISPATCH(), (x1, y1));
+ CALL_Vertex2f(GET_DISPATCH(), (x2, y1));
+ CALL_Vertex2f(GET_DISPATCH(), (x2, y2));
+ CALL_Vertex2f(GET_DISPATCH(), (x1, y2));
+ CALL_End(GET_DISPATCH(), ());
}
if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))
return;
- GL_CALL(Begin)(mode);
+ CALL_Begin(GET_DISPATCH(), (mode));
for (i = 0; i < count; i++)
- GL_CALL(ArrayElement)(start + i);
- GL_CALL(End)();
+ CALL_ArrayElement(GET_DISPATCH(), (start + i));
+ CALL_End(GET_DISPATCH(), ());
}
if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
return;
- GL_CALL(Begin)(mode);
+ CALL_Begin(GET_DISPATCH(), (mode));
switch (type) {
case GL_UNSIGNED_BYTE:
for (i = 0 ; i < count ; i++)
- GL_CALL(ArrayElement)( ((GLubyte *)indices)[i] );
+ CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] ));
break;
case GL_UNSIGNED_SHORT:
for (i = 0 ; i < count ; i++)
- GL_CALL(ArrayElement)( ((GLushort *)indices)[i] );
+ CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] ));
break;
case GL_UNSIGNED_INT:
for (i = 0 ; i < count ; i++)
- GL_CALL(ArrayElement)( ((GLuint *)indices)[i] );
+ CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] ));
break;
default:
_mesa_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
break;
}
- GL_CALL(End)();
+ CALL_End(GET_DISPATCH(), ());
}
void GLAPIENTRY _mesa_noop_DrawRangeElements(GLenum mode,
if (_mesa_validate_DrawRangeElements( ctx, mode,
start, end,
count, type, indices ))
- GL_CALL(DrawElements)( mode, count, type, indices );
+ CALL_DrawElements(GET_DISPATCH(), (mode, count, type, indices));
}
/*
du = ctx->Eval.MapGrid1du;
u = ctx->Eval.MapGrid1u1 + i1 * du;
- GL_CALL(Begin)( prim );
+ CALL_Begin(GET_DISPATCH(), (prim));
for (i=i1;i<=i2;i++,u+=du) {
- GL_CALL(EvalCoord1f)( u );
+ CALL_EvalCoord1f(GET_DISPATCH(), (u));
}
- GL_CALL(End)();
+ CALL_End(GET_DISPATCH(), ());
}
switch (mode) {
case GL_POINT:
- GL_CALL(Begin)( GL_POINTS );
+ CALL_Begin(GET_DISPATCH(), (GL_POINTS));
for (v=v1,j=j1;j<=j2;j++,v+=dv) {
for (u=u1,i=i1;i<=i2;i++,u+=du) {
- GL_CALL(EvalCoord2f)(u, v );
+ CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
}
}
- GL_CALL(End)();
+ CALL_End(GET_DISPATCH(), ());
break;
case GL_LINE:
for (v=v1,j=j1;j<=j2;j++,v+=dv) {
- GL_CALL(Begin)( GL_LINE_STRIP );
+ CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP));
for (u=u1,i=i1;i<=i2;i++,u+=du) {
- GL_CALL(EvalCoord2f)(u, v );
+ CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
}
- GL_CALL(End)();
+ CALL_End(GET_DISPATCH(), ());
}
for (u=u1,i=i1;i<=i2;i++,u+=du) {
- GL_CALL(Begin)( GL_LINE_STRIP );
+ CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP));
for (v=v1,j=j1;j<=j2;j++,v+=dv) {
- GL_CALL(EvalCoord2f)(u, v );
+ CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
}
- GL_CALL(End)();
+ CALL_End(GET_DISPATCH(), ());
}
break;
case GL_FILL:
for (v=v1,j=j1;j<j2;j++,v+=dv) {
- GL_CALL(Begin)( GL_TRIANGLE_STRIP );
+ CALL_Begin(GET_DISPATCH(), (GL_TRIANGLE_STRIP));
for (u=u1,i=i1;i<=i2;i++,u+=du) {
- GL_CALL(EvalCoord2f)(u, v );
- GL_CALL(EvalCoord2f)(u, v+dv );
+ CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
+ CALL_EvalCoord2f(GET_DISPATCH(), (u, v+dv));
}
- GL_CALL(End)();
+ CALL_End(GET_DISPATCH(), ());
}
break;
default:
#define F stdout
#define DISPATCH(FUNC, ARGS, MESSAGE) \
fprintf MESSAGE; \
- GL_CALL(FUNC) ARGS;
+ CALL_ ## FUNC(GET_DISPATCH(), ARGS);
#define RETURN_DISPATCH(FUNC, ARGS, MESSAGE) \
fprintf MESSAGE; \
- return GL_CALL(FUNC) ARGS;
+ return CALL_ ## FUNC(GET_DISPATCH(), ARGS);
#else
#define DISPATCH(FUNC, ARGS, MESSAGE) \
- GL_CALL(FUNC) ARGS;
+ CALL_ ## FUNC(GET_DISPATCH(), ARGS);
#define RETURN_DISPATCH(FUNC, ARGS, MESSAGE) \
- return GL_CALL(FUNC) ARGS;
+ return CALL_ ## FUNC(GET_DISPATCH(), ARGS);
#endif /* logging */
#define GLAPIENTRY
#endif
+#include "dispatch.h"
#include "glapitemp.h"
#endif /* USE_X86_ASM */
#include "math/m_matrix.h"
#include "math/m_xform.h"
+#include "dispatch.h"
+
/**
* Flush vertices.
n[2].f = value;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Accum)( op, value );
+ CALL_Accum(ctx->Exec, ( op, value ));
}
}
n[2].f = (GLfloat) ref;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->AlphaFunc)( func, ref );
+ CALL_AlphaFunc(ctx->Exec, ( func, ref ));
}
}
n[2].ui = texture;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->BindTexture)( target, texture );
+ CALL_BindTexture(ctx->Exec, ( target, texture ));
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Bitmap)( width, height,
- xorig, yorig, xmove, ymove, pixels );
+ CALL_Bitmap(ctx->Exec, ( width, height,
+ xorig, yorig, xmove, ymove, pixels ));
}
}
n[1].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->BlendEquation)( mode );
+ CALL_BlendEquation(ctx->Exec, ( mode ));
}
}
n[2].e = modeA;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->BlendEquationSeparateEXT)( modeRGB, modeA );
+ CALL_BlendEquationSeparateEXT(ctx->Exec, ( modeRGB, modeA ));
}
}
n[4].e = dfactorA;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->BlendFuncSeparateEXT)( sfactorRGB, dfactorRGB,
- sfactorA, dfactorA);
+ CALL_BlendFuncSeparateEXT(ctx->Exec,
+ (sfactorRGB, dfactorRGB, sfactorA, dfactorA));
}
}
n[4].f = alpha;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->BlendColor)( red, green, blue, alpha );
+ CALL_BlendColor(ctx->Exec, ( red, green, blue, alpha ));
}
}
ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CallList)( list );
+ CALL_CallList(ctx->Exec, ( list ));
}
}
ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CallLists)( n, type, lists );
+ CALL_CallLists(ctx->Exec, ( n, type, lists ));
}
}
n[1].bf = mask;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Clear)( mask );
+ CALL_Clear(ctx->Exec, ( mask ));
}
}
n[4].f = alpha;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ClearAccum)( red, green, blue, alpha );
+ CALL_ClearAccum(ctx->Exec, ( red, green, blue, alpha ));
}
}
n[4].f = alpha;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ClearColor)( red, green, blue, alpha );
+ CALL_ClearColor(ctx->Exec, ( red, green, blue, alpha ));
}
}
n[1].f = (GLfloat) depth;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ClearDepth)( depth );
+ CALL_ClearDepth(ctx->Exec, ( depth ));
}
}
n[1].f = c;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ClearIndex)( c );
+ CALL_ClearIndex(ctx->Exec, ( c ));
}
}
n[1].i = s;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ClearStencil)( s );
+ CALL_ClearStencil(ctx->Exec, ( s ));
}
}
n[5].f = (GLfloat) equ[3];
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ClipPlane)( plane, equ );
+ CALL_ClipPlane(ctx->Exec, ( plane, equ ));
}
}
n[4].b = alpha;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ColorMask)( red, green, blue, alpha );
+ CALL_ColorMask(ctx->Exec, ( red, green, blue, alpha ));
}
}
n[2].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ColorMaterial)( face, mode );
+ CALL_ColorMaterial(ctx->Exec, ( face, mode ));
}
}
target == GL_PROXY_TEXTURE_3D ||
target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
/* execute immediately */
- (*ctx->Exec->ColorTable)( target, internalFormat, width,
- format, type, table );
+ CALL_ColorTable(ctx->Exec, ( target, internalFormat, width,
+ format, type, table ));
}
else {
GLvoid *image = unpack_image(1, width, 1, 1, format, type, table,
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ColorTable)( target, internalFormat, width,
- format, type, table );
+ CALL_ColorTable(ctx->Exec, ( target, internalFormat, width,
+ format, type, table ));
}
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ColorTableParameterfv)( target, pname, params );
+ CALL_ColorTableParameterfv(ctx->Exec, ( target, pname, params ));
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ColorTableParameteriv)( target, pname, params );
+ CALL_ColorTableParameteriv(ctx->Exec, ( target, pname, params ));
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ColorSubTable)(target, start, count, format, type, table);
+ CALL_ColorSubTable(ctx->Exec, (target, start, count, format, type, table));
}
}
n[5].i = width;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CopyColorSubTable)(target, start, x, y, width);
+ CALL_CopyColorSubTable(ctx->Exec, (target, start, x, y, width));
}
}
n[5].i = width;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CopyColorTable)(target, internalformat, x, y, width);
+ CALL_CopyColorTable(ctx->Exec, (target, internalformat, x, y, width));
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ConvolutionFilter1D)( target, internalFormat, width,
- format, type, filter );
+ CALL_ConvolutionFilter1D(ctx->Exec, ( target, internalFormat, width,
+ format, type, filter ));
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ConvolutionFilter2D)( target, internalFormat, width, height,
- format, type, filter );
+ CALL_ConvolutionFilter2D(ctx->Exec, ( target, internalFormat, width, height,
+ format, type, filter ));
}
}
n[3].i = param;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ConvolutionParameteri)( target, pname, param );
+ CALL_ConvolutionParameteri(ctx->Exec, ( target, pname, param ));
}
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ConvolutionParameteriv)( target, pname, params );
+ CALL_ConvolutionParameteriv(ctx->Exec, ( target, pname, params ));
}
}
n[3].f = param;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ConvolutionParameterf)( target, pname, param );
+ CALL_ConvolutionParameterf(ctx->Exec, ( target, pname, param ));
}
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ConvolutionParameterfv)( target, pname, params );
+ CALL_ConvolutionParameterfv(ctx->Exec, ( target, pname, params ));
}
}
n[5].e = type;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CopyPixels)( x, y, width, height, type );
+ CALL_CopyPixels(ctx->Exec, ( x, y, width, height, type ));
}
}
n[7].i = border;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CopyTexImage1D)( target, level, internalformat,
- x, y, width, border );
+ CALL_CopyTexImage1D(ctx->Exec, ( target, level, internalformat,
+ x, y, width, border ));
}
}
n[8].i = border;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CopyTexImage2D)( target, level, internalformat,
- x, y, width, height, border );
+ CALL_CopyTexImage2D(ctx->Exec, ( target, level, internalformat,
+ x, y, width, height, border ));
}
}
n[6].i = width;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CopyTexSubImage1D)( target, level, xoffset, x, y, width );
+ CALL_CopyTexSubImage1D(ctx->Exec, ( target, level, xoffset, x, y, width ));
}
}
n[8].i = height;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CopyTexSubImage2D)( target, level, xoffset, yoffset,
- x, y, width, height );
+ CALL_CopyTexSubImage2D(ctx->Exec, ( target, level, xoffset, yoffset,
+ x, y, width, height ));
}
}
n[9].i = height;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CopyTexSubImage3D)( target, level,
+ CALL_CopyTexSubImage3D(ctx->Exec, ( target, level,
xoffset, yoffset, zoffset,
- x, y, width, height );
+ x, y, width, height ));
}
}
n[1].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CullFace)( mode );
+ CALL_CullFace(ctx->Exec, ( mode ));
}
}
n[1].e = func;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->DepthFunc)( func );
+ CALL_DepthFunc(ctx->Exec, ( func ));
}
}
n[1].b = mask;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->DepthMask)( mask );
+ CALL_DepthMask(ctx->Exec, ( mask ));
}
}
n[2].f = (GLfloat) farval;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->DepthRange)( nearval, farval );
+ CALL_DepthRange(ctx->Exec, ( nearval, farval ));
}
}
n[1].e = cap;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Disable)( cap );
+ CALL_Disable(ctx->Exec, ( cap ));
}
}
n[1].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->DrawBuffer)( mode );
+ CALL_DrawBuffer(ctx->Exec, ( mode ));
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->DrawPixels)( width, height, format, type, pixels );
+ CALL_DrawPixels(ctx->Exec, ( width, height, format, type, pixels ));
}
}
n[1].e = cap;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Enable)( cap );
+ CALL_Enable(ctx->Exec, ( cap ));
}
}
n[3].i = i2;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->EvalMesh1)( mode, i1, i2 );
+ CALL_EvalMesh1(ctx->Exec, ( mode, i1, i2 ));
}
}
n[5].i = j2;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->EvalMesh2)( mode, i1, i2, j1, j2 );
+ CALL_EvalMesh2(ctx->Exec, ( mode, i1, i2, j1, j2 ));
}
}
n[5].f = params[3];
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Fogfv)( pname, params );
+ CALL_Fogfv(ctx->Exec, ( pname, params ));
}
}
n[1].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->FrontFace)( mode );
+ CALL_FrontFace(ctx->Exec, ( mode ));
}
}
n[6].f = (GLfloat) farval;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Frustum)( left, right, bottom, top, nearval, farval );
+ CALL_Frustum(ctx->Exec, ( left, right, bottom, top, nearval, farval ));
}
}
n[2].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Hint)( target, mode );
+ CALL_Hint(ctx->Exec, ( target, mode ));
}
}
n[4].b = sink;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Histogram)( target, width, internalFormat, sink );
+ CALL_Histogram(ctx->Exec, ( target, width, internalFormat, sink ));
}
}
n[1].ui = mask;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->IndexMask)( mask );
+ CALL_IndexMask(ctx->Exec, ( mask ));
}
}
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
(void) ALLOC_INSTRUCTION( ctx, OPCODE_INIT_NAMES, 0 );
if (ctx->ExecuteFlag) {
- (*ctx->Exec->InitNames)();
+ CALL_InitNames(ctx->Exec, ());
}
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Lightfv)( light, pname, params );
+ CALL_Lightfv(ctx->Exec, ( light, pname, params ));
}
}
n[5].f = params[3];
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->LightModelfv)( pname, params );
+ CALL_LightModelfv(ctx->Exec, ( pname, params ));
}
}
n[2].us = pattern;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->LineStipple)( factor, pattern );
+ CALL_LineStipple(ctx->Exec, ( factor, pattern ));
}
}
n[1].f = width;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->LineWidth)( width );
+ CALL_LineWidth(ctx->Exec, ( width ));
}
}
n[1].ui = base;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ListBase)( base );
+ CALL_ListBase(ctx->Exec, ( base ));
}
}
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
(void) ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_IDENTITY, 0 );
if (ctx->ExecuteFlag) {
- (*ctx->Exec->LoadIdentity)();
+ CALL_LoadIdentity(ctx->Exec, ());
}
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->LoadMatrixf)( m );
+ CALL_LoadMatrixf(ctx->Exec, ( m ));
}
}
n[1].ui = name;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->LoadName)( name );
+ CALL_LoadName(ctx->Exec, ( name ));
}
}
n[1].e = opcode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->LogicOp)( opcode );
+ CALL_LogicOp(ctx->Exec, ( opcode ));
}
}
n[6].data = (void *) pnts;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Map1d)( target, u1, u2, stride, order, points );
+ CALL_Map1d(ctx->Exec, ( target, u1, u2, stride, order, points ));
}
}
n[6].data = (void *) pnts;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Map1f)( target, u1, u2, stride, order, points );
+ CALL_Map1f(ctx->Exec, ( target, u1, u2, stride, order, points ));
}
}
n[10].data = (void *) pnts;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Map2d)( target,
+ CALL_Map2d(ctx->Exec, ( target,
u1, u2, ustride, uorder,
- v1, v2, vstride, vorder, points );
+ v1, v2, vstride, vorder, points ));
}
}
n[10].data = (void *) pnts;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Map2f)( target, u1, u2, ustride, uorder,
- v1, v2, vstride, vorder, points );
+ CALL_Map2f(ctx->Exec, ( target, u1, u2, ustride, uorder,
+ v1, v2, vstride, vorder, points ));
}
}
n[3].f = u2;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->MapGrid1f)( un, u1, u2 );
+ CALL_MapGrid1f(ctx->Exec, ( un, u1, u2 ));
}
}
n[6].f = v2;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->MapGrid2f)( un, u1, u2, vn, v1, v2 );
+ CALL_MapGrid2f(ctx->Exec, ( un, u1, u2, vn, v1, v2 ));
}
}
n[1].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->MatrixMode)( mode );
+ CALL_MatrixMode(ctx->Exec, ( mode ));
}
}
n[3].b = sink;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Minmax)( target, internalFormat, sink );
+ CALL_Minmax(ctx->Exec, ( target, internalFormat, sink ));
}
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->MultMatrixf)( m );
+ CALL_MultMatrixf(ctx->Exec, ( m ));
}
}
n[6].f = (GLfloat) farval;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Ortho)( left, right, bottom, top, nearval, farval );
+ CALL_Ortho(ctx->Exec, ( left, right, bottom, top, nearval, farval ));
}
}
MEMCPY( n[3].data, (void *) values, mapsize * sizeof(GLfloat) );
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PixelMapfv)( map, mapsize, values );
+ CALL_PixelMapfv(ctx->Exec, ( map, mapsize, values ));
}
}
n[2].f = param;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PixelTransferf)( pname, param );
+ CALL_PixelTransferf(ctx->Exec, ( pname, param ));
}
}
n[2].f = yfactor;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PixelZoom)( xfactor, yfactor );
+ CALL_PixelZoom(ctx->Exec, ( xfactor, yfactor ));
}
}
n[4].f = params[2];
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PointParameterfvEXT)( pname, params );
+ CALL_PointParameterfvEXT(ctx->Exec, ( pname, params ));
}
}
n[1].f = size;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PointSize)( size );
+ CALL_PointSize(ctx->Exec, ( size ));
}
}
n[2].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PolygonMode)( face, mode );
+ CALL_PolygonMode(ctx->Exec, ( face, mode ));
}
}
MEMCPY( data, pattern, 32 * 4 );
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PolygonStipple)( (GLubyte*) pattern );
+ CALL_PolygonStipple(ctx->Exec, ( (GLubyte*) pattern ));
}
}
n[2].f = units;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PolygonOffset)( factor, units );
+ CALL_PolygonOffset(ctx->Exec, ( factor, units ));
}
}
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
(void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_ATTRIB, 0 );
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PopAttrib)();
+ CALL_PopAttrib(ctx->Exec, ());
}
}
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
(void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_MATRIX, 0 );
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PopMatrix)();
+ CALL_PopMatrix(ctx->Exec, ());
}
}
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
(void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_NAME, 0 );
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PopName)();
+ CALL_PopName(ctx->Exec, ());
}
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PrioritizeTextures)( num, textures, priorities );
+ CALL_PrioritizeTextures(ctx->Exec, ( num, textures, priorities ));
}
}
n[1].bf = mask;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PushAttrib)( mask );
+ CALL_PushAttrib(ctx->Exec, ( mask ));
}
}
ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
(void) ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_MATRIX, 0 );
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PushMatrix)();
+ CALL_PushMatrix(ctx->Exec, ());
}
}
n[1].ui = name;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PushName)( name );
+ CALL_PushName(ctx->Exec, ( name ));
}
}
n[4].f = w;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->RasterPos4f)( x, y, z, w );
+ CALL_RasterPos4f(ctx->Exec, ( x, y, z, w ));
}
}
n[1].f = token;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PassThrough)( token );
+ CALL_PassThrough(ctx->Exec, ( token ));
}
}
n[1].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ReadBuffer)( mode );
+ CALL_ReadBuffer(ctx->Exec, ( mode ));
}
}
n[1].e = target;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ResetHistogram)( target );
+ CALL_ResetHistogram(ctx->Exec, ( target ));
}
}
n[1].e = target;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ResetMinmax)( target );
+ CALL_ResetMinmax(ctx->Exec, ( target ));
}
}
n[4].f = z;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Rotatef)( angle, x, y, z );
+ CALL_Rotatef(ctx->Exec, ( angle, x, y, z ));
}
}
n[3].f = z;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Scalef)( x, y, z );
+ CALL_Scalef(ctx->Exec, ( x, y, z ));
}
}
n[4].i = height;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Scissor)( x, y, width, height );
+ CALL_Scissor(ctx->Exec, ( x, y, width, height ));
}
}
n[1].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ShadeModel)( mode );
+ CALL_ShadeModel(ctx->Exec, ( mode ));
}
}
n[3].ui = mask;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->StencilFunc)( func, ref, mask );
+ CALL_StencilFunc(ctx->Exec, ( func, ref, mask ));
}
}
n[1].ui = mask;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->StencilMask)( mask );
+ CALL_StencilMask(ctx->Exec, ( mask ));
}
}
n[3].e = zpass;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->StencilOp)( fail, zfail, zpass );
+ CALL_StencilOp(ctx->Exec, ( fail, zfail, zpass ));
}
}
n[4].ui = mask;
}
if (ctx->ExecuteFlag) {
- ctx->Exec->StencilFuncSeparate(face, func, ref, mask);
+ CALL_StencilFuncSeparate(ctx->Exec, (face, func, ref, mask));
}
}
n[2].ui = mask;
}
if (ctx->ExecuteFlag) {
- ctx->Exec->StencilMaskSeparate(face, mask);
+ CALL_StencilMaskSeparate(ctx->Exec, (face, mask));
}
}
n[4].e = zpass;
}
if (ctx->ExecuteFlag) {
- ctx->Exec->StencilOpSeparate(face, fail, zfail, zpass);
+ CALL_StencilOpSeparate(ctx->Exec, (face, fail, zfail, zpass));
}
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->TexEnvfv)( target, pname, params );
+ CALL_TexEnvfv(ctx->Exec, ( target, pname, params ));
}
}
n[6].f = params[3];
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->TexGenfv)( coord, pname, params );
+ CALL_TexGenfv(ctx->Exec, ( coord, pname, params ));
}
}
n[6].f = params[3];
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->TexParameterfv)( target, pname, params );
+ CALL_TexParameterfv(ctx->Exec, ( target, pname, params ));
}
}
GET_CURRENT_CONTEXT(ctx);
if (target == GL_PROXY_TEXTURE_1D) {
/* don't compile, execute immediately */
- (*ctx->Exec->TexImage1D)( target, level, components, width,
- border, format, type, pixels );
+ CALL_TexImage1D(ctx->Exec, ( target, level, components, width,
+ border, format, type, pixels ));
}
else {
GLvoid *image = unpack_image(1, width, 1, 1, format, type,
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->TexImage1D)( target, level, components, width,
- border, format, type, pixels );
+ CALL_TexImage1D(ctx->Exec, ( target, level, components, width,
+ border, format, type, pixels ));
}
}
}
GET_CURRENT_CONTEXT(ctx);
if (target == GL_PROXY_TEXTURE_2D) {
/* don't compile, execute immediately */
- (*ctx->Exec->TexImage2D)( target, level, components, width,
- height, border, format, type, pixels );
+ CALL_TexImage2D(ctx->Exec, ( target, level, components, width,
+ height, border, format, type, pixels ));
}
else {
GLvoid *image = unpack_image(2, width, height, 1, format, type,
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->TexImage2D)( target, level, components, width,
- height, border, format, type, pixels );
+ CALL_TexImage2D(ctx->Exec, ( target, level, components, width,
+ height, border, format, type, pixels ));
}
}
}
GET_CURRENT_CONTEXT(ctx);
if (target == GL_PROXY_TEXTURE_3D) {
/* don't compile, execute immediately */
- (*ctx->Exec->TexImage3D)( target, level, internalFormat, width,
- height, depth, border, format, type, pixels );
+ CALL_TexImage3D(ctx->Exec, ( target, level, internalFormat, width,
+ height, depth, border, format, type, pixels ));
}
else {
Node *n;
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->TexImage3D)( target, level, internalFormat, width,
- height, depth, border, format, type, pixels );
+ CALL_TexImage3D(ctx->Exec, ( target, level, internalFormat, width,
+ height, depth, border, format, type, pixels ));
}
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->TexSubImage1D)( target, level, xoffset, width,
- format, type, pixels );
+ CALL_TexSubImage1D(ctx->Exec, ( target, level, xoffset, width,
+ format, type, pixels ));
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->TexSubImage2D)( target, level, xoffset, yoffset,
- width, height, format, type, pixels );
+ CALL_TexSubImage2D(ctx->Exec, ( target, level, xoffset, yoffset,
+ width, height, format, type, pixels ));
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->TexSubImage3D)( target, level,
+ CALL_TexSubImage3D(ctx->Exec, ( target, level,
xoffset, yoffset, zoffset,
- width, height, depth, format, type, pixels );
+ width, height, depth, format, type, pixels ));
}
}
n[3].f = z;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Translatef)( x, y, z );
+ CALL_Translatef(ctx->Exec, ( x, y, z ));
}
}
n[4].i = (GLint) height;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Viewport)( x, y, width, height );
+ CALL_Viewport(ctx->Exec, ( x, y, width, height ));
}
}
n[4].f = w;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->WindowPos4fMESA)( x, y, z, w );
+ CALL_WindowPos4fMESA(ctx->Exec, ( x, y, z, w ));
}
}
n[1].e = target;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ActiveTextureARB)( target );
+ CALL_ActiveTextureARB(ctx->Exec, ( target ));
}
}
n[1].e = mode;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PixelTexGenSGIX)( mode );
+ CALL_PixelTexGenSGIX(ctx->Exec, ( mode ));
}
}
GET_CURRENT_CONTEXT(ctx);
if (target == GL_PROXY_TEXTURE_1D) {
/* don't compile, execute immediately */
- (*ctx->Exec->CompressedTexImage1DARB)(target, level, internalFormat,
- width, border, imageSize, data);
+ CALL_CompressedTexImage1DARB(ctx->Exec, (target, level, internalFormat,
+ width, border, imageSize, data));
}
else {
Node *n;
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CompressedTexImage1DARB)(target, level, internalFormat,
- width, border, imageSize, data);
+ CALL_CompressedTexImage1DARB(ctx->Exec, (target, level, internalFormat,
+ width, border, imageSize, data));
}
}
}
GET_CURRENT_CONTEXT(ctx);
if (target == GL_PROXY_TEXTURE_2D) {
/* don't compile, execute immediately */
- (*ctx->Exec->CompressedTexImage2DARB)(target, level, internalFormat,
- width, height, border, imageSize, data);
+ CALL_CompressedTexImage2DARB(ctx->Exec, (target, level, internalFormat,
+ width, height, border, imageSize, data));
}
else {
Node *n;
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CompressedTexImage2DARB)(target, level, internalFormat,
- width, height, border, imageSize, data);
+ CALL_CompressedTexImage2DARB(ctx->Exec, (target, level, internalFormat,
+ width, height, border, imageSize, data));
}
}
}
GET_CURRENT_CONTEXT(ctx);
if (target == GL_PROXY_TEXTURE_3D) {
/* don't compile, execute immediately */
- (*ctx->Exec->CompressedTexImage3DARB)(target, level, internalFormat,
- width, height, depth, border, imageSize, data);
+ CALL_CompressedTexImage3DARB(ctx->Exec, (target, level, internalFormat,
+ width, height, depth, border, imageSize, data));
}
else {
Node *n;
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CompressedTexImage3DARB)(target, level, internalFormat,
- width, height, depth, border, imageSize, data);
+ CALL_CompressedTexImage3DARB(ctx->Exec, (target, level, internalFormat,
+ width, height, depth, border, imageSize, data));
}
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CompressedTexSubImage1DARB)(target, level, xoffset,
- width, format, imageSize, data);
+ CALL_CompressedTexSubImage1DARB(ctx->Exec, (target, level, xoffset,
+ width, format, imageSize, data));
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CompressedTexSubImage2DARB)(target, level, xoffset, yoffset,
- width, height, format, imageSize, data);
+ CALL_CompressedTexSubImage2DARB(ctx->Exec, (target, level, xoffset, yoffset,
+ width, height, format, imageSize, data));
}
}
FREE(image);
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->CompressedTexSubImage3DARB)(target, level, xoffset, yoffset,
- zoffset, width, height, depth, format, imageSize, data);
+ CALL_CompressedTexSubImage3DARB(ctx->Exec, (target, level, xoffset, yoffset,
+ zoffset, width, height, depth, format, imageSize, data));
}
}
n[2].b = invert;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->SampleCoverageARB)( value, invert );
+ CALL_SampleCoverageARB(ctx->Exec, ( value, invert ));
}
}
n[2].i = value;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->PixelTexGenParameteriSGIS)( target, value );
+ CALL_PixelTexGenParameteriSGIS(ctx->Exec, ( target, value ));
}
}
n[2].ui = id;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->BindProgramNV)( target, id );
+ CALL_BindProgramNV(ctx->Exec, ( target, id ));
}
}
#endif /* FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program */
n[6].f = params[3];
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ExecuteProgramNV)(target, id, params);
+ CALL_ExecuteProgramNV(ctx->Exec, (target, id, params));
}
}
n[6].f = w;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ProgramParameter4fNV)(target, index, x, y, z, w);
+ CALL_ProgramParameter4fNV(ctx->Exec, (target, index, x, y, z, w));
}
}
n[4].data = programCopy;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->LoadProgramNV)(target, id, len, program);
+ CALL_LoadProgramNV(ctx->Exec, (target, id, len, program));
}
}
n[2].data = idCopy;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->RequestResidentProgramsNV)(num, ids);
+ CALL_RequestResidentProgramsNV(ctx->Exec, (num, ids));
}
}
n[4].e = transform;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->TrackMatrixNV)(target, address, matrix, transform);
+ CALL_TrackMatrixNV(ctx->Exec, (target, address, matrix, transform));
}
}
#endif /* FEATURE_NV_vertex_program */
n[6].f = w;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ProgramLocalParameter4fARB)(target, index, x, y, z, w);
+ CALL_ProgramLocalParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
}
}
n[6].f = params[3];
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ProgramLocalParameter4fvARB)(target, index, params);
+ CALL_ProgramLocalParameter4fvARB(ctx->Exec, (target, index, params));
}
}
n[6].f = (GLfloat) w;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ProgramLocalParameter4dARB)(target, index, x, y, z, w);
+ CALL_ProgramLocalParameter4dARB(ctx->Exec, (target, index, x, y, z, w));
}
}
n[6].f = (GLfloat) params[3];
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ProgramLocalParameter4dvARB)(target, index, params);
+ CALL_ProgramLocalParameter4dvARB(ctx->Exec, (target, index, params));
}
}
n[7].f = w;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ProgramNamedParameter4fNV)(id, len, name, x, y, z, w);
+ CALL_ProgramNamedParameter4fNV(ctx->Exec, (id, len, name, x, y, z, w));
}
}
n[1].e = face;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ActiveStencilFaceEXT)( face );
+ CALL_ActiveStencilFaceEXT(ctx->Exec, ( face ));
}
}
n[2].f = (GLfloat) zmax;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->DepthBoundsEXT)( zmin, zmax );
+ CALL_DepthBoundsEXT(ctx->Exec, ( zmin, zmax ));
}
}
n[4].data = programCopy;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ProgramStringARB)(target, format, len, string);
+ CALL_ProgramStringARB(ctx->Exec, (target, format, len, string));
}
}
n[6].f = w;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->ProgramEnvParameter4fARB)( target, index, x, y, z, w);
+ CALL_ProgramEnvParameter4fARB(ctx->Exec, ( target, index, x, y, z, w));
}
}
n[2].ui = id;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->BeginQueryARB)( target, id );
+ CALL_BeginQueryARB(ctx->Exec, ( target, id ));
}
}
n[1].e = target;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->EndQueryARB)( target );
+ CALL_EndQueryARB(ctx->Exec, ( target ));
}
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->DrawBuffersARB)(count, buffers);
+ CALL_DrawBuffersARB(ctx->Exec, (count, buffers));
}
}
n[1].ui = id;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->BindFragmentShaderATI)(id);
+ CALL_BindFragmentShaderATI(ctx->Exec, (id));
}
}
n[5].f = value[3];
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->SetFragmentShaderConstantATI)(dst, value);
+ CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, value));
}
}
#endif
ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
if (ctx->ExecuteFlag) {
- (*ctx->Exec->VertexAttrib1fNV)( attr, x );
+ CALL_VertexAttrib1fNV(ctx->Exec, ( attr, x ));
}
}
ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
if (ctx->ExecuteFlag) {
- (*ctx->Exec->VertexAttrib2fNV)( attr, x, y );
+ CALL_VertexAttrib2fNV(ctx->Exec, ( attr, x, y ));
}
}
ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
if (ctx->ExecuteFlag) {
- (*ctx->Exec->VertexAttrib3fNV)( attr, x, y, z );
+ CALL_VertexAttrib3fNV(ctx->Exec, ( attr, x, y, z ));
}
}
ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, y, z, w);
if (ctx->ExecuteFlag) {
- (*ctx->Exec->VertexAttrib4fNV)( attr, x, y, z, w );
+ CALL_VertexAttrib4fNV(ctx->Exec, ( attr, x, y, z, w ));
}
}
ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
if (ctx->ExecuteFlag) {
- (*ctx->Exec->VertexAttrib1fARB)( attr, x );
+ CALL_VertexAttrib1fARB(ctx->Exec, ( attr, x ));
}
}
ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
if (ctx->ExecuteFlag) {
- (*ctx->Exec->VertexAttrib2fARB)( attr, x, y );
+ CALL_VertexAttrib2fARB(ctx->Exec, ( attr, x, y ));
}
}
ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
if (ctx->ExecuteFlag) {
- (*ctx->Exec->VertexAttrib3fARB)( attr, x, y, z );
+ CALL_VertexAttrib3fARB(ctx->Exec, ( attr, x, y, z ));
}
}
ASSIGN_4V( ctx->ListState.CurrentAttrib[attr], x, y, z, w);
if (ctx->ExecuteFlag) {
- (*ctx->Exec->VertexAttrib4fARB)( attr, x, y, z, w );
+ CALL_VertexAttrib4fARB(ctx->Exec, ( attr, x, y, z, w ));
}
}
n[1].f = x;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->EvalCoord1f)( x );
+ CALL_EvalCoord1f(ctx->Exec, ( x ));
}
}
n[2].f = y;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->EvalCoord2f)( x, y );
+ CALL_EvalCoord2f(ctx->Exec, ( x, y ));
}
}
n[1].i = x;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->EvalPoint1)( x );
+ CALL_EvalPoint1(ctx->Exec, ( x ));
}
}
n[2].i = y;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->EvalPoint2)( x, y );
+ CALL_EvalPoint2(ctx->Exec, ( x, y ));
}
}
ctx->ListState.CurrentIndex = x;
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Indexi)( (GLint) x );
+ CALL_Indexi(ctx->Exec, ( (GLint) x ));
}
}
ctx->ListState.CurrentEdgeFlag = x;
if (ctx->ExecuteFlag) {
- (*ctx->Exec->EdgeFlag)( x );
+ CALL_EdgeFlag(ctx->Exec, ( x ));
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Materialfv)( face, pname, param );
+ CALL_Materialfv(ctx->Exec, ( face, pname, param ));
}
}
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Begin)( mode );
+ CALL_Begin(ctx->Exec, ( mode ));
}
}
(void) ALLOC_INSTRUCTION( ctx, OPCODE_END, 0 );
ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
if (ctx->ExecuteFlag) {
- (*ctx->Exec->End)( );
+ CALL_End(ctx->Exec, ( ));
}
}
n[4].f = d;
}
if (ctx->ExecuteFlag) {
- (*ctx->Exec->Rectf)( a, b, c, d );
+ CALL_Rectf(ctx->Exec, ( a, b, c, d ));
}
}
_mesa_error( ctx, n[1].e, (const char *) n[2].data );
break;
case OPCODE_ACCUM:
- (*ctx->Exec->Accum)( n[1].e, n[2].f );
+ CALL_Accum(ctx->Exec, ( n[1].e, n[2].f ));
break;
case OPCODE_ALPHA_FUNC:
- (*ctx->Exec->AlphaFunc)( n[1].e, n[2].f );
+ CALL_AlphaFunc(ctx->Exec, ( n[1].e, n[2].f ));
break;
case OPCODE_BIND_TEXTURE:
- (*ctx->Exec->BindTexture)( n[1].e, n[2].ui );
+ CALL_BindTexture(ctx->Exec, ( n[1].e, n[2].ui ));
break;
case OPCODE_BITMAP:
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->Bitmap)( (GLsizei) n[1].i, (GLsizei) n[2].i,
- n[3].f, n[4].f, n[5].f, n[6].f, (const GLubyte *) n[7].data );
+ CALL_Bitmap(ctx->Exec, ( (GLsizei) n[1].i, (GLsizei) n[2].i,
+ n[3].f, n[4].f, n[5].f, n[6].f, (const GLubyte *) n[7].data ));
ctx->Unpack = save; /* restore */
}
break;
case OPCODE_BLEND_COLOR:
- (*ctx->Exec->BlendColor)( n[1].f, n[2].f, n[3].f, n[4].f );
+ CALL_BlendColor(ctx->Exec, ( n[1].f, n[2].f, n[3].f, n[4].f ));
break;
case OPCODE_BLEND_EQUATION:
- (*ctx->Exec->BlendEquation)( n[1].e );
+ CALL_BlendEquation(ctx->Exec, ( n[1].e ));
break;
case OPCODE_BLEND_EQUATION_SEPARATE:
- (*ctx->Exec->BlendEquationSeparateEXT)( n[1].e, n[2].e );
+ CALL_BlendEquationSeparateEXT(ctx->Exec, ( n[1].e, n[2].e ));
break;
case OPCODE_BLEND_FUNC_SEPARATE:
- (*ctx->Exec->BlendFuncSeparateEXT)(n[1].e, n[2].e, n[3].e, n[4].e);
+ CALL_BlendFuncSeparateEXT(ctx->Exec, (n[1].e, n[2].e, n[3].e, n[4].e));
break;
case OPCODE_CALL_LIST:
/* Generated by glCallList(), don't add ListBase */
}
break;
case OPCODE_CLEAR:
- (*ctx->Exec->Clear)( n[1].bf );
+ CALL_Clear(ctx->Exec, ( n[1].bf ));
break;
case OPCODE_CLEAR_COLOR:
- (*ctx->Exec->ClearColor)( n[1].f, n[2].f, n[3].f, n[4].f );
+ CALL_ClearColor(ctx->Exec, ( n[1].f, n[2].f, n[3].f, n[4].f ));
break;
case OPCODE_CLEAR_ACCUM:
- (*ctx->Exec->ClearAccum)( n[1].f, n[2].f, n[3].f, n[4].f );
+ CALL_ClearAccum(ctx->Exec, ( n[1].f, n[2].f, n[3].f, n[4].f ));
break;
case OPCODE_CLEAR_DEPTH:
- (*ctx->Exec->ClearDepth)( (GLclampd) n[1].f );
+ CALL_ClearDepth(ctx->Exec, ( (GLclampd) n[1].f ));
break;
case OPCODE_CLEAR_INDEX:
- (*ctx->Exec->ClearIndex)( (GLfloat) n[1].ui );
+ CALL_ClearIndex(ctx->Exec, ( (GLfloat) n[1].ui ));
break;
case OPCODE_CLEAR_STENCIL:
- (*ctx->Exec->ClearStencil)( n[1].i );
+ CALL_ClearStencil(ctx->Exec, ( n[1].i ));
break;
case OPCODE_CLIP_PLANE:
{
eq[1] = n[3].f;
eq[2] = n[4].f;
eq[3] = n[5].f;
- (*ctx->Exec->ClipPlane)( n[1].e, eq );
+ CALL_ClipPlane(ctx->Exec, ( n[1].e, eq ));
}
break;
case OPCODE_COLOR_MASK:
- (*ctx->Exec->ColorMask)( n[1].b, n[2].b, n[3].b, n[4].b );
+ CALL_ColorMask(ctx->Exec, ( n[1].b, n[2].b, n[3].b, n[4].b ));
break;
case OPCODE_COLOR_MATERIAL:
- (*ctx->Exec->ColorMaterial)( n[1].e, n[2].e );
+ CALL_ColorMaterial(ctx->Exec, ( n[1].e, n[2].e ));
break;
case OPCODE_COLOR_TABLE:
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->ColorTable)( n[1].e, n[2].e, n[3].i, n[4].e,
- n[5].e, n[6].data );
+ CALL_ColorTable(ctx->Exec, ( n[1].e, n[2].e, n[3].i, n[4].e,
+ n[5].e, n[6].data ));
ctx->Unpack = save; /* restore */
}
break;
params[1] = n[4].f;
params[2] = n[5].f;
params[3] = n[6].f;
- (*ctx->Exec->ColorTableParameterfv)( n[1].e, n[2].e, params );
+ CALL_ColorTableParameterfv(ctx->Exec, ( n[1].e, n[2].e, params ));
}
break;
case OPCODE_COLOR_TABLE_PARAMETER_IV:
params[1] = n[4].i;
params[2] = n[5].i;
params[3] = n[6].i;
- (*ctx->Exec->ColorTableParameteriv)( n[1].e, n[2].e, params );
+ CALL_ColorTableParameteriv(ctx->Exec, ( n[1].e, n[2].e, params ));
}
break;
case OPCODE_COLOR_SUB_TABLE:
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->ColorSubTable)( n[1].e, n[2].i, n[3].i,
- n[4].e, n[5].e, n[6].data );
+ CALL_ColorSubTable(ctx->Exec, ( n[1].e, n[2].i, n[3].i,
+ n[4].e, n[5].e, n[6].data ));
ctx->Unpack = save; /* restore */
}
break;
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->ConvolutionFilter1D)( n[1].e, n[2].i, n[3].i,
- n[4].e, n[5].e, n[6].data );
+ CALL_ConvolutionFilter1D(ctx->Exec, ( n[1].e, n[2].i, n[3].i,
+ n[4].e, n[5].e, n[6].data ));
ctx->Unpack = save; /* restore */
}
break;
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->ConvolutionFilter2D)( n[1].e, n[2].i, n[3].i,
- n[4].i, n[5].e, n[6].e, n[7].data );
+ CALL_ConvolutionFilter2D(ctx->Exec, ( n[1].e, n[2].i, n[3].i,
+ n[4].i, n[5].e, n[6].e, n[7].data ));
ctx->Unpack = save; /* restore */
}
break;
case OPCODE_CONVOLUTION_PARAMETER_I:
- (*ctx->Exec->ConvolutionParameteri)( n[1].e, n[2].e, n[3].i );
+ CALL_ConvolutionParameteri(ctx->Exec, ( n[1].e, n[2].e, n[3].i ));
break;
case OPCODE_CONVOLUTION_PARAMETER_IV:
{
params[1] = n[4].i;
params[2] = n[5].i;
params[3] = n[6].i;
- (*ctx->Exec->ConvolutionParameteriv)( n[1].e, n[2].e, params );
+ CALL_ConvolutionParameteriv(ctx->Exec, ( n[1].e, n[2].e, params ));
}
break;
case OPCODE_CONVOLUTION_PARAMETER_F:
- (*ctx->Exec->ConvolutionParameterf)( n[1].e, n[2].e, n[3].f );
+ CALL_ConvolutionParameterf(ctx->Exec, ( n[1].e, n[2].e, n[3].f ));
break;
case OPCODE_CONVOLUTION_PARAMETER_FV:
{
params[1] = n[4].f;
params[2] = n[5].f;
params[3] = n[6].f;
- (*ctx->Exec->ConvolutionParameterfv)( n[1].e, n[2].e, params );
+ CALL_ConvolutionParameterfv(ctx->Exec, ( n[1].e, n[2].e, params ));
}
break;
case OPCODE_COPY_COLOR_SUB_TABLE:
- (*ctx->Exec->CopyColorSubTable)( n[1].e, n[2].i,
- n[3].i, n[4].i, n[5].i );
+ CALL_CopyColorSubTable(ctx->Exec, ( n[1].e, n[2].i,
+ n[3].i, n[4].i, n[5].i ));
break;
case OPCODE_COPY_COLOR_TABLE:
- (*ctx->Exec->CopyColorSubTable)( n[1].e, n[2].i,
- n[3].i, n[4].i, n[5].i );
+ CALL_CopyColorSubTable(ctx->Exec, ( n[1].e, n[2].i,
+ n[3].i, n[4].i, n[5].i ));
break;
case OPCODE_COPY_PIXELS:
- (*ctx->Exec->CopyPixels)( n[1].i, n[2].i,
- (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e );
+ CALL_CopyPixels(ctx->Exec, ( n[1].i, n[2].i,
+ (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e ));
break;
case OPCODE_COPY_TEX_IMAGE1D:
- (*ctx->Exec->CopyTexImage1D)( n[1].e, n[2].i, n[3].e, n[4].i,
- n[5].i, n[6].i, n[7].i );
+ CALL_CopyTexImage1D(ctx->Exec, ( n[1].e, n[2].i, n[3].e, n[4].i,
+ n[5].i, n[6].i, n[7].i ));
break;
case OPCODE_COPY_TEX_IMAGE2D:
- (*ctx->Exec->CopyTexImage2D)( n[1].e, n[2].i, n[3].e, n[4].i,
- n[5].i, n[6].i, n[7].i, n[8].i );
+ CALL_CopyTexImage2D(ctx->Exec, ( n[1].e, n[2].i, n[3].e, n[4].i,
+ n[5].i, n[6].i, n[7].i, n[8].i ));
break;
case OPCODE_COPY_TEX_SUB_IMAGE1D:
- (*ctx->Exec->CopyTexSubImage1D)( n[1].e, n[2].i, n[3].i,
- n[4].i, n[5].i, n[6].i );
+ CALL_CopyTexSubImage1D(ctx->Exec, ( n[1].e, n[2].i, n[3].i,
+ n[4].i, n[5].i, n[6].i ));
break;
case OPCODE_COPY_TEX_SUB_IMAGE2D:
- (*ctx->Exec->CopyTexSubImage2D)( n[1].e, n[2].i, n[3].i,
- n[4].i, n[5].i, n[6].i, n[7].i, n[8].i );
+ CALL_CopyTexSubImage2D(ctx->Exec, ( n[1].e, n[2].i, n[3].i,
+ n[4].i, n[5].i, n[6].i, n[7].i, n[8].i ));
break;
case OPCODE_COPY_TEX_SUB_IMAGE3D:
- (*ctx->Exec->CopyTexSubImage3D)( n[1].e, n[2].i, n[3].i,
- n[4].i, n[5].i, n[6].i, n[7].i, n[8].i , n[9].i);
+ CALL_CopyTexSubImage3D(ctx->Exec, ( n[1].e, n[2].i, n[3].i,
+ n[4].i, n[5].i, n[6].i, n[7].i, n[8].i , n[9].i));
break;
case OPCODE_CULL_FACE:
- (*ctx->Exec->CullFace)( n[1].e );
+ CALL_CullFace(ctx->Exec, ( n[1].e ));
break;
case OPCODE_DEPTH_FUNC:
- (*ctx->Exec->DepthFunc)( n[1].e );
+ CALL_DepthFunc(ctx->Exec, ( n[1].e ));
break;
case OPCODE_DEPTH_MASK:
- (*ctx->Exec->DepthMask)( n[1].b );
+ CALL_DepthMask(ctx->Exec, ( n[1].b ));
break;
case OPCODE_DEPTH_RANGE:
- (*ctx->Exec->DepthRange)( (GLclampd) n[1].f, (GLclampd) n[2].f );
+ CALL_DepthRange(ctx->Exec, ( (GLclampd) n[1].f, (GLclampd) n[2].f ));
break;
case OPCODE_DISABLE:
- (*ctx->Exec->Disable)( n[1].e );
+ CALL_Disable(ctx->Exec, ( n[1].e ));
break;
case OPCODE_DRAW_BUFFER:
- (*ctx->Exec->DrawBuffer)( n[1].e );
+ CALL_DrawBuffer(ctx->Exec, ( n[1].e ));
break;
case OPCODE_DRAW_PIXELS:
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->DrawPixels)( n[1].i, n[2].i, n[3].e, n[4].e,
- n[5].data );
+ CALL_DrawPixels(ctx->Exec, ( n[1].i, n[2].i, n[3].e, n[4].e,
+ n[5].data ));
ctx->Unpack = save; /* restore */
}
break;
case OPCODE_ENABLE:
- (*ctx->Exec->Enable)( n[1].e );
+ CALL_Enable(ctx->Exec, ( n[1].e ));
break;
case OPCODE_EVALMESH1:
- (*ctx->Exec->EvalMesh1)( n[1].e, n[2].i, n[3].i );
+ CALL_EvalMesh1(ctx->Exec, ( n[1].e, n[2].i, n[3].i ));
break;
case OPCODE_EVALMESH2:
- (*ctx->Exec->EvalMesh2)( n[1].e, n[2].i, n[3].i, n[4].i, n[5].i );
+ CALL_EvalMesh2(ctx->Exec, ( n[1].e, n[2].i, n[3].i, n[4].i, n[5].i ));
break;
case OPCODE_FOG:
{
p[1] = n[3].f;
p[2] = n[4].f;
p[3] = n[5].f;
- (*ctx->Exec->Fogfv)( n[1].e, p );
+ CALL_Fogfv(ctx->Exec, ( n[1].e, p ));
}
break;
case OPCODE_FRONT_FACE:
- (*ctx->Exec->FrontFace)( n[1].e );
+ CALL_FrontFace(ctx->Exec, ( n[1].e ));
break;
case OPCODE_FRUSTUM:
- (*ctx->Exec->Frustum)( n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
+ CALL_Frustum(ctx->Exec, ( n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f ));
break;
case OPCODE_HINT:
- (*ctx->Exec->Hint)( n[1].e, n[2].e );
+ CALL_Hint(ctx->Exec, ( n[1].e, n[2].e ));
break;
case OPCODE_HISTOGRAM:
- (*ctx->Exec->Histogram)( n[1].e, n[2].i, n[3].e, n[4].b );
+ CALL_Histogram(ctx->Exec, ( n[1].e, n[2].i, n[3].e, n[4].b ));
break;
case OPCODE_INDEX_MASK:
- (*ctx->Exec->IndexMask)( n[1].ui );
+ CALL_IndexMask(ctx->Exec, ( n[1].ui ));
break;
case OPCODE_INIT_NAMES:
- (*ctx->Exec->InitNames)();
+ CALL_InitNames(ctx->Exec, ());
break;
case OPCODE_LIGHT:
{
p[1] = n[4].f;
p[2] = n[5].f;
p[3] = n[6].f;
- (*ctx->Exec->Lightfv)( n[1].e, n[2].e, p );
+ CALL_Lightfv(ctx->Exec, ( n[1].e, n[2].e, p ));
}
break;
case OPCODE_LIGHT_MODEL:
p[1] = n[3].f;
p[2] = n[4].f;
p[3] = n[5].f;
- (*ctx->Exec->LightModelfv)( n[1].e, p );
+ CALL_LightModelfv(ctx->Exec, ( n[1].e, p ));
}
break;
case OPCODE_LINE_STIPPLE:
- (*ctx->Exec->LineStipple)( n[1].i, n[2].us );
+ CALL_LineStipple(ctx->Exec, ( n[1].i, n[2].us ));
break;
case OPCODE_LINE_WIDTH:
- (*ctx->Exec->LineWidth)( n[1].f );
+ CALL_LineWidth(ctx->Exec, ( n[1].f ));
break;
case OPCODE_LIST_BASE:
- (*ctx->Exec->ListBase)( n[1].ui );
+ CALL_ListBase(ctx->Exec, ( n[1].ui ));
break;
case OPCODE_LOAD_IDENTITY:
- (*ctx->Exec->LoadIdentity)();
+ CALL_LoadIdentity(ctx->Exec, ());
break;
case OPCODE_LOAD_MATRIX:
if (sizeof(Node)==sizeof(GLfloat)) {
- (*ctx->Exec->LoadMatrixf)( &n[1].f );
+ CALL_LoadMatrixf(ctx->Exec, ( &n[1].f ));
}
else {
GLfloat m[16];
for (i=0;i<16;i++) {
m[i] = n[1+i].f;
}
- (*ctx->Exec->LoadMatrixf)( m );
+ CALL_LoadMatrixf(ctx->Exec, ( m ));
}
break;
case OPCODE_LOAD_NAME:
- (*ctx->Exec->LoadName)( n[1].ui );
+ CALL_LoadName(ctx->Exec, ( n[1].ui ));
break;
case OPCODE_LOGIC_OP:
- (*ctx->Exec->LogicOp)( n[1].e );
+ CALL_LogicOp(ctx->Exec, ( n[1].e ));
break;
case OPCODE_MAP1:
{
GLint uorder = n[5].i;
GLfloat u1 = n[2].f;
GLfloat u2 = n[3].f;
- (*ctx->Exec->Map1f)( target, u1, u2, ustride, uorder,
- (GLfloat *) n[6].data );
+ CALL_Map1f(ctx->Exec, ( target, u1, u2, ustride, uorder,
+ (GLfloat *) n[6].data ));
}
break;
case OPCODE_MAP2:
GLint vstride = n[7].i;
GLint uorder = n[8].i;
GLint vorder = n[9].i;
- (*ctx->Exec->Map2f)( target, u1, u2, ustride, uorder,
+ CALL_Map2f(ctx->Exec, ( target, u1, u2, ustride, uorder,
v1, v2, vstride, vorder,
- (GLfloat *) n[10].data );
+ (GLfloat *) n[10].data ));
}
break;
case OPCODE_MAPGRID1:
- (*ctx->Exec->MapGrid1f)( n[1].i, n[2].f, n[3].f );
+ CALL_MapGrid1f(ctx->Exec, ( n[1].i, n[2].f, n[3].f ));
break;
case OPCODE_MAPGRID2:
- (*ctx->Exec->MapGrid2f)( n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
+ CALL_MapGrid2f(ctx->Exec, ( n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f));
break;
case OPCODE_MATRIX_MODE:
- (*ctx->Exec->MatrixMode)( n[1].e );
+ CALL_MatrixMode(ctx->Exec, ( n[1].e ));
break;
case OPCODE_MIN_MAX:
- (*ctx->Exec->Minmax)(n[1].e, n[2].e, n[3].b);
+ CALL_Minmax(ctx->Exec, (n[1].e, n[2].e, n[3].b));
break;
case OPCODE_MULT_MATRIX:
if (sizeof(Node)==sizeof(GLfloat)) {
- (*ctx->Exec->MultMatrixf)( &n[1].f );
+ CALL_MultMatrixf(ctx->Exec, ( &n[1].f ));
}
else {
GLfloat m[16];
for (i=0;i<16;i++) {
m[i] = n[1+i].f;
}
- (*ctx->Exec->MultMatrixf)( m );
+ CALL_MultMatrixf(ctx->Exec, ( m ));
}
break;
case OPCODE_ORTHO:
- (*ctx->Exec->Ortho)( n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f );
+ CALL_Ortho(ctx->Exec, ( n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f ));
break;
case OPCODE_PASSTHROUGH:
- (*ctx->Exec->PassThrough)( n[1].f );
+ CALL_PassThrough(ctx->Exec, ( n[1].f ));
break;
case OPCODE_PIXEL_MAP:
- (*ctx->Exec->PixelMapfv)( n[1].e, n[2].i, (GLfloat *) n[3].data );
+ CALL_PixelMapfv(ctx->Exec, ( n[1].e, n[2].i, (GLfloat *) n[3].data ));
break;
case OPCODE_PIXEL_TRANSFER:
- (*ctx->Exec->PixelTransferf)( n[1].e, n[2].f );
+ CALL_PixelTransferf(ctx->Exec, ( n[1].e, n[2].f ));
break;
case OPCODE_PIXEL_ZOOM:
- (*ctx->Exec->PixelZoom)( n[1].f, n[2].f );
+ CALL_PixelZoom(ctx->Exec, ( n[1].f, n[2].f ));
break;
case OPCODE_POINT_SIZE:
- (*ctx->Exec->PointSize)( n[1].f );
+ CALL_PointSize(ctx->Exec, ( n[1].f ));
break;
case OPCODE_POINT_PARAMETERS:
{
params[0] = n[2].f;
params[1] = n[3].f;
params[2] = n[4].f;
- (*ctx->Exec->PointParameterfvEXT)( n[1].e, params );
+ CALL_PointParameterfvEXT(ctx->Exec, ( n[1].e, params ));
}
break;
case OPCODE_POLYGON_MODE:
- (*ctx->Exec->PolygonMode)( n[1].e, n[2].e );
+ CALL_PolygonMode(ctx->Exec, ( n[1].e, n[2].e ));
break;
case OPCODE_POLYGON_STIPPLE:
- (*ctx->Exec->PolygonStipple)( (GLubyte *) n[1].data );
+ CALL_PolygonStipple(ctx->Exec, ( (GLubyte *) n[1].data ));
break;
case OPCODE_POLYGON_OFFSET:
- (*ctx->Exec->PolygonOffset)( n[1].f, n[2].f );
+ CALL_PolygonOffset(ctx->Exec, ( n[1].f, n[2].f ));
break;
case OPCODE_POP_ATTRIB:
- (*ctx->Exec->PopAttrib)();
+ CALL_PopAttrib(ctx->Exec, ());
break;
case OPCODE_POP_MATRIX:
- (*ctx->Exec->PopMatrix)();
+ CALL_PopMatrix(ctx->Exec, ());
break;
case OPCODE_POP_NAME:
- (*ctx->Exec->PopName)();
+ CALL_PopName(ctx->Exec, ());
break;
case OPCODE_PRIORITIZE_TEXTURE:
- (*ctx->Exec->PrioritizeTextures)( 1, &n[1].ui, &n[2].f );
+ CALL_PrioritizeTextures(ctx->Exec, ( 1, &n[1].ui, &n[2].f ));
break;
case OPCODE_PUSH_ATTRIB:
- (*ctx->Exec->PushAttrib)( n[1].bf );
+ CALL_PushAttrib(ctx->Exec, ( n[1].bf ));
break;
case OPCODE_PUSH_MATRIX:
- (*ctx->Exec->PushMatrix)();
+ CALL_PushMatrix(ctx->Exec, ());
break;
case OPCODE_PUSH_NAME:
- (*ctx->Exec->PushName)( n[1].ui );
+ CALL_PushName(ctx->Exec, ( n[1].ui ));
break;
case OPCODE_RASTER_POS:
- (*ctx->Exec->RasterPos4f)( n[1].f, n[2].f, n[3].f, n[4].f );
+ CALL_RasterPos4f(ctx->Exec, ( n[1].f, n[2].f, n[3].f, n[4].f ));
break;
case OPCODE_READ_BUFFER:
- (*ctx->Exec->ReadBuffer)( n[1].e );
+ CALL_ReadBuffer(ctx->Exec, ( n[1].e ));
break;
case OPCODE_RESET_HISTOGRAM:
- (*ctx->Exec->ResetHistogram)( n[1].e );
+ CALL_ResetHistogram(ctx->Exec, ( n[1].e ));
break;
case OPCODE_RESET_MIN_MAX:
- (*ctx->Exec->ResetMinmax)( n[1].e );
+ CALL_ResetMinmax(ctx->Exec, ( n[1].e ));
break;
case OPCODE_ROTATE:
- (*ctx->Exec->Rotatef)( n[1].f, n[2].f, n[3].f, n[4].f );
+ CALL_Rotatef(ctx->Exec, ( n[1].f, n[2].f, n[3].f, n[4].f ));
break;
case OPCODE_SCALE:
- (*ctx->Exec->Scalef)( n[1].f, n[2].f, n[3].f );
+ CALL_Scalef(ctx->Exec, ( n[1].f, n[2].f, n[3].f ));
break;
case OPCODE_SCISSOR:
- (*ctx->Exec->Scissor)( n[1].i, n[2].i, n[3].i, n[4].i );
+ CALL_Scissor(ctx->Exec, ( n[1].i, n[2].i, n[3].i, n[4].i ));
break;
case OPCODE_SHADE_MODEL:
- (*ctx->Exec->ShadeModel)( n[1].e );
+ CALL_ShadeModel(ctx->Exec, ( n[1].e ));
break;
case OPCODE_STENCIL_FUNC:
- (*ctx->Exec->StencilFunc)( n[1].e, n[2].i, n[3].ui );
+ CALL_StencilFunc(ctx->Exec, ( n[1].e, n[2].i, n[3].ui ));
break;
case OPCODE_STENCIL_MASK:
- (*ctx->Exec->StencilMask)( n[1].ui );
+ CALL_StencilMask(ctx->Exec, ( n[1].ui ));
break;
case OPCODE_STENCIL_OP:
- (*ctx->Exec->StencilOp)( n[1].e, n[2].e, n[3].e );
+ CALL_StencilOp(ctx->Exec, ( n[1].e, n[2].e, n[3].e ));
break;
case OPCODE_STENCIL_FUNC_SEPARATE:
- ctx->Exec->StencilFuncSeparate( n[1].e, n[2].e, n[3].i, n[4].ui );
+ CALL_StencilFuncSeparate(ctx->Exec, ( n[1].e, n[2].e, n[3].i, n[4].ui ));
break;
case OPCODE_STENCIL_MASK_SEPARATE:
- ctx->Exec->StencilMaskSeparate( n[1].e, n[2].ui );
+ CALL_StencilMaskSeparate(ctx->Exec, ( n[1].e, n[2].ui ));
break;
case OPCODE_STENCIL_OP_SEPARATE:
- ctx->Exec->StencilOpSeparate( n[1].e, n[2].e, n[3].e, n[4].e );
+ CALL_StencilOpSeparate(ctx->Exec, ( n[1].e, n[2].e, n[3].e, n[4].e ));
break;
case OPCODE_TEXENV:
{
params[1] = n[4].f;
params[2] = n[5].f;
params[3] = n[6].f;
- (*ctx->Exec->TexEnvfv)( n[1].e, n[2].e, params );
+ CALL_TexEnvfv(ctx->Exec, ( n[1].e, n[2].e, params ));
}
break;
case OPCODE_TEXGEN:
params[1] = n[4].f;
params[2] = n[5].f;
params[3] = n[6].f;
- (*ctx->Exec->TexGenfv)( n[1].e, n[2].e, params );
+ CALL_TexGenfv(ctx->Exec, ( n[1].e, n[2].e, params ));
}
break;
case OPCODE_TEXPARAMETER:
params[1] = n[4].f;
params[2] = n[5].f;
params[3] = n[6].f;
- (*ctx->Exec->TexParameterfv)( n[1].e, n[2].e, params );
+ CALL_TexParameterfv(ctx->Exec, ( n[1].e, n[2].e, params ));
}
break;
case OPCODE_TEX_IMAGE1D:
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->TexImage1D)(
+ CALL_TexImage1D(ctx->Exec, (
n[1].e, /* target */
n[2].i, /* level */
n[3].i, /* components */
n[5].e, /* border */
n[6].e, /* format */
n[7].e, /* type */
- n[8].data );
+ n[8].data ));
ctx->Unpack = save; /* restore */
}
break;
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->TexImage2D)(
+ CALL_TexImage2D(ctx->Exec, (
n[1].e, /* target */
n[2].i, /* level */
n[3].i, /* components */
n[6].e, /* border */
n[7].e, /* format */
n[8].e, /* type */
- n[9].data );
+ n[9].data ));
ctx->Unpack = save; /* restore */
}
break;
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->TexImage3D)(
+ CALL_TexImage3D(ctx->Exec, (
n[1].e, /* target */
n[2].i, /* level */
n[3].i, /* components */
n[7].e, /* border */
n[8].e, /* format */
n[9].e, /* type */
- n[10].data );
+ n[10].data ));
ctx->Unpack = save; /* restore */
}
break;
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->TexSubImage1D)( n[1].e, n[2].i, n[3].i,
+ CALL_TexSubImage1D(ctx->Exec, ( n[1].e, n[2].i, n[3].i,
n[4].i, n[5].e,
- n[6].e, n[7].data );
+ n[6].e, n[7].data ));
ctx->Unpack = save; /* restore */
}
break;
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->TexSubImage2D)( n[1].e, n[2].i, n[3].i,
+ CALL_TexSubImage2D(ctx->Exec, ( n[1].e, n[2].i, n[3].i,
n[4].i, n[5].e,
- n[6].i, n[7].e, n[8].e, n[9].data );
+ n[6].i, n[7].e, n[8].e, n[9].data ));
ctx->Unpack = save; /* restore */
}
break;
{
const struct gl_pixelstore_attrib save = ctx->Unpack;
ctx->Unpack = ctx->DefaultPacking;
- (*ctx->Exec->TexSubImage3D)( n[1].e, n[2].i, n[3].i,
+ CALL_TexSubImage3D(ctx->Exec, ( n[1].e, n[2].i, n[3].i,
n[4].i, n[5].i, n[6].i, n[7].i,
n[8].i, n[9].e, n[10].e,
- n[11].data );
+ n[11].data ));
ctx->Unpack = save; /* restore */
}
break;
case OPCODE_TRANSLATE:
- (*ctx->Exec->Translatef)( n[1].f, n[2].f, n[3].f );
+ CALL_Translatef(ctx->Exec, ( n[1].f, n[2].f, n[3].f ));
break;
case OPCODE_VIEWPORT:
- (*ctx->Exec->Viewport)(n[1].i, n[2].i,
- (GLsizei) n[3].i, (GLsizei) n[4].i);
+ CALL_Viewport(ctx->Exec, (n[1].i, n[2].i,
+ (GLsizei) n[3].i, (GLsizei) n[4].i));
break;
case OPCODE_WINDOW_POS:
- (*ctx->Exec->WindowPos4fMESA)( n[1].f, n[2].f, n[3].f, n[4].f );
+ CALL_WindowPos4fMESA(ctx->Exec, ( n[1].f, n[2].f, n[3].f, n[4].f ));
break;
case OPCODE_ACTIVE_TEXTURE: /* GL_ARB_multitexture */
- (*ctx->Exec->ActiveTextureARB)( n[1].e );
+ CALL_ActiveTextureARB(ctx->Exec, ( n[1].e ));
break;
case OPCODE_PIXEL_TEXGEN_SGIX: /* GL_SGIX_pixel_texture */
- (*ctx->Exec->PixelTexGenSGIX)( n[1].e );
+ CALL_PixelTexGenSGIX(ctx->Exec, ( n[1].e ));
break;
case OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS: /* GL_SGIS_pixel_texture */
- (*ctx->Exec->PixelTexGenParameteriSGIS)( n[1].e, n[2].i );
+ CALL_PixelTexGenParameteriSGIS(ctx->Exec, ( n[1].e, n[2].i ));
break;
case OPCODE_COMPRESSED_TEX_IMAGE_1D: /* GL_ARB_texture_compression */
- (*ctx->Exec->CompressedTexImage1DARB)(n[1].e, n[2].i, n[3].e,
- n[4].i, n[5].i, n[6].i, n[7].data);
+ CALL_CompressedTexImage1DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
+ n[4].i, n[5].i, n[6].i, n[7].data));
break;
case OPCODE_COMPRESSED_TEX_IMAGE_2D: /* GL_ARB_texture_compression */
- (*ctx->Exec->CompressedTexImage2DARB)(n[1].e, n[2].i, n[3].e,
- n[4].i, n[5].i, n[6].i, n[7].i, n[8].data);
+ CALL_CompressedTexImage2DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
+ n[4].i, n[5].i, n[6].i, n[7].i, n[8].data));
break;
case OPCODE_COMPRESSED_TEX_IMAGE_3D: /* GL_ARB_texture_compression */
- (*ctx->Exec->CompressedTexImage3DARB)(n[1].e, n[2].i, n[3].e,
- n[4].i, n[5].i, n[6].i, n[7].i, n[8].i, n[9].data);
+ CALL_CompressedTexImage3DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
+ n[4].i, n[5].i, n[6].i, n[7].i, n[8].i, n[9].data));
break;
case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D: /* GL_ARB_texture_compress */
- (*ctx->Exec->CompressedTexSubImage1DARB)(n[1].e, n[2].i, n[3].i,
- n[4].i, n[5].e, n[6].i, n[7].data);
+ CALL_CompressedTexSubImage1DARB(ctx->Exec, (n[1].e, n[2].i, n[3].i,
+ n[4].i, n[5].e, n[6].i, n[7].data));
break;
case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D: /* GL_ARB_texture_compress */
- (*ctx->Exec->CompressedTexSubImage2DARB)(n[1].e, n[2].i, n[3].i,
- n[4].i, n[5].i, n[6].i, n[7].e, n[8].i, n[9].data);
+ CALL_CompressedTexSubImage2DARB(ctx->Exec, (n[1].e, n[2].i, n[3].i,
+ n[4].i, n[5].i, n[6].i, n[7].e, n[8].i, n[9].data));
break;
case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D: /* GL_ARB_texture_compress */
- (*ctx->Exec->CompressedTexSubImage3DARB)(n[1].e, n[2].i, n[3].i,
+ CALL_CompressedTexSubImage3DARB(ctx->Exec, (n[1].e, n[2].i, n[3].i,
n[4].i, n[5].i, n[6].i, n[7].i, n[8].i,
- n[9].e, n[10].i, n[11].data);
+ n[9].e, n[10].i, n[11].data));
break;
case OPCODE_SAMPLE_COVERAGE: /* GL_ARB_multisample */
- (*ctx->Exec->SampleCoverageARB)(n[1].f, n[2].b);
+ CALL_SampleCoverageARB(ctx->Exec, (n[1].f, n[2].b));
break;
case OPCODE_WINDOW_POS_ARB: /* GL_ARB_window_pos */
- (*ctx->Exec->WindowPos3fMESA)( n[1].f, n[2].f, n[3].f );
+ CALL_WindowPos3fMESA(ctx->Exec, ( n[1].f, n[2].f, n[3].f ));
break;
#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
case OPCODE_BIND_PROGRAM_NV: /* GL_NV_vertex_program */
- (*ctx->Exec->BindProgramNV)( n[1].e, n[2].ui );
+ CALL_BindProgramNV(ctx->Exec, ( n[1].e, n[2].ui ));
break;
#endif
#if FEATURE_NV_vertex_program
v[1] = n[4].f;
v[2] = n[5].f;
v[3] = n[6].f;
- (*ctx->Exec->ExecuteProgramNV)(n[1].e, n[2].ui, v);
+ CALL_ExecuteProgramNV(ctx->Exec, (n[1].e, n[2].ui, v));
}
break;
case OPCODE_REQUEST_RESIDENT_PROGRAMS_NV:
- (*ctx->Exec->RequestResidentProgramsNV)(n[1].ui,
- (GLuint *) n[2].data);
+ CALL_RequestResidentProgramsNV(ctx->Exec, (n[1].ui,
+ (GLuint *) n[2].data));
break;
case OPCODE_LOAD_PROGRAM_NV:
- (*ctx->Exec->LoadProgramNV)(n[1].e, n[2].ui, n[3].i,
- (const GLubyte *) n[4].data);
+ CALL_LoadProgramNV(ctx->Exec, (n[1].e, n[2].ui, n[3].i,
+ (const GLubyte *) n[4].data));
break;
case OPCODE_PROGRAM_PARAMETER4F_NV:
- (*ctx->Exec->ProgramParameter4fNV)(n[1].e, n[2].ui, n[3].f,
- n[4].f, n[5].f, n[6].f);
+ CALL_ProgramParameter4fNV(ctx->Exec, (n[1].e, n[2].ui, n[3].f,
+ n[4].f, n[5].f, n[6].f));
break;
case OPCODE_TRACK_MATRIX_NV:
- (*ctx->Exec->TrackMatrixNV)(n[1].e, n[2].ui, n[3].e, n[4].e);
+ CALL_TrackMatrixNV(ctx->Exec, (n[1].e, n[2].ui, n[3].e, n[4].e));
break;
#endif
#if FEATURE_NV_fragment_program
case OPCODE_PROGRAM_LOCAL_PARAMETER_ARB:
- (*ctx->Exec->ProgramLocalParameter4fARB)(n[1].e, n[2].ui, n[3].f,
- n[4].f, n[5].f, n[6].f);
+ CALL_ProgramLocalParameter4fARB(ctx->Exec, (n[1].e, n[2].ui, n[3].f,
+ n[4].f, n[5].f, n[6].f));
break;
case OPCODE_PROGRAM_NAMED_PARAMETER_NV:
- (*ctx->Exec->ProgramNamedParameter4fNV)(n[1].ui, n[2].i,
+ CALL_ProgramNamedParameter4fNV(ctx->Exec, (n[1].ui, n[2].i,
(const GLubyte *) n[3].data,
- n[4].f, n[5].f, n[6].f, n[7].f);
+ n[4].f, n[5].f, n[6].f, n[7].f));
break;
#endif
case OPCODE_ACTIVE_STENCIL_FACE_EXT:
- (*ctx->Exec->ActiveStencilFaceEXT)(n[1].e);
+ CALL_ActiveStencilFaceEXT(ctx->Exec, (n[1].e));
break;
case OPCODE_DEPTH_BOUNDS_EXT:
- (*ctx->Exec->DepthBoundsEXT)(n[1].f, n[2].f);
+ CALL_DepthBoundsEXT(ctx->Exec, (n[1].f, n[2].f));
break;
#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
case OPCODE_PROGRAM_STRING_ARB:
- (*ctx->Exec->ProgramStringARB)(n[1].e, n[2].e, n[3].i, n[4].data);
+ CALL_ProgramStringARB(ctx->Exec, (n[1].e, n[2].e, n[3].i, n[4].data));
break;
case OPCODE_PROGRAM_ENV_PARAMETER_ARB:
- (*ctx->Exec->ProgramEnvParameter4fARB)(n[1].e, n[2].ui, n[3].f,
- n[4].f, n[5].f, n[6].f);
+ CALL_ProgramEnvParameter4fARB(ctx->Exec, (n[1].e, n[2].ui, n[3].f,
+ n[4].f, n[5].f, n[6].f));
break;
#endif
#if FEATURE_ARB_occlusion_query
case OPCODE_BEGIN_QUERY_ARB:
- ctx->Exec->BeginQueryARB(n[1].e, n[2].ui);
+ CALL_BeginQueryARB(ctx->Exec, (n[1].e, n[2].ui));
break;
case OPCODE_END_QUERY_ARB:
- ctx->Exec->EndQueryARB(n[1].e);
+ CALL_EndQueryARB(ctx->Exec, (n[1].e));
break;
#endif
case OPCODE_DRAW_BUFFERS_ARB:
GLint i, count = MIN2(n[1].i, MAX_DRAW_BUFFERS);
for (i = 0; i < count; i++)
buffers[i] = n[2 + i].e;
- ctx->Exec->DrawBuffersARB(n[1].i, buffers);
+ CALL_DrawBuffersARB(ctx->Exec, (n[1].i, buffers));
}
break;
#if FEATURE_ATI_fragment_shader
case OPCODE_BIND_FRAGMENT_SHADER_ATI:
- ctx->Exec->BindFragmentShaderATI(n[1].i);
+ CALL_BindFragmentShaderATI(ctx->Exec, (n[1].i));
break;
case OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI:
{
for (i = 0; i < 4; i++)
values[i] = n[1+i].f;
- ctx->Exec->SetFragmentShaderConstantATI(dst, values);
+ CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, values));
}
break;
#endif
case OPCODE_ATTR_1F_NV:
- (*ctx->Exec->VertexAttrib1fNV)(n[1].e, n[2].f);
+ CALL_VertexAttrib1fNV(ctx->Exec, (n[1].e, n[2].f));
break;
case OPCODE_ATTR_2F_NV:
/* Really shouldn't have to do this - the Node structure
* matter more.
*/
if (sizeof(Node)==sizeof(GLfloat))
- (*ctx->Exec->VertexAttrib2fvNV)(n[1].e, &n[2].f);
+ CALL_VertexAttrib2fvNV(ctx->Exec, (n[1].e, &n[2].f));
else
- (*ctx->Exec->VertexAttrib2fNV)(n[1].e, n[2].f, n[3].f);
+ CALL_VertexAttrib2fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f));
break;
case OPCODE_ATTR_3F_NV:
if (sizeof(Node)==sizeof(GLfloat))
- (*ctx->Exec->VertexAttrib3fvNV)(n[1].e, &n[2].f);
+ CALL_VertexAttrib3fvNV(ctx->Exec, (n[1].e, &n[2].f));
else
- (*ctx->Exec->VertexAttrib3fNV)(n[1].e, n[2].f, n[3].f,
- n[4].f);
+ CALL_VertexAttrib3fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f,
+ n[4].f));
break;
case OPCODE_ATTR_4F_NV:
if (sizeof(Node)==sizeof(GLfloat))
- (*ctx->Exec->VertexAttrib4fvNV)(n[1].e, &n[2].f);
+ CALL_VertexAttrib4fvNV(ctx->Exec, (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);
+ CALL_VertexAttrib4fNV(ctx->Exec, (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);
+ CALL_VertexAttrib1fARB(ctx->Exec, (n[1].e, n[2].f));
break;
case OPCODE_ATTR_2F_ARB:
/* Really shouldn't have to do this - the Node structure
* matter more.
*/
if (sizeof(Node)==sizeof(GLfloat))
- (*ctx->Exec->VertexAttrib2fvARB)(n[1].e, &n[2].f);
+ CALL_VertexAttrib2fvARB(ctx->Exec, (n[1].e, &n[2].f));
else
- (*ctx->Exec->VertexAttrib2fARB)(n[1].e, n[2].f, n[3].f);
+ CALL_VertexAttrib2fARB(ctx->Exec, (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);
+ CALL_VertexAttrib3fvARB(ctx->Exec, (n[1].e, &n[2].f));
else
- (*ctx->Exec->VertexAttrib3fARB)(n[1].e, n[2].f, n[3].f,
- n[4].f);
+ CALL_VertexAttrib3fARB(ctx->Exec, (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);
+ CALL_VertexAttrib4fvARB(ctx->Exec, (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);
+ CALL_VertexAttrib4fARB(ctx->Exec, (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);
+ CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, &n[3].f));
else {
GLfloat f[4];
f[0] = n[3].f;
f[1] = n[4].f;
f[2] = n[5].f;
f[3] = n[6].f;
- (*ctx->Exec->Materialfv)(n[1].e, n[2].e, f);
+ CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, f));
}
break;
case OPCODE_INDEX:
- (*ctx->Exec->Indexi)(n[1].i);
+ CALL_Indexi(ctx->Exec, (n[1].i));
break;
case OPCODE_EDGEFLAG:
- (*ctx->Exec->EdgeFlag)(n[1].b);
+ CALL_EdgeFlag(ctx->Exec, (n[1].b));
break;
case OPCODE_BEGIN:
- (*ctx->Exec->Begin)(n[1].e);
+ CALL_Begin(ctx->Exec, (n[1].e));
break;
case OPCODE_END:
- (*ctx->Exec->End)();
+ CALL_End(ctx->Exec, ());
break;
case OPCODE_RECTF:
- (*ctx->Exec->Rectf)(n[1].f, n[2].f, n[3].f, n[4].f);
+ CALL_Rectf(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
break;
case OPCODE_EVAL_C1:
- (*ctx->Exec->EvalCoord1f)(n[1].f);
+ CALL_EvalCoord1f(ctx->Exec, (n[1].f));
break;
case OPCODE_EVAL_C2:
- (*ctx->Exec->EvalCoord2f)(n[1].f, n[2].f);
+ CALL_EvalCoord2f(ctx->Exec, (n[1].f, n[2].f));
break;
case OPCODE_EVAL_P1:
- (*ctx->Exec->EvalPoint1)(n[1].i);
+ CALL_EvalPoint1(ctx->Exec, (n[1].i));
break;
case OPCODE_EVAL_P2:
- (*ctx->Exec->EvalPoint2)(n[1].i, n[2].i);
+ CALL_EvalPoint2(ctx->Exec, (n[1].i, n[2].i));
break;
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->Finish();
+ CALL_Finish(ctx->Exec, ());
}
static void GLAPIENTRY exec_Flush( void )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->Flush( );
+ CALL_Flush(ctx->Exec, ( ));
}
static void GLAPIENTRY exec_GetBooleanv( GLenum pname, GLboolean *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetBooleanv( pname, params );
+ CALL_GetBooleanv(ctx->Exec, ( pname, params ));
}
static void GLAPIENTRY exec_GetClipPlane( GLenum plane, GLdouble *equation )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetClipPlane( plane, equation );
+ CALL_GetClipPlane(ctx->Exec, ( plane, equation ));
}
static void GLAPIENTRY exec_GetDoublev( GLenum pname, GLdouble *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetDoublev( pname, params );
+ CALL_GetDoublev(ctx->Exec, ( pname, params ));
}
static GLenum GLAPIENTRY exec_GetError( void )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- return ctx->Exec->GetError( );
+ return CALL_GetError(ctx->Exec, ( ));
}
static void GLAPIENTRY exec_GetFloatv( GLenum pname, GLfloat *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetFloatv( pname, params );
+ CALL_GetFloatv(ctx->Exec, ( pname, params ));
}
static void GLAPIENTRY exec_GetIntegerv( GLenum pname, GLint *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetIntegerv( pname, params );
+ CALL_GetIntegerv(ctx->Exec, ( pname, params ));
}
static void GLAPIENTRY exec_GetLightfv( GLenum light, GLenum pname, GLfloat *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetLightfv( light, pname, params );
+ CALL_GetLightfv(ctx->Exec, ( light, pname, params ));
}
static void GLAPIENTRY exec_GetLightiv( GLenum light, GLenum pname, GLint *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetLightiv( light, pname, params );
+ CALL_GetLightiv(ctx->Exec, ( light, pname, params ));
}
static void GLAPIENTRY exec_GetMapdv( GLenum target, GLenum query, GLdouble *v )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetMapdv( target, query, v );
+ CALL_GetMapdv(ctx->Exec, ( target, query, v ));
}
static void GLAPIENTRY exec_GetMapfv( GLenum target, GLenum query, GLfloat *v )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetMapfv( target, query, v );
+ CALL_GetMapfv(ctx->Exec, ( target, query, v ));
}
static void GLAPIENTRY exec_GetMapiv( GLenum target, GLenum query, GLint *v )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetMapiv( target, query, v );
+ CALL_GetMapiv(ctx->Exec, ( target, query, v ));
}
static void GLAPIENTRY exec_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetMaterialfv( face, pname, params );
+ CALL_GetMaterialfv(ctx->Exec, ( face, pname, params ));
}
static void GLAPIENTRY exec_GetMaterialiv( GLenum face, GLenum pname, GLint *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetMaterialiv( face, pname, params );
+ CALL_GetMaterialiv(ctx->Exec, ( face, pname, params ));
}
static void GLAPIENTRY exec_GetPixelMapfv( GLenum map, GLfloat *values )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetPixelMapfv( map, values );
+ CALL_GetPixelMapfv(ctx->Exec, ( map, values ));
}
static void GLAPIENTRY exec_GetPixelMapuiv( GLenum map, GLuint *values )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetPixelMapuiv( map, values );
+ CALL_GetPixelMapuiv(ctx->Exec, ( map, values ));
}
static void GLAPIENTRY exec_GetPixelMapusv( GLenum map, GLushort *values )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetPixelMapusv( map, values );
+ CALL_GetPixelMapusv(ctx->Exec, ( map, values ));
}
static void GLAPIENTRY exec_GetPolygonStipple( GLubyte *dest )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetPolygonStipple( dest );
+ CALL_GetPolygonStipple(ctx->Exec, ( dest ));
}
static const GLubyte * GLAPIENTRY exec_GetString( GLenum name )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- return ctx->Exec->GetString( name );
+ return CALL_GetString(ctx->Exec, ( name ));
}
static void GLAPIENTRY exec_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetTexEnvfv( target, pname, params );
+ CALL_GetTexEnvfv(ctx->Exec, ( target, pname, params ));
}
static void GLAPIENTRY exec_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetTexEnviv( target, pname, params );
+ CALL_GetTexEnviv(ctx->Exec, ( target, pname, params ));
}
static void GLAPIENTRY exec_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetTexGendv( coord, pname, params );
+ CALL_GetTexGendv(ctx->Exec, ( coord, pname, params ));
}
static void GLAPIENTRY exec_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetTexGenfv( coord, pname, params );
+ CALL_GetTexGenfv(ctx->Exec, ( coord, pname, params ));
}
static void GLAPIENTRY exec_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetTexGeniv( coord, pname, params );
+ CALL_GetTexGeniv(ctx->Exec, ( coord, pname, params ));
}
static void GLAPIENTRY exec_GetTexImage( GLenum target, GLint level, GLenum format,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetTexImage( target, level, format, type, pixels );
+ CALL_GetTexImage(ctx->Exec, ( target, level, format, type, pixels ));
}
static void GLAPIENTRY exec_GetTexLevelParameterfv( GLenum target, GLint level,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetTexLevelParameterfv( target, level, pname, params );
+ CALL_GetTexLevelParameterfv(ctx->Exec, ( target, level, pname, params ));
}
static void GLAPIENTRY exec_GetTexLevelParameteriv( GLenum target, GLint level,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetTexLevelParameteriv( target, level, pname, params );
+ CALL_GetTexLevelParameteriv(ctx->Exec, ( target, level, pname, params ));
}
static void GLAPIENTRY exec_GetTexParameterfv( GLenum target, GLenum pname,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetTexParameterfv( target, pname, params );
+ CALL_GetTexParameterfv(ctx->Exec, ( target, pname, params ));
}
static void GLAPIENTRY exec_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetTexParameteriv( target, pname, params );
+ CALL_GetTexParameteriv(ctx->Exec, ( target, pname, params ));
}
static GLboolean GLAPIENTRY exec_IsEnabled( GLenum cap )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- return ctx->Exec->IsEnabled( cap );
+ return CALL_IsEnabled(ctx->Exec, ( cap ));
}
static void GLAPIENTRY exec_PixelStoref( GLenum pname, GLfloat param )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->PixelStoref( pname, param );
+ CALL_PixelStoref(ctx->Exec, ( pname, param ));
}
static void GLAPIENTRY exec_PixelStorei( GLenum pname, GLint param )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->PixelStorei( pname, param );
+ CALL_PixelStorei(ctx->Exec, ( pname, param ));
}
static void GLAPIENTRY exec_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->ReadPixels( x, y, width, height, format, type, pixels );
+ CALL_ReadPixels(ctx->Exec, ( x, y, width, height, format, type, pixels ));
}
static GLint GLAPIENTRY exec_RenderMode( GLenum mode )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- return ctx->Exec->RenderMode( mode );
+ return CALL_RenderMode(ctx->Exec, ( mode ));
}
static void GLAPIENTRY exec_FeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->FeedbackBuffer( size, type, buffer );
+ CALL_FeedbackBuffer(ctx->Exec, ( size, type, buffer ));
}
static void GLAPIENTRY exec_SelectBuffer( GLsizei size, GLuint *buffer )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->SelectBuffer( size, buffer );
+ CALL_SelectBuffer(ctx->Exec, ( size, buffer ));
}
static GLboolean GLAPIENTRY exec_AreTexturesResident(GLsizei n, const GLuint *texName,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- return ctx->Exec->AreTexturesResident( n, texName, residences);
+ return CALL_AreTexturesResident(ctx->Exec, ( n, texName, residences));
}
static void GLAPIENTRY exec_ColorPointer(GLint size, GLenum type, GLsizei stride,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->ColorPointer( size, type, stride, ptr);
+ CALL_ColorPointer(ctx->Exec, ( size, type, stride, ptr));
}
static void GLAPIENTRY exec_DeleteTextures( GLsizei n, const GLuint *texName)
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->DeleteTextures( n, texName);
+ CALL_DeleteTextures(ctx->Exec, ( n, texName));
}
static void GLAPIENTRY exec_DisableClientState( GLenum cap )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->DisableClientState( cap );
+ CALL_DisableClientState(ctx->Exec, ( cap ));
}
static void GLAPIENTRY exec_EdgeFlagPointer(GLsizei stride, const GLvoid *vptr)
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->EdgeFlagPointer( stride, vptr);
+ CALL_EdgeFlagPointer(ctx->Exec, ( stride, vptr));
}
static void GLAPIENTRY exec_EnableClientState( GLenum cap )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->EnableClientState( cap );
+ CALL_EnableClientState(ctx->Exec, ( cap ));
}
static void GLAPIENTRY exec_GenTextures( GLsizei n, GLuint *texName )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GenTextures( n, texName );
+ CALL_GenTextures(ctx->Exec, ( n, texName ));
}
static void GLAPIENTRY exec_GetPointerv( GLenum pname, GLvoid **params )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetPointerv( pname, params );
+ CALL_GetPointerv(ctx->Exec, ( pname, params ));
}
static void GLAPIENTRY exec_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->IndexPointer( type, stride, ptr);
+ CALL_IndexPointer(ctx->Exec, ( type, stride, ptr));
}
static void GLAPIENTRY exec_InterleavedArrays(GLenum format, GLsizei stride,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->InterleavedArrays( format, stride, pointer);
+ CALL_InterleavedArrays(ctx->Exec, ( format, stride, pointer));
}
static GLboolean GLAPIENTRY exec_IsTexture( GLuint texture )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- return ctx->Exec->IsTexture( texture );
+ return CALL_IsTexture(ctx->Exec, ( texture ));
}
static void GLAPIENTRY exec_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->NormalPointer( type, stride, ptr );
+ CALL_NormalPointer(ctx->Exec, ( type, stride, ptr ));
}
static void GLAPIENTRY exec_PopClientAttrib(void)
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->PopClientAttrib();
+ CALL_PopClientAttrib(ctx->Exec, ());
}
static void GLAPIENTRY exec_PushClientAttrib(GLbitfield mask)
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->PushClientAttrib( mask);
+ CALL_PushClientAttrib(ctx->Exec, ( mask));
}
static void GLAPIENTRY exec_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->TexCoordPointer( size, type, stride, ptr);
+ CALL_TexCoordPointer(ctx->Exec, ( size, type, stride, ptr));
}
static void GLAPIENTRY exec_GetCompressedTexImageARB(GLenum target, GLint level,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetCompressedTexImageARB( target, level, img);
+ CALL_GetCompressedTexImageARB(ctx->Exec, ( target, level, img));
}
static void GLAPIENTRY exec_VertexPointer(GLint size, GLenum type, GLsizei stride,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->VertexPointer( size, type, stride, ptr);
+ CALL_VertexPointer(ctx->Exec, ( size, type, stride, ptr));
}
static void GLAPIENTRY exec_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->CopyConvolutionFilter1D( target, internalFormat, x, y, width);
+ CALL_CopyConvolutionFilter1D(ctx->Exec, ( target, internalFormat, x, y, width));
}
static void GLAPIENTRY exec_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->CopyConvolutionFilter2D( target, internalFormat, x, y, width,
- height);
+ CALL_CopyConvolutionFilter2D(ctx->Exec, ( target, internalFormat, x, y, width,
+ height));
}
static void GLAPIENTRY exec_GetColorTable( GLenum target, GLenum format,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetColorTable( target, format, type, data );
+ CALL_GetColorTable(ctx->Exec, ( target, format, type, data ));
}
static void GLAPIENTRY exec_GetColorTableParameterfv( GLenum target, GLenum pname,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetColorTableParameterfv( target, pname, params );
+ CALL_GetColorTableParameterfv(ctx->Exec, ( target, pname, params ));
}
static void GLAPIENTRY exec_GetColorTableParameteriv( GLenum target, GLenum pname,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetColorTableParameteriv( target, pname, params );
+ CALL_GetColorTableParameteriv(ctx->Exec, ( target, pname, params ));
}
static void GLAPIENTRY exec_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetConvolutionFilter( target, format, type, image);
+ CALL_GetConvolutionFilter(ctx->Exec, ( target, format, type, image));
}
static void GLAPIENTRY exec_GetConvolutionParameterfv(GLenum target, GLenum pname,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetConvolutionParameterfv( target, pname, params);
+ CALL_GetConvolutionParameterfv(ctx->Exec, ( target, pname, params));
}
static void GLAPIENTRY exec_GetConvolutionParameteriv(GLenum target, GLenum pname,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetConvolutionParameteriv( target, pname, params);
+ CALL_GetConvolutionParameteriv(ctx->Exec, ( target, pname, params));
}
static void GLAPIENTRY exec_GetHistogram(GLenum target, GLboolean reset, GLenum format,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetHistogram( target, reset, format, type, values);
+ CALL_GetHistogram(ctx->Exec, ( target, reset, format, type, values));
}
static void GLAPIENTRY exec_GetHistogramParameterfv(GLenum target, GLenum pname,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetHistogramParameterfv( target, pname, params);
+ CALL_GetHistogramParameterfv(ctx->Exec, ( target, pname, params));
}
static void GLAPIENTRY exec_GetHistogramParameteriv(GLenum target, GLenum pname,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetHistogramParameteriv( target, pname, params);
+ CALL_GetHistogramParameteriv(ctx->Exec, ( target, pname, params));
}
static void GLAPIENTRY exec_GetMinmax(GLenum target, GLboolean reset, GLenum format,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetMinmax( target, reset, format, type, values);
+ CALL_GetMinmax(ctx->Exec, ( target, reset, format, type, values));
}
static void GLAPIENTRY exec_GetMinmaxParameterfv(GLenum target, GLenum pname,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetMinmaxParameterfv( target, pname, params);
+ CALL_GetMinmaxParameterfv(ctx->Exec, ( target, pname, params));
}
static void GLAPIENTRY exec_GetMinmaxParameteriv(GLenum target, GLenum pname,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetMinmaxParameteriv( target, pname, params);
+ CALL_GetMinmaxParameteriv(ctx->Exec, ( target, pname, params));
}
static void GLAPIENTRY exec_GetSeparableFilter(GLenum target, GLenum format, GLenum type,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetSeparableFilter( target, format, type, row, column, span);
+ CALL_GetSeparableFilter(ctx->Exec, ( target, format, type, row, column, span));
}
static void GLAPIENTRY exec_SeparableFilter2D(GLenum target, GLenum internalFormat,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->SeparableFilter2D( target, internalFormat, width, height, format,
- type, row, column);
+ CALL_SeparableFilter2D(ctx->Exec, ( target, internalFormat, width, height, format,
+ type, row, column));
}
static void GLAPIENTRY exec_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value)
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetPixelTexGenParameterivSGIS( target, value);
+ CALL_GetPixelTexGenParameterivSGIS(ctx->Exec, ( target, value));
}
static void GLAPIENTRY exec_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value)
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->GetPixelTexGenParameterfvSGIS( target, value);
+ CALL_GetPixelTexGenParameterfvSGIS(ctx->Exec, ( target, value));
}
static void GLAPIENTRY exec_ColorPointerEXT(GLint size, GLenum type, GLsizei stride,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->ColorPointerEXT( size, type, stride, count, ptr);
+ CALL_ColorPointerEXT(ctx->Exec, ( size, type, stride, count, ptr));
}
static void GLAPIENTRY exec_EdgeFlagPointerEXT(GLsizei stride, GLsizei count,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->EdgeFlagPointerEXT( stride, count, ptr);
+ CALL_EdgeFlagPointerEXT(ctx->Exec, ( stride, count, ptr));
}
static void GLAPIENTRY exec_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->IndexPointerEXT( type, stride, count, ptr);
+ CALL_IndexPointerEXT(ctx->Exec, ( type, stride, count, ptr));
}
static void GLAPIENTRY exec_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->NormalPointerEXT( type, stride, count, ptr);
+ CALL_NormalPointerEXT(ctx->Exec, ( type, stride, count, ptr));
}
static void GLAPIENTRY exec_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->TexCoordPointerEXT( size, type, stride, count, ptr);
+ CALL_TexCoordPointerEXT(ctx->Exec, ( size, type, stride, count, ptr));
}
static void GLAPIENTRY exec_VertexPointerEXT(GLint size, GLenum type, GLsizei stride,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->VertexPointerEXT( size, type, stride, count, ptr);
+ CALL_VertexPointerEXT(ctx->Exec, ( size, type, stride, count, ptr));
}
static void GLAPIENTRY exec_LockArraysEXT(GLint first, GLsizei count)
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->LockArraysEXT( first, count);
+ CALL_LockArraysEXT(ctx->Exec, ( first, count));
}
static void GLAPIENTRY exec_UnlockArraysEXT( void )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->UnlockArraysEXT( );
+ CALL_UnlockArraysEXT(ctx->Exec, ( ));
}
static void GLAPIENTRY exec_ClientActiveTextureARB( GLenum target )
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->ClientActiveTextureARB(target);
+ CALL_ClientActiveTextureARB(ctx->Exec, (target));
}
static void GLAPIENTRY exec_SecondaryColorPointerEXT(GLint size, GLenum type,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->SecondaryColorPointerEXT( size, type, stride, ptr);
+ CALL_SecondaryColorPointerEXT(ctx->Exec, ( size, type, stride, ptr));
}
static void GLAPIENTRY exec_FogCoordPointerEXT(GLenum type, GLsizei stride,
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->FogCoordPointerEXT( type, stride, ptr);
+ CALL_FogCoordPointerEXT(ctx->Exec, ( type, stride, ptr));
}
/* GL_EXT_multi_draw_arrays */
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->MultiDrawArraysEXT( mode, first, count, primcount );
+ CALL_MultiDrawArraysEXT(ctx->Exec, ( mode, first, count, primcount ));
}
/* GL_EXT_multi_draw_arrays */
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->MultiDrawElementsEXT(mode, count, type, indices, primcount);
+ CALL_MultiDrawElementsEXT(ctx->Exec, (mode, count, type, indices, primcount));
}
/* GL_IBM_multimode_draw_arrays */
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->MultiModeDrawArraysIBM(mode, first, count, primcount, modestride);
+ CALL_MultiModeDrawArraysIBM(ctx->Exec, (mode, first, count, primcount, modestride));
}
/* GL_IBM_multimode_draw_arrays */
{
GET_CURRENT_CONTEXT(ctx);
FLUSH_VERTICES(ctx, 0);
- ctx->Exec->MultiModeDrawElementsIBM(mode, count, type, indices, primcount,
- modestride);
+ CALL_MultiModeDrawElementsIBM(ctx->Exec, (mode, count, type, indices, primcount,
+ modestride));
}
_mesa_loopback_init_api_table( table );
/* GL 1.0 */
- table->Accum = save_Accum;
- table->AlphaFunc = save_AlphaFunc;
- table->Bitmap = save_Bitmap;
- table->BlendFunc = _mesa_BlendFunc; /* loops-back to BlendFuncSeparate */
- table->CallList = _mesa_save_CallList;
- table->CallLists = _mesa_save_CallLists;
- table->Clear = save_Clear;
- table->ClearAccum = save_ClearAccum;
- table->ClearColor = save_ClearColor;
- table->ClearDepth = save_ClearDepth;
- table->ClearIndex = save_ClearIndex;
- table->ClearStencil = save_ClearStencil;
- table->ClipPlane = save_ClipPlane;
- table->ColorMask = save_ColorMask;
- table->ColorMaterial = save_ColorMaterial;
- table->CopyPixels = save_CopyPixels;
- table->CullFace = save_CullFace;
- table->DeleteLists = _mesa_DeleteLists;
- table->DepthFunc = save_DepthFunc;
- table->DepthMask = save_DepthMask;
- table->DepthRange = save_DepthRange;
- table->Disable = save_Disable;
- table->DrawBuffer = save_DrawBuffer;
- table->DrawPixels = save_DrawPixels;
- table->Enable = save_Enable;
- table->EndList = _mesa_EndList;
- table->EvalMesh1 = _mesa_save_EvalMesh1;
- table->EvalMesh2 = _mesa_save_EvalMesh2;
- table->Finish = exec_Finish;
- table->Flush = exec_Flush;
- table->Fogf = save_Fogf;
- table->Fogfv = save_Fogfv;
- table->Fogi = save_Fogi;
- table->Fogiv = save_Fogiv;
- table->FrontFace = save_FrontFace;
- table->Frustum = save_Frustum;
- table->GenLists = _mesa_GenLists;
- table->GetBooleanv = exec_GetBooleanv;
- table->GetClipPlane = exec_GetClipPlane;
- table->GetDoublev = exec_GetDoublev;
- table->GetError = exec_GetError;
- table->GetFloatv = exec_GetFloatv;
- table->GetIntegerv = exec_GetIntegerv;
- table->GetLightfv = exec_GetLightfv;
- table->GetLightiv = exec_GetLightiv;
- table->GetMapdv = exec_GetMapdv;
- table->GetMapfv = exec_GetMapfv;
- table->GetMapiv = exec_GetMapiv;
- table->GetMaterialfv = exec_GetMaterialfv;
- table->GetMaterialiv = exec_GetMaterialiv;
- table->GetPixelMapfv = exec_GetPixelMapfv;
- table->GetPixelMapuiv = exec_GetPixelMapuiv;
- table->GetPixelMapusv = exec_GetPixelMapusv;
- table->GetPolygonStipple = exec_GetPolygonStipple;
- table->GetString = exec_GetString;
- table->GetTexEnvfv = exec_GetTexEnvfv;
- table->GetTexEnviv = exec_GetTexEnviv;
- table->GetTexGendv = exec_GetTexGendv;
- table->GetTexGenfv = exec_GetTexGenfv;
- table->GetTexGeniv = exec_GetTexGeniv;
- table->GetTexImage = exec_GetTexImage;
- table->GetTexLevelParameterfv = exec_GetTexLevelParameterfv;
- table->GetTexLevelParameteriv = exec_GetTexLevelParameteriv;
- table->GetTexParameterfv = exec_GetTexParameterfv;
- table->GetTexParameteriv = exec_GetTexParameteriv;
- table->Hint = save_Hint;
- table->IndexMask = save_IndexMask;
- table->InitNames = save_InitNames;
- table->IsEnabled = exec_IsEnabled;
- table->IsList = _mesa_IsList;
- table->LightModelf = save_LightModelf;
- table->LightModelfv = save_LightModelfv;
- table->LightModeli = save_LightModeli;
- table->LightModeliv = save_LightModeliv;
- table->Lightf = save_Lightf;
- table->Lightfv = save_Lightfv;
- table->Lighti = save_Lighti;
- table->Lightiv = save_Lightiv;
- table->LineStipple = save_LineStipple;
- table->LineWidth = save_LineWidth;
- table->ListBase = save_ListBase;
- table->LoadIdentity = save_LoadIdentity;
- table->LoadMatrixd = save_LoadMatrixd;
- table->LoadMatrixf = save_LoadMatrixf;
- table->LoadName = save_LoadName;
- table->LogicOp = save_LogicOp;
- table->Map1d = save_Map1d;
- table->Map1f = save_Map1f;
- table->Map2d = save_Map2d;
- table->Map2f = save_Map2f;
- table->MapGrid1d = save_MapGrid1d;
- table->MapGrid1f = save_MapGrid1f;
- table->MapGrid2d = save_MapGrid2d;
- table->MapGrid2f = save_MapGrid2f;
- table->MatrixMode = save_MatrixMode;
- table->MultMatrixd = save_MultMatrixd;
- table->MultMatrixf = save_MultMatrixf;
- table->NewList = save_NewList;
- table->Ortho = save_Ortho;
- table->PassThrough = save_PassThrough;
- table->PixelMapfv = save_PixelMapfv;
- table->PixelMapuiv = save_PixelMapuiv;
- table->PixelMapusv = save_PixelMapusv;
- table->PixelStoref = exec_PixelStoref;
- table->PixelStorei = exec_PixelStorei;
- table->PixelTransferf = save_PixelTransferf;
- table->PixelTransferi = save_PixelTransferi;
- table->PixelZoom = save_PixelZoom;
- table->PointSize = save_PointSize;
- table->PolygonMode = save_PolygonMode;
- table->PolygonOffset = save_PolygonOffset;
- table->PolygonStipple = save_PolygonStipple;
- table->PopAttrib = save_PopAttrib;
- table->PopMatrix = save_PopMatrix;
- table->PopName = save_PopName;
- table->PushAttrib = save_PushAttrib;
- table->PushMatrix = save_PushMatrix;
- table->PushName = save_PushName;
- table->RasterPos2d = save_RasterPos2d;
- table->RasterPos2dv = save_RasterPos2dv;
- table->RasterPos2f = save_RasterPos2f;
- table->RasterPos2fv = save_RasterPos2fv;
- table->RasterPos2i = save_RasterPos2i;
- table->RasterPos2iv = save_RasterPos2iv;
- table->RasterPos2s = save_RasterPos2s;
- table->RasterPos2sv = save_RasterPos2sv;
- table->RasterPos3d = save_RasterPos3d;
- table->RasterPos3dv = save_RasterPos3dv;
- table->RasterPos3f = save_RasterPos3f;
- table->RasterPos3fv = save_RasterPos3fv;
- table->RasterPos3i = save_RasterPos3i;
- table->RasterPos3iv = save_RasterPos3iv;
- table->RasterPos3s = save_RasterPos3s;
- table->RasterPos3sv = save_RasterPos3sv;
- table->RasterPos4d = save_RasterPos4d;
- table->RasterPos4dv = save_RasterPos4dv;
- table->RasterPos4f = save_RasterPos4f;
- table->RasterPos4fv = save_RasterPos4fv;
- table->RasterPos4i = save_RasterPos4i;
- table->RasterPos4iv = save_RasterPos4iv;
- table->RasterPos4s = save_RasterPos4s;
- table->RasterPos4sv = save_RasterPos4sv;
- table->ReadBuffer = save_ReadBuffer;
- table->ReadPixels = exec_ReadPixels;
- table->RenderMode = exec_RenderMode;
- table->Rotated = save_Rotated;
- table->Rotatef = save_Rotatef;
- table->Scaled = save_Scaled;
- table->Scalef = save_Scalef;
- table->Scissor = save_Scissor;
- table->FeedbackBuffer = exec_FeedbackBuffer;
- table->SelectBuffer = exec_SelectBuffer;
- table->ShadeModel = save_ShadeModel;
- table->StencilFunc = save_StencilFunc;
- table->StencilMask = save_StencilMask;
- table->StencilOp = save_StencilOp;
- table->TexEnvf = save_TexEnvf;
- table->TexEnvfv = save_TexEnvfv;
- table->TexEnvi = save_TexEnvi;
- table->TexEnviv = save_TexEnviv;
- table->TexGend = save_TexGend;
- table->TexGendv = save_TexGendv;
- table->TexGenf = save_TexGenf;
- table->TexGenfv = save_TexGenfv;
- table->TexGeni = save_TexGeni;
- table->TexGeniv = save_TexGeniv;
- table->TexImage1D = save_TexImage1D;
- table->TexImage2D = save_TexImage2D;
- table->TexParameterf = save_TexParameterf;
- table->TexParameterfv = save_TexParameterfv;
- table->TexParameteri = save_TexParameteri;
- table->TexParameteriv = save_TexParameteriv;
- table->Translated = save_Translated;
- table->Translatef = save_Translatef;
- table->Viewport = save_Viewport;
+ SET_Accum(table, save_Accum);
+ SET_AlphaFunc(table, save_AlphaFunc);
+ SET_Bitmap(table, save_Bitmap);
+ SET_BlendFunc(table, _mesa_BlendFunc); /* loops-back to BlendFuncSeparate */
+ SET_CallList(table, _mesa_save_CallList);
+ SET_CallLists(table, _mesa_save_CallLists);
+ SET_Clear(table, save_Clear);
+ SET_ClearAccum(table, save_ClearAccum);
+ SET_ClearColor(table, save_ClearColor);
+ SET_ClearDepth(table, save_ClearDepth);
+ SET_ClearIndex(table, save_ClearIndex);
+ SET_ClearStencil(table, save_ClearStencil);
+ SET_ClipPlane(table, save_ClipPlane);
+ SET_ColorMask(table, save_ColorMask);
+ SET_ColorMaterial(table, save_ColorMaterial);
+ SET_CopyPixels(table, save_CopyPixels);
+ SET_CullFace(table, save_CullFace);
+ SET_DeleteLists(table, _mesa_DeleteLists);
+ SET_DepthFunc(table, save_DepthFunc);
+ SET_DepthMask(table, save_DepthMask);
+ SET_DepthRange(table, save_DepthRange);
+ SET_Disable(table, save_Disable);
+ SET_DrawBuffer(table, save_DrawBuffer);
+ SET_DrawPixels(table, save_DrawPixels);
+ SET_Enable(table, save_Enable);
+ SET_EndList(table, _mesa_EndList);
+ SET_EvalMesh1(table, _mesa_save_EvalMesh1);
+ SET_EvalMesh2(table, _mesa_save_EvalMesh2);
+ SET_Finish(table, exec_Finish);
+ SET_Flush(table, exec_Flush);
+ SET_Fogf(table, save_Fogf);
+ SET_Fogfv(table, save_Fogfv);
+ SET_Fogi(table, save_Fogi);
+ SET_Fogiv(table, save_Fogiv);
+ SET_FrontFace(table, save_FrontFace);
+ SET_Frustum(table, save_Frustum);
+ SET_GenLists(table, _mesa_GenLists);
+ SET_GetBooleanv(table, exec_GetBooleanv);
+ SET_GetClipPlane(table, exec_GetClipPlane);
+ SET_GetDoublev(table, exec_GetDoublev);
+ SET_GetError(table, exec_GetError);
+ SET_GetFloatv(table, exec_GetFloatv);
+ SET_GetIntegerv(table, exec_GetIntegerv);
+ SET_GetLightfv(table, exec_GetLightfv);
+ SET_GetLightiv(table, exec_GetLightiv);
+ SET_GetMapdv(table, exec_GetMapdv);
+ SET_GetMapfv(table, exec_GetMapfv);
+ SET_GetMapiv(table, exec_GetMapiv);
+ SET_GetMaterialfv(table, exec_GetMaterialfv);
+ SET_GetMaterialiv(table, exec_GetMaterialiv);
+ SET_GetPixelMapfv(table, exec_GetPixelMapfv);
+ SET_GetPixelMapuiv(table, exec_GetPixelMapuiv);
+ SET_GetPixelMapusv(table, exec_GetPixelMapusv);
+ SET_GetPolygonStipple(table, exec_GetPolygonStipple);
+ SET_GetString(table, exec_GetString);
+ SET_GetTexEnvfv(table, exec_GetTexEnvfv);
+ SET_GetTexEnviv(table, exec_GetTexEnviv);
+ SET_GetTexGendv(table, exec_GetTexGendv);
+ SET_GetTexGenfv(table, exec_GetTexGenfv);
+ SET_GetTexGeniv(table, exec_GetTexGeniv);
+ SET_GetTexImage(table, exec_GetTexImage);
+ SET_GetTexLevelParameterfv(table, exec_GetTexLevelParameterfv);
+ SET_GetTexLevelParameteriv(table, exec_GetTexLevelParameteriv);
+ SET_GetTexParameterfv(table, exec_GetTexParameterfv);
+ SET_GetTexParameteriv(table, exec_GetTexParameteriv);
+ SET_Hint(table, save_Hint);
+ SET_IndexMask(table, save_IndexMask);
+ SET_InitNames(table, save_InitNames);
+ SET_IsEnabled(table, exec_IsEnabled);
+ SET_IsList(table, _mesa_IsList);
+ SET_LightModelf(table, save_LightModelf);
+ SET_LightModelfv(table, save_LightModelfv);
+ SET_LightModeli(table, save_LightModeli);
+ SET_LightModeliv(table, save_LightModeliv);
+ SET_Lightf(table, save_Lightf);
+ SET_Lightfv(table, save_Lightfv);
+ SET_Lighti(table, save_Lighti);
+ SET_Lightiv(table, save_Lightiv);
+ SET_LineStipple(table, save_LineStipple);
+ SET_LineWidth(table, save_LineWidth);
+ SET_ListBase(table, save_ListBase);
+ SET_LoadIdentity(table, save_LoadIdentity);
+ SET_LoadMatrixd(table, save_LoadMatrixd);
+ SET_LoadMatrixf(table, save_LoadMatrixf);
+ SET_LoadName(table, save_LoadName);
+ SET_LogicOp(table, save_LogicOp);
+ SET_Map1d(table, save_Map1d);
+ SET_Map1f(table, save_Map1f);
+ SET_Map2d(table, save_Map2d);
+ SET_Map2f(table, save_Map2f);
+ SET_MapGrid1d(table, save_MapGrid1d);
+ SET_MapGrid1f(table, save_MapGrid1f);
+ SET_MapGrid2d(table, save_MapGrid2d);
+ SET_MapGrid2f(table, save_MapGrid2f);
+ SET_MatrixMode(table, save_MatrixMode);
+ SET_MultMatrixd(table, save_MultMatrixd);
+ SET_MultMatrixf(table, save_MultMatrixf);
+ SET_NewList(table, save_NewList);
+ SET_Ortho(table, save_Ortho);
+ SET_PassThrough(table, save_PassThrough);
+ SET_PixelMapfv(table, save_PixelMapfv);
+ SET_PixelMapuiv(table, save_PixelMapuiv);
+ SET_PixelMapusv(table, save_PixelMapusv);
+ SET_PixelStoref(table, exec_PixelStoref);
+ SET_PixelStorei(table, exec_PixelStorei);
+ SET_PixelTransferf(table, save_PixelTransferf);
+ SET_PixelTransferi(table, save_PixelTransferi);
+ SET_PixelZoom(table, save_PixelZoom);
+ SET_PointSize(table, save_PointSize);
+ SET_PolygonMode(table, save_PolygonMode);
+ SET_PolygonOffset(table, save_PolygonOffset);
+ SET_PolygonStipple(table, save_PolygonStipple);
+ SET_PopAttrib(table, save_PopAttrib);
+ SET_PopMatrix(table, save_PopMatrix);
+ SET_PopName(table, save_PopName);
+ SET_PushAttrib(table, save_PushAttrib);
+ SET_PushMatrix(table, save_PushMatrix);
+ SET_PushName(table, save_PushName);
+ SET_RasterPos2d(table, save_RasterPos2d);
+ SET_RasterPos2dv(table, save_RasterPos2dv);
+ SET_RasterPos2f(table, save_RasterPos2f);
+ SET_RasterPos2fv(table, save_RasterPos2fv);
+ SET_RasterPos2i(table, save_RasterPos2i);
+ SET_RasterPos2iv(table, save_RasterPos2iv);
+ SET_RasterPos2s(table, save_RasterPos2s);
+ SET_RasterPos2sv(table, save_RasterPos2sv);
+ SET_RasterPos3d(table, save_RasterPos3d);
+ SET_RasterPos3dv(table, save_RasterPos3dv);
+ SET_RasterPos3f(table, save_RasterPos3f);
+ SET_RasterPos3fv(table, save_RasterPos3fv);
+ SET_RasterPos3i(table, save_RasterPos3i);
+ SET_RasterPos3iv(table, save_RasterPos3iv);
+ SET_RasterPos3s(table, save_RasterPos3s);
+ SET_RasterPos3sv(table, save_RasterPos3sv);
+ SET_RasterPos4d(table, save_RasterPos4d);
+ SET_RasterPos4dv(table, save_RasterPos4dv);
+ SET_RasterPos4f(table, save_RasterPos4f);
+ SET_RasterPos4fv(table, save_RasterPos4fv);
+ SET_RasterPos4i(table, save_RasterPos4i);
+ SET_RasterPos4iv(table, save_RasterPos4iv);
+ SET_RasterPos4s(table, save_RasterPos4s);
+ SET_RasterPos4sv(table, save_RasterPos4sv);
+ SET_ReadBuffer(table, save_ReadBuffer);
+ SET_ReadPixels(table, exec_ReadPixels);
+ SET_RenderMode(table, exec_RenderMode);
+ SET_Rotated(table, save_Rotated);
+ SET_Rotatef(table, save_Rotatef);
+ SET_Scaled(table, save_Scaled);
+ SET_Scalef(table, save_Scalef);
+ SET_Scissor(table, save_Scissor);
+ SET_FeedbackBuffer(table, exec_FeedbackBuffer);
+ SET_SelectBuffer(table, exec_SelectBuffer);
+ SET_ShadeModel(table, save_ShadeModel);
+ SET_StencilFunc(table, save_StencilFunc);
+ SET_StencilMask(table, save_StencilMask);
+ SET_StencilOp(table, save_StencilOp);
+ SET_TexEnvf(table, save_TexEnvf);
+ SET_TexEnvfv(table, save_TexEnvfv);
+ SET_TexEnvi(table, save_TexEnvi);
+ SET_TexEnviv(table, save_TexEnviv);
+ SET_TexGend(table, save_TexGend);
+ SET_TexGendv(table, save_TexGendv);
+ SET_TexGenf(table, save_TexGenf);
+ SET_TexGenfv(table, save_TexGenfv);
+ SET_TexGeni(table, save_TexGeni);
+ SET_TexGeniv(table, save_TexGeniv);
+ SET_TexImage1D(table, save_TexImage1D);
+ SET_TexImage2D(table, save_TexImage2D);
+ SET_TexParameterf(table, save_TexParameterf);
+ SET_TexParameterfv(table, save_TexParameterfv);
+ SET_TexParameteri(table, save_TexParameteri);
+ SET_TexParameteriv(table, save_TexParameteriv);
+ SET_Translated(table, save_Translated);
+ SET_Translatef(table, save_Translatef);
+ SET_Viewport(table, save_Viewport);
/* GL 1.1 */
- table->AreTexturesResident = exec_AreTexturesResident;
- table->AreTexturesResidentEXT = exec_AreTexturesResident;
- table->BindTexture = save_BindTexture;
- table->ColorPointer = exec_ColorPointer;
- table->CopyTexImage1D = save_CopyTexImage1D;
- table->CopyTexImage2D = save_CopyTexImage2D;
- table->CopyTexSubImage1D = save_CopyTexSubImage1D;
- table->CopyTexSubImage2D = save_CopyTexSubImage2D;
- table->DeleteTextures = exec_DeleteTextures;
- table->DisableClientState = exec_DisableClientState;
- table->EdgeFlagPointer = exec_EdgeFlagPointer;
- table->EnableClientState = exec_EnableClientState;
- table->GenTextures = exec_GenTextures;
- table->GenTexturesEXT = exec_GenTextures;
- table->GetPointerv = exec_GetPointerv;
- table->IndexPointer = exec_IndexPointer;
- table->InterleavedArrays = exec_InterleavedArrays;
- table->IsTexture = exec_IsTexture;
- table->IsTextureEXT = exec_IsTexture;
- table->NormalPointer = exec_NormalPointer;
- table->PopClientAttrib = exec_PopClientAttrib;
- table->PrioritizeTextures = save_PrioritizeTextures;
- table->PushClientAttrib = exec_PushClientAttrib;
- table->TexCoordPointer = exec_TexCoordPointer;
- table->TexSubImage1D = save_TexSubImage1D;
- table->TexSubImage2D = save_TexSubImage2D;
- table->VertexPointer = exec_VertexPointer;
+ SET_AreTexturesResident(table, exec_AreTexturesResident);
+ SET_AreTexturesResidentEXT(table, exec_AreTexturesResident);
+ SET_BindTexture(table, save_BindTexture);
+ SET_ColorPointer(table, exec_ColorPointer);
+ SET_CopyTexImage1D(table, save_CopyTexImage1D);
+ SET_CopyTexImage2D(table, save_CopyTexImage2D);
+ SET_CopyTexSubImage1D(table, save_CopyTexSubImage1D);
+ SET_CopyTexSubImage2D(table, save_CopyTexSubImage2D);
+ SET_DeleteTextures(table, exec_DeleteTextures);
+ SET_DisableClientState(table, exec_DisableClientState);
+ SET_EdgeFlagPointer(table, exec_EdgeFlagPointer);
+ SET_EnableClientState(table, exec_EnableClientState);
+ SET_GenTextures(table, exec_GenTextures);
+ SET_GenTexturesEXT(table, exec_GenTextures);
+ SET_GetPointerv(table, exec_GetPointerv);
+ SET_IndexPointer(table, exec_IndexPointer);
+ SET_InterleavedArrays(table, exec_InterleavedArrays);
+ SET_IsTexture(table, exec_IsTexture);
+ SET_IsTextureEXT(table, exec_IsTexture);
+ SET_NormalPointer(table, exec_NormalPointer);
+ SET_PopClientAttrib(table, exec_PopClientAttrib);
+ SET_PrioritizeTextures(table, save_PrioritizeTextures);
+ SET_PushClientAttrib(table, exec_PushClientAttrib);
+ SET_TexCoordPointer(table, exec_TexCoordPointer);
+ SET_TexSubImage1D(table, save_TexSubImage1D);
+ SET_TexSubImage2D(table, save_TexSubImage2D);
+ SET_VertexPointer(table, exec_VertexPointer);
/* GL 1.2 */
- table->CopyTexSubImage3D = save_CopyTexSubImage3D;
- table->TexImage3D = save_TexImage3D;
- table->TexSubImage3D = save_TexSubImage3D;
+ SET_CopyTexSubImage3D(table, save_CopyTexSubImage3D);
+ SET_TexImage3D(table, save_TexImage3D);
+ SET_TexSubImage3D(table, save_TexSubImage3D);
/* GL 2.0 */
- table->StencilFuncSeparate = save_StencilFuncSeparate;
- table->StencilMaskSeparate = save_StencilMaskSeparate;
- table->StencilOpSeparate = save_StencilOpSeparate;
+ SET_StencilFuncSeparate(table, save_StencilFuncSeparate);
+ SET_StencilMaskSeparate(table, save_StencilMaskSeparate);
+ SET_StencilOpSeparate(table, save_StencilOpSeparate);
/* GL_ARB_imaging */
/* Not all are supported */
- table->BlendColor = save_BlendColor;
- table->BlendEquation = save_BlendEquation;
- table->ColorSubTable = save_ColorSubTable;
- table->ColorTable = save_ColorTable;
- table->ColorTableParameterfv = save_ColorTableParameterfv;
- table->ColorTableParameteriv = save_ColorTableParameteriv;
- table->ConvolutionFilter1D = save_ConvolutionFilter1D;
- table->ConvolutionFilter2D = save_ConvolutionFilter2D;
- table->ConvolutionParameterf = save_ConvolutionParameterf;
- table->ConvolutionParameterfv = save_ConvolutionParameterfv;
- table->ConvolutionParameteri = save_ConvolutionParameteri;
- table->ConvolutionParameteriv = save_ConvolutionParameteriv;
- table->CopyColorSubTable = save_CopyColorSubTable;
- table->CopyColorTable = save_CopyColorTable;
- table->CopyConvolutionFilter1D = exec_CopyConvolutionFilter1D;
- table->CopyConvolutionFilter2D = exec_CopyConvolutionFilter2D;
- table->GetColorTable = exec_GetColorTable;
- table->GetColorTableEXT = exec_GetColorTable;
- table->GetColorTableParameterfv = exec_GetColorTableParameterfv;
- table->GetColorTableParameterfvEXT = exec_GetColorTableParameterfv;
- table->GetColorTableParameteriv = exec_GetColorTableParameteriv;
- table->GetColorTableParameterivEXT = exec_GetColorTableParameteriv;
- table->GetConvolutionFilter = exec_GetConvolutionFilter;
- table->GetConvolutionFilterEXT = exec_GetConvolutionFilter;
- table->GetConvolutionParameterfv = exec_GetConvolutionParameterfv;
- table->GetConvolutionParameterfvEXT = exec_GetConvolutionParameterfv;
- table->GetConvolutionParameteriv = exec_GetConvolutionParameteriv;
- table->GetConvolutionParameterivEXT = exec_GetConvolutionParameteriv;
- table->GetHistogram = exec_GetHistogram;
- table->GetHistogramEXT = exec_GetHistogram;
- table->GetHistogramParameterfv = exec_GetHistogramParameterfv;
- table->GetHistogramParameterfvEXT = exec_GetHistogramParameterfv;
- table->GetHistogramParameteriv = exec_GetHistogramParameteriv;
- table->GetHistogramParameterivEXT = exec_GetHistogramParameteriv;
- table->GetMinmax = exec_GetMinmax;
- table->GetMinmaxEXT = exec_GetMinmax;
- table->GetMinmaxParameterfv = exec_GetMinmaxParameterfv;
- table->GetMinmaxParameterfvEXT = exec_GetMinmaxParameterfv;
- table->GetMinmaxParameteriv = exec_GetMinmaxParameteriv;
- table->GetMinmaxParameterivEXT = exec_GetMinmaxParameteriv;
- table->GetSeparableFilter = exec_GetSeparableFilter;
- table->GetSeparableFilterEXT = exec_GetSeparableFilter;
- table->Histogram = save_Histogram;
- table->Minmax = save_Minmax;
- table->ResetHistogram = save_ResetHistogram;
- table->ResetMinmax = save_ResetMinmax;
- table->SeparableFilter2D = exec_SeparableFilter2D;
+ SET_BlendColor(table, save_BlendColor);
+ SET_BlendEquation(table, save_BlendEquation);
+ SET_ColorSubTable(table, save_ColorSubTable);
+ SET_ColorTable(table, save_ColorTable);
+ SET_ColorTableParameterfv(table, save_ColorTableParameterfv);
+ SET_ColorTableParameteriv(table, save_ColorTableParameteriv);
+ SET_ConvolutionFilter1D(table, save_ConvolutionFilter1D);
+ SET_ConvolutionFilter2D(table, save_ConvolutionFilter2D);
+ SET_ConvolutionParameterf(table, save_ConvolutionParameterf);
+ SET_ConvolutionParameterfv(table, save_ConvolutionParameterfv);
+ SET_ConvolutionParameteri(table, save_ConvolutionParameteri);
+ SET_ConvolutionParameteriv(table, save_ConvolutionParameteriv);
+ SET_CopyColorSubTable(table, save_CopyColorSubTable);
+ SET_CopyColorTable(table, save_CopyColorTable);
+ SET_CopyConvolutionFilter1D(table, exec_CopyConvolutionFilter1D);
+ SET_CopyConvolutionFilter2D(table, exec_CopyConvolutionFilter2D);
+ SET_GetColorTable(table, exec_GetColorTable);
+ SET_GetColorTableEXT(table, exec_GetColorTable);
+ SET_GetColorTableParameterfv(table, exec_GetColorTableParameterfv);
+ SET_GetColorTableParameterfvEXT(table, exec_GetColorTableParameterfv);
+ SET_GetColorTableParameteriv(table, exec_GetColorTableParameteriv);
+ SET_GetColorTableParameterivEXT(table, exec_GetColorTableParameteriv);
+ SET_GetConvolutionFilter(table, exec_GetConvolutionFilter);
+ SET_GetConvolutionFilterEXT(table, exec_GetConvolutionFilter);
+ SET_GetConvolutionParameterfv(table, exec_GetConvolutionParameterfv);
+ SET_GetConvolutionParameterfvEXT(table, exec_GetConvolutionParameterfv);
+ SET_GetConvolutionParameteriv(table, exec_GetConvolutionParameteriv);
+ SET_GetConvolutionParameterivEXT(table, exec_GetConvolutionParameteriv);
+ SET_GetHistogram(table, exec_GetHistogram);
+ SET_GetHistogramEXT(table, exec_GetHistogram);
+ SET_GetHistogramParameterfv(table, exec_GetHistogramParameterfv);
+ SET_GetHistogramParameterfvEXT(table, exec_GetHistogramParameterfv);
+ SET_GetHistogramParameteriv(table, exec_GetHistogramParameteriv);
+ SET_GetHistogramParameterivEXT(table, exec_GetHistogramParameteriv);
+ SET_GetMinmax(table, exec_GetMinmax);
+ SET_GetMinmaxEXT(table, exec_GetMinmax);
+ SET_GetMinmaxParameterfv(table, exec_GetMinmaxParameterfv);
+ SET_GetMinmaxParameterfvEXT(table, exec_GetMinmaxParameterfv);
+ SET_GetMinmaxParameteriv(table, exec_GetMinmaxParameteriv);
+ SET_GetMinmaxParameterivEXT(table, exec_GetMinmaxParameteriv);
+ SET_GetSeparableFilter(table, exec_GetSeparableFilter);
+ SET_GetSeparableFilterEXT(table, exec_GetSeparableFilter);
+ SET_Histogram(table, save_Histogram);
+ SET_Minmax(table, save_Minmax);
+ SET_ResetHistogram(table, save_ResetHistogram);
+ SET_ResetMinmax(table, save_ResetMinmax);
+ SET_SeparableFilter2D(table, exec_SeparableFilter2D);
/* 2. GL_EXT_blend_color */
#if 0
- table->BlendColorEXT = save_BlendColorEXT;
+ SET_BlendColorEXT(table, save_BlendColorEXT);
#endif
/* 3. GL_EXT_polygon_offset */
- table->PolygonOffsetEXT = save_PolygonOffsetEXT;
+ SET_PolygonOffsetEXT(table, save_PolygonOffsetEXT);
/* 6. GL_EXT_texture3d */
#if 0
- table->CopyTexSubImage3DEXT = save_CopyTexSubImage3D;
- table->TexImage3DEXT = save_TexImage3DEXT;
- table->TexSubImage3DEXT = save_TexSubImage3D;
+ SET_CopyTexSubImage3DEXT(table, save_CopyTexSubImage3D);
+ SET_TexImage3DEXT(table, save_TexImage3DEXT);
+ SET_TexSubImage3DEXT(table, save_TexSubImage3D);
#endif
/* 15. GL_SGIX_pixel_texture */
- table->PixelTexGenSGIX = save_PixelTexGenSGIX;
+ SET_PixelTexGenSGIX(table, save_PixelTexGenSGIX);
/* 15. GL_SGIS_pixel_texture */
- table->PixelTexGenParameteriSGIS = save_PixelTexGenParameteriSGIS;
- table->PixelTexGenParameterfSGIS = save_PixelTexGenParameterfSGIS;
- table->PixelTexGenParameterivSGIS = save_PixelTexGenParameterivSGIS;
- table->PixelTexGenParameterfvSGIS = save_PixelTexGenParameterfvSGIS;
- table->GetPixelTexGenParameterivSGIS = exec_GetPixelTexGenParameterivSGIS;
- table->GetPixelTexGenParameterfvSGIS = exec_GetPixelTexGenParameterfvSGIS;
+ SET_PixelTexGenParameteriSGIS(table, save_PixelTexGenParameteriSGIS);
+ SET_PixelTexGenParameterfSGIS(table, save_PixelTexGenParameterfSGIS);
+ SET_PixelTexGenParameterivSGIS(table, save_PixelTexGenParameterivSGIS);
+ SET_PixelTexGenParameterfvSGIS(table, save_PixelTexGenParameterfvSGIS);
+ SET_GetPixelTexGenParameterivSGIS(table, exec_GetPixelTexGenParameterivSGIS);
+ SET_GetPixelTexGenParameterfvSGIS(table, exec_GetPixelTexGenParameterfvSGIS);
/* 30. GL_EXT_vertex_array */
- table->ColorPointerEXT = exec_ColorPointerEXT;
- table->EdgeFlagPointerEXT = exec_EdgeFlagPointerEXT;
- table->IndexPointerEXT = exec_IndexPointerEXT;
- table->NormalPointerEXT = exec_NormalPointerEXT;
- table->TexCoordPointerEXT = exec_TexCoordPointerEXT;
- table->VertexPointerEXT = exec_VertexPointerEXT;
+ SET_ColorPointerEXT(table, exec_ColorPointerEXT);
+ SET_EdgeFlagPointerEXT(table, exec_EdgeFlagPointerEXT);
+ SET_IndexPointerEXT(table, exec_IndexPointerEXT);
+ SET_NormalPointerEXT(table, exec_NormalPointerEXT);
+ SET_TexCoordPointerEXT(table, exec_TexCoordPointerEXT);
+ SET_VertexPointerEXT(table, exec_VertexPointerEXT);
/* 37. GL_EXT_blend_minmax */
#if 0
- table->BlendEquationEXT = save_BlendEquationEXT;
+ SET_BlendEquationEXT(table, save_BlendEquationEXT);
#endif
/* 54. GL_EXT_point_parameters */
- table->PointParameterfEXT = save_PointParameterfEXT;
- table->PointParameterfvEXT = save_PointParameterfvEXT;
+ SET_PointParameterfEXT(table, save_PointParameterfEXT);
+ SET_PointParameterfvEXT(table, save_PointParameterfvEXT);
/* 78. GL_EXT_paletted_texture */
#if 0
- table->ColorTableEXT = save_ColorTable;
- table->ColorSubTableEXT = save_ColorSubTable;
+ SET_ColorTableEXT(table, save_ColorTable);
+ SET_ColorSubTableEXT(table, save_ColorSubTable);
#endif
- table->GetColorTableEXT = exec_GetColorTable;
- table->GetColorTableParameterfvEXT = exec_GetColorTableParameterfv;
- table->GetColorTableParameterivEXT = exec_GetColorTableParameteriv;
+ SET_GetColorTableEXT(table, exec_GetColorTable);
+ SET_GetColorTableParameterfvEXT(table, exec_GetColorTableParameterfv);
+ SET_GetColorTableParameterivEXT(table, exec_GetColorTableParameteriv);
/* 97. GL_EXT_compiled_vertex_array */
- table->LockArraysEXT = exec_LockArraysEXT;
- table->UnlockArraysEXT = exec_UnlockArraysEXT;
+ SET_LockArraysEXT(table, exec_LockArraysEXT);
+ SET_UnlockArraysEXT(table, exec_UnlockArraysEXT);
/* 145. GL_EXT_secondary_color */
- table->SecondaryColorPointerEXT = exec_SecondaryColorPointerEXT;
+ SET_SecondaryColorPointerEXT(table, exec_SecondaryColorPointerEXT);
/* 148. GL_EXT_multi_draw_arrays */
- table->MultiDrawArraysEXT = exec_MultiDrawArraysEXT;
- table->MultiDrawElementsEXT = exec_MultiDrawElementsEXT;
+ SET_MultiDrawArraysEXT(table, exec_MultiDrawArraysEXT);
+ SET_MultiDrawElementsEXT(table, exec_MultiDrawElementsEXT);
/* 149. GL_EXT_fog_coord */
- table->FogCoordPointerEXT = exec_FogCoordPointerEXT;
+ SET_FogCoordPointerEXT(table, exec_FogCoordPointerEXT);
/* 173. GL_EXT_blend_func_separate */
- table->BlendFuncSeparateEXT = save_BlendFuncSeparateEXT;
+ SET_BlendFuncSeparateEXT(table, save_BlendFuncSeparateEXT);
/* 196. GL_MESA_resize_buffers */
- table->ResizeBuffersMESA = _mesa_ResizeBuffersMESA;
+ SET_ResizeBuffersMESA(table, _mesa_ResizeBuffersMESA);
/* 197. GL_MESA_window_pos */
- table->WindowPos2dMESA = save_WindowPos2dMESA;
- table->WindowPos2dvMESA = save_WindowPos2dvMESA;
- table->WindowPos2fMESA = save_WindowPos2fMESA;
- table->WindowPos2fvMESA = save_WindowPos2fvMESA;
- table->WindowPos2iMESA = save_WindowPos2iMESA;
- table->WindowPos2ivMESA = save_WindowPos2ivMESA;
- table->WindowPos2sMESA = save_WindowPos2sMESA;
- table->WindowPos2svMESA = save_WindowPos2svMESA;
- table->WindowPos3dMESA = save_WindowPos3dMESA;
- table->WindowPos3dvMESA = save_WindowPos3dvMESA;
- table->WindowPos3fMESA = save_WindowPos3fMESA;
- table->WindowPos3fvMESA = save_WindowPos3fvMESA;
- table->WindowPos3iMESA = save_WindowPos3iMESA;
- table->WindowPos3ivMESA = save_WindowPos3ivMESA;
- table->WindowPos3sMESA = save_WindowPos3sMESA;
- table->WindowPos3svMESA = save_WindowPos3svMESA;
- table->WindowPos4dMESA = save_WindowPos4dMESA;
- table->WindowPos4dvMESA = save_WindowPos4dvMESA;
- table->WindowPos4fMESA = save_WindowPos4fMESA;
- table->WindowPos4fvMESA = save_WindowPos4fvMESA;
- table->WindowPos4iMESA = save_WindowPos4iMESA;
- table->WindowPos4ivMESA = save_WindowPos4ivMESA;
- table->WindowPos4sMESA = save_WindowPos4sMESA;
- table->WindowPos4svMESA = save_WindowPos4svMESA;
+ SET_WindowPos2dMESA(table, save_WindowPos2dMESA);
+ SET_WindowPos2dvMESA(table, save_WindowPos2dvMESA);
+ SET_WindowPos2fMESA(table, save_WindowPos2fMESA);
+ SET_WindowPos2fvMESA(table, save_WindowPos2fvMESA);
+ SET_WindowPos2iMESA(table, save_WindowPos2iMESA);
+ SET_WindowPos2ivMESA(table, save_WindowPos2ivMESA);
+ SET_WindowPos2sMESA(table, save_WindowPos2sMESA);
+ SET_WindowPos2svMESA(table, save_WindowPos2svMESA);
+ SET_WindowPos3dMESA(table, save_WindowPos3dMESA);
+ SET_WindowPos3dvMESA(table, save_WindowPos3dvMESA);
+ SET_WindowPos3fMESA(table, save_WindowPos3fMESA);
+ SET_WindowPos3fvMESA(table, save_WindowPos3fvMESA);
+ SET_WindowPos3iMESA(table, save_WindowPos3iMESA);
+ SET_WindowPos3ivMESA(table, save_WindowPos3ivMESA);
+ SET_WindowPos3sMESA(table, save_WindowPos3sMESA);
+ SET_WindowPos3svMESA(table, save_WindowPos3svMESA);
+ SET_WindowPos4dMESA(table, save_WindowPos4dMESA);
+ SET_WindowPos4dvMESA(table, save_WindowPos4dvMESA);
+ SET_WindowPos4fMESA(table, save_WindowPos4fMESA);
+ SET_WindowPos4fvMESA(table, save_WindowPos4fvMESA);
+ SET_WindowPos4iMESA(table, save_WindowPos4iMESA);
+ SET_WindowPos4ivMESA(table, save_WindowPos4ivMESA);
+ SET_WindowPos4sMESA(table, save_WindowPos4sMESA);
+ SET_WindowPos4svMESA(table, save_WindowPos4svMESA);
/* 200. GL_IBM_multimode_draw_arrays */
- table->MultiModeDrawArraysIBM = exec_MultiModeDrawArraysIBM;
- table->MultiModeDrawElementsIBM = exec_MultiModeDrawElementsIBM;
+ SET_MultiModeDrawArraysIBM(table, exec_MultiModeDrawArraysIBM);
+ SET_MultiModeDrawElementsIBM(table, exec_MultiModeDrawElementsIBM);
#if FEATURE_NV_vertex_program
/* 233. GL_NV_vertex_program */
* AreProgramsResidentNV, IsProgramNV, GenProgramsNV, DeleteProgramsNV,
* VertexAttribPointerNV, GetProgram*, GetVertexAttrib*
*/
- table->BindProgramNV = save_BindProgramNV;
- table->DeleteProgramsNV = _mesa_DeletePrograms;
- table->ExecuteProgramNV = save_ExecuteProgramNV;
- table->GenProgramsNV = _mesa_GenPrograms;
- table->AreProgramsResidentNV = _mesa_AreProgramsResidentNV;
- table->RequestResidentProgramsNV = save_RequestResidentProgramsNV;
- table->GetProgramParameterfvNV = _mesa_GetProgramParameterfvNV;
- table->GetProgramParameterdvNV = _mesa_GetProgramParameterdvNV;
- table->GetProgramivNV = _mesa_GetProgramivNV;
- table->GetProgramStringNV = _mesa_GetProgramStringNV;
- table->GetTrackMatrixivNV = _mesa_GetTrackMatrixivNV;
- table->GetVertexAttribdvNV = _mesa_GetVertexAttribdvNV;
- table->GetVertexAttribfvNV = _mesa_GetVertexAttribfvNV;
- table->GetVertexAttribivNV = _mesa_GetVertexAttribivNV;
- table->GetVertexAttribPointervNV = _mesa_GetVertexAttribPointervNV;
- table->IsProgramNV = _mesa_IsProgram;
- table->LoadProgramNV = save_LoadProgramNV;
- table->ProgramParameter4dNV = save_ProgramParameter4dNV;
- table->ProgramParameter4dvNV = save_ProgramParameter4dvNV;
- table->ProgramParameter4fNV = save_ProgramParameter4fNV;
- table->ProgramParameter4fvNV = save_ProgramParameter4fvNV;
- table->ProgramParameters4dvNV = save_ProgramParameters4dvNV;
- table->ProgramParameters4fvNV = save_ProgramParameters4fvNV;
- table->TrackMatrixNV = save_TrackMatrixNV;
- table->VertexAttribPointerNV = _mesa_VertexAttribPointerNV;
+ SET_BindProgramNV(table, save_BindProgramNV);
+ SET_DeleteProgramsNV(table, _mesa_DeletePrograms);
+ SET_ExecuteProgramNV(table, save_ExecuteProgramNV);
+ SET_GenProgramsNV(table, _mesa_GenPrograms);
+ SET_AreProgramsResidentNV(table, _mesa_AreProgramsResidentNV);
+ SET_RequestResidentProgramsNV(table, save_RequestResidentProgramsNV);
+ SET_GetProgramParameterfvNV(table, _mesa_GetProgramParameterfvNV);
+ SET_GetProgramParameterdvNV(table, _mesa_GetProgramParameterdvNV);
+ SET_GetProgramivNV(table, _mesa_GetProgramivNV);
+ SET_GetProgramStringNV(table, _mesa_GetProgramStringNV);
+ SET_GetTrackMatrixivNV(table, _mesa_GetTrackMatrixivNV);
+ SET_GetVertexAttribdvNV(table, _mesa_GetVertexAttribdvNV);
+ SET_GetVertexAttribfvNV(table, _mesa_GetVertexAttribfvNV);
+ SET_GetVertexAttribivNV(table, _mesa_GetVertexAttribivNV);
+ SET_GetVertexAttribPointervNV(table, _mesa_GetVertexAttribPointervNV);
+ SET_IsProgramNV(table, _mesa_IsProgram);
+ SET_LoadProgramNV(table, save_LoadProgramNV);
+ SET_ProgramParameter4dNV(table, save_ProgramParameter4dNV);
+ SET_ProgramParameter4dvNV(table, save_ProgramParameter4dvNV);
+ SET_ProgramParameter4fNV(table, save_ProgramParameter4fNV);
+ SET_ProgramParameter4fvNV(table, save_ProgramParameter4fvNV);
+ SET_ProgramParameters4dvNV(table, save_ProgramParameters4dvNV);
+ SET_ProgramParameters4fvNV(table, save_ProgramParameters4fvNV);
+ SET_TrackMatrixNV(table, save_TrackMatrixNV);
+ SET_VertexAttribPointerNV(table, _mesa_VertexAttribPointerNV);
#endif
/* 245. GL_ATI_fragment_shader */
#if FEATURE_ATI_fragment_shader
- table->BindFragmentShaderATI = save_BindFragmentShaderATI;
- table->SetFragmentShaderConstantATI = save_SetFragmentShaderConstantATI;
+ SET_BindFragmentShaderATI(table, save_BindFragmentShaderATI);
+ SET_SetFragmentShaderConstantATI(table, save_SetFragmentShaderConstantATI);
#endif
/* 282. GL_NV_fragment_program */
#if FEATURE_NV_fragment_program
- table->ProgramNamedParameter4fNV = save_ProgramNamedParameter4fNV;
- table->ProgramNamedParameter4dNV = save_ProgramNamedParameter4dNV;
- table->ProgramNamedParameter4fvNV = save_ProgramNamedParameter4fvNV;
- table->ProgramNamedParameter4dvNV = save_ProgramNamedParameter4dvNV;
- table->GetProgramNamedParameterfvNV = _mesa_GetProgramNamedParameterfvNV;
- table->GetProgramNamedParameterdvNV = _mesa_GetProgramNamedParameterdvNV;
- table->ProgramLocalParameter4dARB = save_ProgramLocalParameter4dARB;
- table->ProgramLocalParameter4dvARB = save_ProgramLocalParameter4dvARB;
- table->ProgramLocalParameter4fARB = save_ProgramLocalParameter4fARB;
- table->ProgramLocalParameter4fvARB = save_ProgramLocalParameter4fvARB;
- table->GetProgramLocalParameterdvARB = _mesa_GetProgramLocalParameterdvARB;
- table->GetProgramLocalParameterfvARB = _mesa_GetProgramLocalParameterfvARB;
+ SET_ProgramNamedParameter4fNV(table, save_ProgramNamedParameter4fNV);
+ SET_ProgramNamedParameter4dNV(table, save_ProgramNamedParameter4dNV);
+ SET_ProgramNamedParameter4fvNV(table, save_ProgramNamedParameter4fvNV);
+ SET_ProgramNamedParameter4dvNV(table, save_ProgramNamedParameter4dvNV);
+ SET_GetProgramNamedParameterfvNV(table, _mesa_GetProgramNamedParameterfvNV);
+ SET_GetProgramNamedParameterdvNV(table, _mesa_GetProgramNamedParameterdvNV);
+ SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);
+ SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);
+ SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);
+ SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);
+ SET_GetProgramLocalParameterdvARB(table, _mesa_GetProgramLocalParameterdvARB);
+ SET_GetProgramLocalParameterfvARB(table, _mesa_GetProgramLocalParameterfvARB);
#endif
/* 262. GL_NV_point_sprite */
- table->PointParameteriNV = save_PointParameteriNV;
- table->PointParameterivNV = save_PointParameterivNV;
+ SET_PointParameteriNV(table, save_PointParameteriNV);
+ SET_PointParameterivNV(table, save_PointParameterivNV);
/* 268. GL_EXT_stencil_two_side */
- table->ActiveStencilFaceEXT = save_ActiveStencilFaceEXT;
+ SET_ActiveStencilFaceEXT(table, save_ActiveStencilFaceEXT);
/* ???. GL_EXT_depth_bounds_test */
- table->DepthBoundsEXT = save_DepthBoundsEXT;
+ SET_DepthBoundsEXT(table, save_DepthBoundsEXT);
/* ARB 1. GL_ARB_multitexture */
- table->ActiveTextureARB = save_ActiveTextureARB;
- table->ClientActiveTextureARB = exec_ClientActiveTextureARB;
+ SET_ActiveTextureARB(table, save_ActiveTextureARB);
+ SET_ClientActiveTextureARB(table, exec_ClientActiveTextureARB);
/* ARB 3. GL_ARB_transpose_matrix */
- table->LoadTransposeMatrixdARB = save_LoadTransposeMatrixdARB;
- table->LoadTransposeMatrixfARB = save_LoadTransposeMatrixfARB;
- table->MultTransposeMatrixdARB = save_MultTransposeMatrixdARB;
- table->MultTransposeMatrixfARB = save_MultTransposeMatrixfARB;
+ SET_LoadTransposeMatrixdARB(table, save_LoadTransposeMatrixdARB);
+ SET_LoadTransposeMatrixfARB(table, save_LoadTransposeMatrixfARB);
+ SET_MultTransposeMatrixdARB(table, save_MultTransposeMatrixdARB);
+ SET_MultTransposeMatrixfARB(table, save_MultTransposeMatrixfARB);
/* ARB 5. GL_ARB_multisample */
- table->SampleCoverageARB = save_SampleCoverageARB;
+ SET_SampleCoverageARB(table, save_SampleCoverageARB);
/* ARB 12. GL_ARB_texture_compression */
- table->CompressedTexImage3DARB = save_CompressedTexImage3DARB;
- table->CompressedTexImage2DARB = save_CompressedTexImage2DARB;
- table->CompressedTexImage1DARB = save_CompressedTexImage1DARB;
- table->CompressedTexSubImage3DARB = save_CompressedTexSubImage3DARB;
- table->CompressedTexSubImage2DARB = save_CompressedTexSubImage2DARB;
- table->CompressedTexSubImage1DARB = save_CompressedTexSubImage1DARB;
- table->GetCompressedTexImageARB = exec_GetCompressedTexImageARB;
+ SET_CompressedTexImage3DARB(table, save_CompressedTexImage3DARB);
+ SET_CompressedTexImage2DARB(table, save_CompressedTexImage2DARB);
+ SET_CompressedTexImage1DARB(table, save_CompressedTexImage1DARB);
+ SET_CompressedTexSubImage3DARB(table, save_CompressedTexSubImage3DARB);
+ SET_CompressedTexSubImage2DARB(table, save_CompressedTexSubImage2DARB);
+ SET_CompressedTexSubImage1DARB(table, save_CompressedTexSubImage1DARB);
+ SET_GetCompressedTexImageARB(table, exec_GetCompressedTexImageARB);
/* ARB 14. GL_ARB_point_parameters */
/* aliased with EXT_point_parameters functions */
/* ARB 27. GL_ARB_fragment_program */
#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
/* glVertexAttrib* functions alias the NV ones, handled elsewhere */
- table->VertexAttribPointerARB = _mesa_VertexAttribPointerARB;
- table->EnableVertexAttribArrayARB = _mesa_EnableVertexAttribArrayARB;
- table->DisableVertexAttribArrayARB = _mesa_DisableVertexAttribArrayARB;
- table->ProgramStringARB = save_ProgramStringARB;
- table->BindProgramNV = save_BindProgramNV;
- table->DeleteProgramsNV = _mesa_DeletePrograms;
- table->GenProgramsNV = _mesa_GenPrograms;
- table->IsProgramNV = _mesa_IsProgram;
- table->GetVertexAttribdvNV = _mesa_GetVertexAttribdvNV;
- table->GetVertexAttribfvNV = _mesa_GetVertexAttribfvNV;
- table->GetVertexAttribivNV = _mesa_GetVertexAttribivNV;
- table->GetVertexAttribPointervNV = _mesa_GetVertexAttribPointervNV;
- table->ProgramEnvParameter4dARB = save_ProgramEnvParameter4dARB;
- table->ProgramEnvParameter4dvARB = save_ProgramEnvParameter4dvARB;
- table->ProgramEnvParameter4fARB = save_ProgramEnvParameter4fARB;
- table->ProgramEnvParameter4fvARB = save_ProgramEnvParameter4fvARB;
- table->ProgramLocalParameter4dARB = save_ProgramLocalParameter4dARB;
- table->ProgramLocalParameter4dvARB = save_ProgramLocalParameter4dvARB;
- table->ProgramLocalParameter4fARB = save_ProgramLocalParameter4fARB;
- table->ProgramLocalParameter4fvARB = save_ProgramLocalParameter4fvARB;
- table->GetProgramEnvParameterdvARB = _mesa_GetProgramEnvParameterdvARB;
- table->GetProgramEnvParameterfvARB = _mesa_GetProgramEnvParameterfvARB;
- table->GetProgramLocalParameterdvARB = _mesa_GetProgramLocalParameterdvARB;
- table->GetProgramLocalParameterfvARB = _mesa_GetProgramLocalParameterfvARB;
- table->GetProgramivARB = _mesa_GetProgramivARB;
- table->GetProgramStringARB = _mesa_GetProgramStringARB;
+ SET_VertexAttribPointerARB(table, _mesa_VertexAttribPointerARB);
+ SET_EnableVertexAttribArrayARB(table, _mesa_EnableVertexAttribArrayARB);
+ SET_DisableVertexAttribArrayARB(table, _mesa_DisableVertexAttribArrayARB);
+ SET_ProgramStringARB(table, save_ProgramStringARB);
+ SET_BindProgramNV(table, save_BindProgramNV);
+ SET_DeleteProgramsNV(table, _mesa_DeletePrograms);
+ SET_GenProgramsNV(table, _mesa_GenPrograms);
+ SET_IsProgramNV(table, _mesa_IsProgram);
+ SET_GetVertexAttribdvNV(table, _mesa_GetVertexAttribdvNV);
+ SET_GetVertexAttribfvNV(table, _mesa_GetVertexAttribfvNV);
+ SET_GetVertexAttribivNV(table, _mesa_GetVertexAttribivNV);
+ SET_GetVertexAttribPointervNV(table, _mesa_GetVertexAttribPointervNV);
+ SET_ProgramEnvParameter4dARB(table, save_ProgramEnvParameter4dARB);
+ SET_ProgramEnvParameter4dvARB(table, save_ProgramEnvParameter4dvARB);
+ SET_ProgramEnvParameter4fARB(table, save_ProgramEnvParameter4fARB);
+ SET_ProgramEnvParameter4fvARB(table, save_ProgramEnvParameter4fvARB);
+ SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);
+ SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);
+ SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);
+ SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);
+ SET_GetProgramEnvParameterdvARB(table, _mesa_GetProgramEnvParameterdvARB);
+ SET_GetProgramEnvParameterfvARB(table, _mesa_GetProgramEnvParameterfvARB);
+ SET_GetProgramLocalParameterdvARB(table, _mesa_GetProgramLocalParameterdvARB);
+ SET_GetProgramLocalParameterfvARB(table, _mesa_GetProgramLocalParameterfvARB);
+ SET_GetProgramivARB(table, _mesa_GetProgramivARB);
+ SET_GetProgramStringARB(table, _mesa_GetProgramStringARB);
#endif
/* ARB 28. GL_ARB_vertex_buffer_object */
#if FEATURE_ARB_vertex_buffer_object
/* None of the extension's functions get compiled */
- table->BindBufferARB = _mesa_BindBufferARB;
- table->BufferDataARB = _mesa_BufferDataARB;
- table->BufferSubDataARB = _mesa_BufferSubDataARB;
- table->DeleteBuffersARB = _mesa_DeleteBuffersARB;
- table->GenBuffersARB = _mesa_GenBuffersARB;
- table->GetBufferParameterivARB = _mesa_GetBufferParameterivARB;
- table->GetBufferPointervARB = _mesa_GetBufferPointervARB;
- table->GetBufferSubDataARB = _mesa_GetBufferSubDataARB;
- table->IsBufferARB = _mesa_IsBufferARB;
- table->MapBufferARB = _mesa_MapBufferARB;
- table->UnmapBufferARB = _mesa_UnmapBufferARB;
+ SET_BindBufferARB(table, _mesa_BindBufferARB);
+ SET_BufferDataARB(table, _mesa_BufferDataARB);
+ SET_BufferSubDataARB(table, _mesa_BufferSubDataARB);
+ SET_DeleteBuffersARB(table, _mesa_DeleteBuffersARB);
+ SET_GenBuffersARB(table, _mesa_GenBuffersARB);
+ SET_GetBufferParameterivARB(table, _mesa_GetBufferParameterivARB);
+ SET_GetBufferPointervARB(table, _mesa_GetBufferPointervARB);
+ SET_GetBufferSubDataARB(table, _mesa_GetBufferSubDataARB);
+ SET_IsBufferARB(table, _mesa_IsBufferARB);
+ SET_MapBufferARB(table, _mesa_MapBufferARB);
+ SET_UnmapBufferARB(table, _mesa_UnmapBufferARB);
#endif
#if FEATURE_ARB_occlusion_query
- table->BeginQueryARB = save_BeginQueryARB;
- table->EndQueryARB = save_EndQueryARB;
- table->GenQueriesARB = _mesa_GenQueriesARB;
- table->DeleteQueriesARB = _mesa_DeleteQueriesARB;
- table->IsQueryARB = _mesa_IsQueryARB;
- table->GetQueryivARB = _mesa_GetQueryivARB;
- table->GetQueryObjectivARB = _mesa_GetQueryObjectivARB;
- table->GetQueryObjectuivARB = _mesa_GetQueryObjectuivARB;
+ SET_BeginQueryARB(table, save_BeginQueryARB);
+ SET_EndQueryARB(table, save_EndQueryARB);
+ SET_GenQueriesARB(table, _mesa_GenQueriesARB);
+ SET_DeleteQueriesARB(table, _mesa_DeleteQueriesARB);
+ SET_IsQueryARB(table, _mesa_IsQueryARB);
+ SET_GetQueryivARB(table, _mesa_GetQueryivARB);
+ SET_GetQueryObjectivARB(table, _mesa_GetQueryObjectivARB);
+ SET_GetQueryObjectuivARB(table, _mesa_GetQueryObjectuivARB);
#endif
- table->DrawBuffersARB = save_DrawBuffersARB;
+ SET_DrawBuffersARB(table, save_DrawBuffersARB);
/* 299. GL_EXT_blend_equation_separate */
- table->BlendEquationSeparateEXT = save_BlendEquationSeparateEXT;
+ SET_BlendEquationSeparateEXT(table, save_BlendEquationSeparateEXT);
}
Node *n;
GLboolean done;
- if (!GL_CALL(IsList)(list)) {
+ if (!CALL_IsList(GET_DISPATCH(), (list))) {
_mesa_printf("%u is not a display list ID\n", list);
return;
}
#include "shaderobjects.h"
#endif
#include "debug.h"
+#include "dispatch.h"
* Pointers to glBegin()/glEnd() object commands and a few others
* are provided via the GLvertexformat interface.
*
+ * \param ctx GL context to which \c exec belongs.
* \param exec dispatch table.
- * \param tableSize dispatch table size.
*/
void
_mesa_init_exec_table(struct _glapi_table *exec)
#endif
/* load the dispatch slots we understand */
- exec->AlphaFunc = _mesa_AlphaFunc;
- exec->BlendFunc = _mesa_BlendFunc;
- exec->Clear = _mesa_Clear;
- exec->ClearColor = _mesa_ClearColor;
- exec->ClearStencil = _mesa_ClearStencil;
- exec->ColorMask = _mesa_ColorMask;
- exec->CullFace = _mesa_CullFace;
- exec->Disable = _mesa_Disable;
- exec->DrawBuffer = _mesa_DrawBuffer;
- exec->Enable = _mesa_Enable;
- exec->Finish = _mesa_Finish;
- exec->Flush = _mesa_Flush;
- exec->FrontFace = _mesa_FrontFace;
- exec->Frustum = _mesa_Frustum;
- exec->GetError = _mesa_GetError;
- exec->GetFloatv = _mesa_GetFloatv;
- exec->GetString = _mesa_GetString;
- exec->InitNames = _mesa_InitNames;
- exec->LineStipple = _mesa_LineStipple;
- exec->LineWidth = _mesa_LineWidth;
- exec->LoadIdentity = _mesa_LoadIdentity;
- exec->LoadMatrixf = _mesa_LoadMatrixf;
- exec->LoadName = _mesa_LoadName;
- exec->LogicOp = _mesa_LogicOp;
- exec->MatrixMode = _mesa_MatrixMode;
- exec->MultMatrixf = _mesa_MultMatrixf;
- exec->Ortho = _mesa_Ortho;
- exec->PixelStorei = _mesa_PixelStorei;
- exec->PopMatrix = _mesa_PopMatrix;
- exec->PopName = _mesa_PopName;
- exec->PushMatrix = _mesa_PushMatrix;
- exec->PushName = _mesa_PushName;
- exec->RasterPos2f = _mesa_RasterPos2f;
- exec->RasterPos2fv = _mesa_RasterPos2fv;
- exec->RasterPos2i = _mesa_RasterPos2i;
- exec->RasterPos2iv = _mesa_RasterPos2iv;
- exec->ReadBuffer = _mesa_ReadBuffer;
- exec->RenderMode = _mesa_RenderMode;
- exec->Rotatef = _mesa_Rotatef;
- exec->Scalef = _mesa_Scalef;
- exec->Scissor = _mesa_Scissor;
- exec->SelectBuffer = _mesa_SelectBuffer;
- exec->ShadeModel = _mesa_ShadeModel;
- exec->StencilFunc = _mesa_StencilFunc;
- exec->StencilMask = _mesa_StencilMask;
- exec->StencilOp = _mesa_StencilOp;
- exec->TexEnvfv = _mesa_TexEnvfv;
- exec->TexEnvi = _mesa_TexEnvi;
- exec->TexImage2D = _mesa_TexImage2D;
- exec->TexParameteri = _mesa_TexParameteri;
- exec->Translatef = _mesa_Translatef;
- exec->Viewport = _mesa_Viewport;
+ SET_AlphaFunc(exec, _mesa_AlphaFunc);
+ SET_BlendFunc(exec, _mesa_BlendFunc);
+ SET_Clear(exec, _mesa_Clear);
+ SET_ClearColor(exec, _mesa_ClearColor);
+ SET_ClearStencil(exec, _mesa_ClearStencil);
+ SET_ColorMask(exec, _mesa_ColorMask);
+ SET_CullFace(exec, _mesa_CullFace);
+ SET_Disable(exec, _mesa_Disable);
+ SET_DrawBuffer(exec, _mesa_DrawBuffer);
+ SET_Enable(exec, _mesa_Enable);
+ SET_Finish(exec, _mesa_Finish);
+ SET_Flush(exec, _mesa_Flush);
+ SET_FrontFace(exec, _mesa_FrontFace);
+ SET_Frustum(exec, _mesa_Frustum);
+ SET_GetError(exec, _mesa_GetError);
+ SET_GetFloatv(exec, _mesa_GetFloatv);
+ SET_GetString(exec, _mesa_GetString);
+ SET_InitNames(exec, _mesa_InitNames);
+ SET_LineStipple(exec, _mesa_LineStipple);
+ SET_LineWidth(exec, _mesa_LineWidth);
+ SET_LoadIdentity(exec, _mesa_LoadIdentity);
+ SET_LoadMatrixf(exec, _mesa_LoadMatrixf);
+ SET_LoadName(exec, _mesa_LoadName);
+ SET_LogicOp(exec, _mesa_LogicOp);
+ SET_MatrixMode(exec, _mesa_MatrixMode);
+ SET_MultMatrixf(exec, _mesa_MultMatrixf);
+ SET_Ortho(exec, _mesa_Ortho);
+ SET_PixelStorei(exec, _mesa_PixelStorei);
+ SET_PopMatrix(exec, _mesa_PopMatrix);
+ SET_PopName(exec, _mesa_PopName);
+ SET_PushMatrix(exec, _mesa_PushMatrix);
+ SET_PushName(exec, _mesa_PushName);
+ SET_RasterPos2f(exec, _mesa_RasterPos2f);
+ SET_RasterPos2fv(exec, _mesa_RasterPos2fv);
+ SET_RasterPos2i(exec, _mesa_RasterPos2i);
+ SET_RasterPos2iv(exec, _mesa_RasterPos2iv);
+ SET_ReadBuffer(exec, _mesa_ReadBuffer);
+ SET_RenderMode(exec, _mesa_RenderMode);
+ SET_Rotatef(exec, _mesa_Rotatef);
+ SET_Scalef(exec, _mesa_Scalef);
+ SET_Scissor(exec, _mesa_Scissor);
+ SET_SelectBuffer(exec, _mesa_SelectBuffer);
+ SET_ShadeModel(exec, _mesa_ShadeModel);
+ SET_StencilFunc(exec, _mesa_StencilFunc);
+ SET_StencilMask(exec, _mesa_StencilMask);
+ SET_StencilOp(exec, _mesa_StencilOp);
+ SET_TexEnvfv(exec, _mesa_TexEnvfv);
+ SET_TexEnvi(exec, _mesa_TexEnvi);
+ SET_TexImage2D(exec, _mesa_TexImage2D);
+ SET_TexParameteri(exec, _mesa_TexParameteri);
+ SET_Translatef(exec, _mesa_Translatef);
+ SET_Viewport(exec, _mesa_Viewport);
#if _HAVE_FULL_GL
- exec->Accum = _mesa_Accum;
- exec->Bitmap = _mesa_Bitmap;
- exec->CallList = _mesa_CallList;
- exec->CallLists = _mesa_CallLists;
- exec->ClearAccum = _mesa_ClearAccum;
- exec->ClearDepth = _mesa_ClearDepth;
- exec->ClearIndex = _mesa_ClearIndex;
- exec->ClipPlane = _mesa_ClipPlane;
- exec->ColorMaterial = _mesa_ColorMaterial;
- exec->CopyPixels = _mesa_CopyPixels;
- exec->CullParameterfvEXT = _mesa_CullParameterfvEXT;
- exec->CullParameterdvEXT = _mesa_CullParameterdvEXT;
- exec->DeleteLists = _mesa_DeleteLists;
- exec->DepthFunc = _mesa_DepthFunc;
- exec->DepthMask = _mesa_DepthMask;
- exec->DepthRange = _mesa_DepthRange;
- exec->DrawPixels = _mesa_DrawPixels;
- exec->EndList = _mesa_EndList;
- exec->FeedbackBuffer = _mesa_FeedbackBuffer;
- exec->FogCoordPointerEXT = _mesa_FogCoordPointerEXT;
- exec->Fogf = _mesa_Fogf;
- exec->Fogfv = _mesa_Fogfv;
- exec->Fogi = _mesa_Fogi;
- exec->Fogiv = _mesa_Fogiv;
- exec->GenLists = _mesa_GenLists;
- exec->GetClipPlane = _mesa_GetClipPlane;
- exec->GetBooleanv = _mesa_GetBooleanv;
- exec->GetDoublev = _mesa_GetDoublev;
- exec->GetIntegerv = _mesa_GetIntegerv;
- exec->GetLightfv = _mesa_GetLightfv;
- exec->GetLightiv = _mesa_GetLightiv;
- exec->GetMapdv = _mesa_GetMapdv;
- exec->GetMapfv = _mesa_GetMapfv;
- exec->GetMapiv = _mesa_GetMapiv;
- exec->GetMaterialfv = _mesa_GetMaterialfv;
- exec->GetMaterialiv = _mesa_GetMaterialiv;
- exec->GetPixelMapfv = _mesa_GetPixelMapfv;
- exec->GetPixelMapuiv = _mesa_GetPixelMapuiv;
- exec->GetPixelMapusv = _mesa_GetPixelMapusv;
- exec->GetPolygonStipple = _mesa_GetPolygonStipple;
- exec->GetTexEnvfv = _mesa_GetTexEnvfv;
- exec->GetTexEnviv = _mesa_GetTexEnviv;
- exec->GetTexLevelParameterfv = _mesa_GetTexLevelParameterfv;
- exec->GetTexLevelParameteriv = _mesa_GetTexLevelParameteriv;
- exec->GetTexParameterfv = _mesa_GetTexParameterfv;
- exec->GetTexParameteriv = _mesa_GetTexParameteriv;
- exec->GetTexGendv = _mesa_GetTexGendv;
- exec->GetTexGenfv = _mesa_GetTexGenfv;
- exec->GetTexGeniv = _mesa_GetTexGeniv;
- exec->GetTexImage = _mesa_GetTexImage;
- exec->Hint = _mesa_Hint;
- exec->IndexMask = _mesa_IndexMask;
- exec->IsEnabled = _mesa_IsEnabled;
- exec->IsList = _mesa_IsList;
- exec->LightModelf = _mesa_LightModelf;
- exec->LightModelfv = _mesa_LightModelfv;
- exec->LightModeli = _mesa_LightModeli;
- exec->LightModeliv = _mesa_LightModeliv;
- exec->Lightf = _mesa_Lightf;
- exec->Lightfv = _mesa_Lightfv;
- exec->Lighti = _mesa_Lighti;
- exec->Lightiv = _mesa_Lightiv;
- exec->ListBase = _mesa_ListBase;
- exec->LoadMatrixd = _mesa_LoadMatrixd;
- exec->Map1d = _mesa_Map1d;
- exec->Map1f = _mesa_Map1f;
- exec->Map2d = _mesa_Map2d;
- exec->Map2f = _mesa_Map2f;
- exec->MapGrid1d = _mesa_MapGrid1d;
- exec->MapGrid1f = _mesa_MapGrid1f;
- exec->MapGrid2d = _mesa_MapGrid2d;
- exec->MapGrid2f = _mesa_MapGrid2f;
- exec->MultMatrixd = _mesa_MultMatrixd;
- exec->NewList = _mesa_NewList;
- exec->PassThrough = _mesa_PassThrough;
- exec->PixelMapfv = _mesa_PixelMapfv;
- exec->PixelMapuiv = _mesa_PixelMapuiv;
- exec->PixelMapusv = _mesa_PixelMapusv;
- exec->PixelStoref = _mesa_PixelStoref;
- exec->PixelTransferf = _mesa_PixelTransferf;
- exec->PixelTransferi = _mesa_PixelTransferi;
- exec->PixelZoom = _mesa_PixelZoom;
- exec->PointSize = _mesa_PointSize;
- exec->PolygonMode = _mesa_PolygonMode;
- exec->PolygonOffset = _mesa_PolygonOffset;
- exec->PolygonStipple = _mesa_PolygonStipple;
- exec->PopAttrib = _mesa_PopAttrib;
- exec->PushAttrib = _mesa_PushAttrib;
- exec->RasterPos2d = _mesa_RasterPos2d;
- exec->RasterPos2dv = _mesa_RasterPos2dv;
- exec->RasterPos2s = _mesa_RasterPos2s;
- exec->RasterPos2sv = _mesa_RasterPos2sv;
- exec->RasterPos3d = _mesa_RasterPos3d;
- exec->RasterPos3dv = _mesa_RasterPos3dv;
- exec->RasterPos3f = _mesa_RasterPos3f;
- exec->RasterPos3fv = _mesa_RasterPos3fv;
- exec->RasterPos3i = _mesa_RasterPos3i;
- exec->RasterPos3iv = _mesa_RasterPos3iv;
- exec->RasterPos3s = _mesa_RasterPos3s;
- exec->RasterPos3sv = _mesa_RasterPos3sv;
- exec->RasterPos4d = _mesa_RasterPos4d;
- exec->RasterPos4dv = _mesa_RasterPos4dv;
- exec->RasterPos4f = _mesa_RasterPos4f;
- exec->RasterPos4fv = _mesa_RasterPos4fv;
- exec->RasterPos4i = _mesa_RasterPos4i;
- exec->RasterPos4iv = _mesa_RasterPos4iv;
- exec->RasterPos4s = _mesa_RasterPos4s;
- exec->RasterPos4sv = _mesa_RasterPos4sv;
- exec->ReadPixels = _mesa_ReadPixels;
- exec->Rotated = _mesa_Rotated;
- exec->Scaled = _mesa_Scaled;
- exec->SecondaryColorPointerEXT = _mesa_SecondaryColorPointerEXT;
- exec->TexEnvf = _mesa_TexEnvf;
- exec->TexEnviv = _mesa_TexEnviv;
- exec->TexGend = _mesa_TexGend;
- exec->TexGendv = _mesa_TexGendv;
- exec->TexGenf = _mesa_TexGenf;
- exec->TexGenfv = _mesa_TexGenfv;
- exec->TexGeni = _mesa_TexGeni;
- exec->TexGeniv = _mesa_TexGeniv;
- exec->TexImage1D = _mesa_TexImage1D;
- exec->TexParameterf = _mesa_TexParameterf;
- exec->TexParameterfv = _mesa_TexParameterfv;
- exec->TexParameteriv = _mesa_TexParameteriv;
- exec->Translated = _mesa_Translated;
+ SET_Accum(exec, _mesa_Accum);
+ SET_Bitmap(exec, _mesa_Bitmap);
+ SET_CallList(exec, _mesa_CallList);
+ SET_CallLists(exec, _mesa_CallLists);
+ SET_ClearAccum(exec, _mesa_ClearAccum);
+ SET_ClearDepth(exec, _mesa_ClearDepth);
+ SET_ClearIndex(exec, _mesa_ClearIndex);
+ SET_ClipPlane(exec, _mesa_ClipPlane);
+ SET_ColorMaterial(exec, _mesa_ColorMaterial);
+ SET_CopyPixels(exec, _mesa_CopyPixels);
+ SET_CullParameterfvEXT(exec, _mesa_CullParameterfvEXT);
+ SET_CullParameterdvEXT(exec, _mesa_CullParameterdvEXT);
+ SET_DeleteLists(exec, _mesa_DeleteLists);
+ SET_DepthFunc(exec, _mesa_DepthFunc);
+ SET_DepthMask(exec, _mesa_DepthMask);
+ SET_DepthRange(exec, _mesa_DepthRange);
+ SET_DrawPixels(exec, _mesa_DrawPixels);
+ SET_EndList(exec, _mesa_EndList);
+ SET_FeedbackBuffer(exec, _mesa_FeedbackBuffer);
+ SET_FogCoordPointerEXT(exec, _mesa_FogCoordPointerEXT);
+ SET_Fogf(exec, _mesa_Fogf);
+ SET_Fogfv(exec, _mesa_Fogfv);
+ SET_Fogi(exec, _mesa_Fogi);
+ SET_Fogiv(exec, _mesa_Fogiv);
+ SET_GenLists(exec, _mesa_GenLists);
+ SET_GetClipPlane(exec, _mesa_GetClipPlane);
+ SET_GetBooleanv(exec, _mesa_GetBooleanv);
+ SET_GetDoublev(exec, _mesa_GetDoublev);
+ SET_GetIntegerv(exec, _mesa_GetIntegerv);
+ SET_GetLightfv(exec, _mesa_GetLightfv);
+ SET_GetLightiv(exec, _mesa_GetLightiv);
+ SET_GetMapdv(exec, _mesa_GetMapdv);
+ SET_GetMapfv(exec, _mesa_GetMapfv);
+ SET_GetMapiv(exec, _mesa_GetMapiv);
+ SET_GetMaterialfv(exec, _mesa_GetMaterialfv);
+ SET_GetMaterialiv(exec, _mesa_GetMaterialiv);
+ SET_GetPixelMapfv(exec, _mesa_GetPixelMapfv);
+ SET_GetPixelMapuiv(exec, _mesa_GetPixelMapuiv);
+ SET_GetPixelMapusv(exec, _mesa_GetPixelMapusv);
+ SET_GetPolygonStipple(exec, _mesa_GetPolygonStipple);
+ SET_GetTexEnvfv(exec, _mesa_GetTexEnvfv);
+ SET_GetTexEnviv(exec, _mesa_GetTexEnviv);
+ SET_GetTexLevelParameterfv(exec, _mesa_GetTexLevelParameterfv);
+ SET_GetTexLevelParameteriv(exec, _mesa_GetTexLevelParameteriv);
+ SET_GetTexParameterfv(exec, _mesa_GetTexParameterfv);
+ SET_GetTexParameteriv(exec, _mesa_GetTexParameteriv);
+ SET_GetTexGendv(exec, _mesa_GetTexGendv);
+ SET_GetTexGenfv(exec, _mesa_GetTexGenfv);
+ SET_GetTexGeniv(exec, _mesa_GetTexGeniv);
+ SET_GetTexImage(exec, _mesa_GetTexImage);
+ SET_Hint(exec, _mesa_Hint);
+ SET_IndexMask(exec, _mesa_IndexMask);
+ SET_IsEnabled(exec, _mesa_IsEnabled);
+ SET_IsList(exec, _mesa_IsList);
+ SET_LightModelf(exec, _mesa_LightModelf);
+ SET_LightModelfv(exec, _mesa_LightModelfv);
+ SET_LightModeli(exec, _mesa_LightModeli);
+ SET_LightModeliv(exec, _mesa_LightModeliv);
+ SET_Lightf(exec, _mesa_Lightf);
+ SET_Lightfv(exec, _mesa_Lightfv);
+ SET_Lighti(exec, _mesa_Lighti);
+ SET_Lightiv(exec, _mesa_Lightiv);
+ SET_ListBase(exec, _mesa_ListBase);
+ SET_LoadMatrixd(exec, _mesa_LoadMatrixd);
+ SET_Map1d(exec, _mesa_Map1d);
+ SET_Map1f(exec, _mesa_Map1f);
+ SET_Map2d(exec, _mesa_Map2d);
+ SET_Map2f(exec, _mesa_Map2f);
+ SET_MapGrid1d(exec, _mesa_MapGrid1d);
+ SET_MapGrid1f(exec, _mesa_MapGrid1f);
+ SET_MapGrid2d(exec, _mesa_MapGrid2d);
+ SET_MapGrid2f(exec, _mesa_MapGrid2f);
+ SET_MultMatrixd(exec, _mesa_MultMatrixd);
+ SET_NewList(exec, _mesa_NewList);
+ SET_PassThrough(exec, _mesa_PassThrough);
+ SET_PixelMapfv(exec, _mesa_PixelMapfv);
+ SET_PixelMapuiv(exec, _mesa_PixelMapuiv);
+ SET_PixelMapusv(exec, _mesa_PixelMapusv);
+ SET_PixelStoref(exec, _mesa_PixelStoref);
+ SET_PixelTransferf(exec, _mesa_PixelTransferf);
+ SET_PixelTransferi(exec, _mesa_PixelTransferi);
+ SET_PixelZoom(exec, _mesa_PixelZoom);
+ SET_PointSize(exec, _mesa_PointSize);
+ SET_PolygonMode(exec, _mesa_PolygonMode);
+ SET_PolygonOffset(exec, _mesa_PolygonOffset);
+ SET_PolygonStipple(exec, _mesa_PolygonStipple);
+ SET_PopAttrib(exec, _mesa_PopAttrib);
+ SET_PushAttrib(exec, _mesa_PushAttrib);
+ SET_RasterPos2d(exec, _mesa_RasterPos2d);
+ SET_RasterPos2dv(exec, _mesa_RasterPos2dv);
+ SET_RasterPos2s(exec, _mesa_RasterPos2s);
+ SET_RasterPos2sv(exec, _mesa_RasterPos2sv);
+ SET_RasterPos3d(exec, _mesa_RasterPos3d);
+ SET_RasterPos3dv(exec, _mesa_RasterPos3dv);
+ SET_RasterPos3f(exec, _mesa_RasterPos3f);
+ SET_RasterPos3fv(exec, _mesa_RasterPos3fv);
+ SET_RasterPos3i(exec, _mesa_RasterPos3i);
+ SET_RasterPos3iv(exec, _mesa_RasterPos3iv);
+ SET_RasterPos3s(exec, _mesa_RasterPos3s);
+ SET_RasterPos3sv(exec, _mesa_RasterPos3sv);
+ SET_RasterPos4d(exec, _mesa_RasterPos4d);
+ SET_RasterPos4dv(exec, _mesa_RasterPos4dv);
+ SET_RasterPos4f(exec, _mesa_RasterPos4f);
+ SET_RasterPos4fv(exec, _mesa_RasterPos4fv);
+ SET_RasterPos4i(exec, _mesa_RasterPos4i);
+ SET_RasterPos4iv(exec, _mesa_RasterPos4iv);
+ SET_RasterPos4s(exec, _mesa_RasterPos4s);
+ SET_RasterPos4sv(exec, _mesa_RasterPos4sv);
+ SET_ReadPixels(exec, _mesa_ReadPixels);
+ SET_Rotated(exec, _mesa_Rotated);
+ SET_Scaled(exec, _mesa_Scaled);
+ SET_SecondaryColorPointerEXT(exec, _mesa_SecondaryColorPointerEXT);
+ SET_TexEnvf(exec, _mesa_TexEnvf);
+ SET_TexEnviv(exec, _mesa_TexEnviv);
+ SET_TexGend(exec, _mesa_TexGend);
+ SET_TexGendv(exec, _mesa_TexGendv);
+ SET_TexGenf(exec, _mesa_TexGenf);
+ SET_TexGenfv(exec, _mesa_TexGenfv);
+ SET_TexGeni(exec, _mesa_TexGeni);
+ SET_TexGeniv(exec, _mesa_TexGeniv);
+ SET_TexImage1D(exec, _mesa_TexImage1D);
+ SET_TexParameterf(exec, _mesa_TexParameterf);
+ SET_TexParameterfv(exec, _mesa_TexParameterfv);
+ SET_TexParameteriv(exec, _mesa_TexParameteriv);
+ SET_Translated(exec, _mesa_Translated);
#endif
/* 1.1 */
- exec->BindTexture = _mesa_BindTexture;
- exec->DeleteTextures = _mesa_DeleteTextures;
- exec->GenTextures = _mesa_GenTextures;
+ SET_BindTexture(exec, _mesa_BindTexture);
+ SET_DeleteTextures(exec, _mesa_DeleteTextures);
+ SET_GenTextures(exec, _mesa_GenTextures);
#if _HAVE_FULL_GL
- exec->AreTexturesResident = _mesa_AreTexturesResident;
- exec->AreTexturesResidentEXT = _mesa_AreTexturesResident;
- exec->ColorPointer = _mesa_ColorPointer;
- exec->CopyTexImage1D = _mesa_CopyTexImage1D;
- exec->CopyTexImage2D = _mesa_CopyTexImage2D;
- exec->CopyTexSubImage1D = _mesa_CopyTexSubImage1D;
- exec->CopyTexSubImage2D = _mesa_CopyTexSubImage2D;
- exec->DisableClientState = _mesa_DisableClientState;
- exec->EdgeFlagPointer = _mesa_EdgeFlagPointer;
- exec->EnableClientState = _mesa_EnableClientState;
- exec->GenTexturesEXT = _mesa_GenTextures;
- exec->GetPointerv = _mesa_GetPointerv;
- exec->IndexPointer = _mesa_IndexPointer;
- exec->InterleavedArrays = _mesa_InterleavedArrays;
- exec->IsTexture = _mesa_IsTexture;
- exec->IsTextureEXT = _mesa_IsTexture;
- exec->NormalPointer = _mesa_NormalPointer;
- exec->PopClientAttrib = _mesa_PopClientAttrib;
- exec->PrioritizeTextures = _mesa_PrioritizeTextures;
- exec->PushClientAttrib = _mesa_PushClientAttrib;
- exec->TexCoordPointer = _mesa_TexCoordPointer;
- exec->TexSubImage1D = _mesa_TexSubImage1D;
- exec->TexSubImage2D = _mesa_TexSubImage2D;
- exec->VertexPointer = _mesa_VertexPointer;
+ SET_AreTexturesResident(exec, _mesa_AreTexturesResident);
+ SET_AreTexturesResidentEXT(exec, _mesa_AreTexturesResident);
+ SET_ColorPointer(exec, _mesa_ColorPointer);
+ SET_CopyTexImage1D(exec, _mesa_CopyTexImage1D);
+ SET_CopyTexImage2D(exec, _mesa_CopyTexImage2D);
+ SET_CopyTexSubImage1D(exec, _mesa_CopyTexSubImage1D);
+ SET_CopyTexSubImage2D(exec, _mesa_CopyTexSubImage2D);
+ SET_DisableClientState(exec, _mesa_DisableClientState);
+ SET_EdgeFlagPointer(exec, _mesa_EdgeFlagPointer);
+ SET_EnableClientState(exec, _mesa_EnableClientState);
+ SET_GenTexturesEXT(exec, _mesa_GenTextures);
+ SET_GetPointerv(exec, _mesa_GetPointerv);
+ SET_IndexPointer(exec, _mesa_IndexPointer);
+ SET_InterleavedArrays(exec, _mesa_InterleavedArrays);
+ SET_IsTexture(exec, _mesa_IsTexture);
+ SET_IsTextureEXT(exec, _mesa_IsTexture);
+ SET_NormalPointer(exec, _mesa_NormalPointer);
+ SET_PopClientAttrib(exec, _mesa_PopClientAttrib);
+ SET_PrioritizeTextures(exec, _mesa_PrioritizeTextures);
+ SET_PushClientAttrib(exec, _mesa_PushClientAttrib);
+ SET_TexCoordPointer(exec, _mesa_TexCoordPointer);
+ SET_TexSubImage1D(exec, _mesa_TexSubImage1D);
+ SET_TexSubImage2D(exec, _mesa_TexSubImage2D);
+ SET_VertexPointer(exec, _mesa_VertexPointer);
#endif
/* 1.2 */
#if _HAVE_FULL_GL
- exec->CopyTexSubImage3D = _mesa_CopyTexSubImage3D;
- exec->TexImage3D = _mesa_TexImage3D;
- exec->TexSubImage3D = _mesa_TexSubImage3D;
+ SET_CopyTexSubImage3D(exec, _mesa_CopyTexSubImage3D);
+ SET_TexImage3D(exec, _mesa_TexImage3D);
+ SET_TexSubImage3D(exec, _mesa_TexSubImage3D);
#endif
/* OpenGL 1.2 GL_ARB_imaging */
#if _HAVE_FULL_GL
- exec->BlendColor = _mesa_BlendColor;
- exec->BlendEquation = _mesa_BlendEquation;
- exec->BlendEquationSeparateEXT = _mesa_BlendEquationSeparateEXT;
- exec->ColorSubTable = _mesa_ColorSubTable;
- exec->ColorTable = _mesa_ColorTable;
- exec->ColorTableParameterfv = _mesa_ColorTableParameterfv;
- exec->ColorTableParameteriv = _mesa_ColorTableParameteriv;
- exec->ConvolutionFilter1D = _mesa_ConvolutionFilter1D;
- exec->ConvolutionFilter2D = _mesa_ConvolutionFilter2D;
- exec->ConvolutionParameterf = _mesa_ConvolutionParameterf;
- exec->ConvolutionParameterfv = _mesa_ConvolutionParameterfv;
- exec->ConvolutionParameteri = _mesa_ConvolutionParameteri;
- exec->ConvolutionParameteriv = _mesa_ConvolutionParameteriv;
- exec->CopyColorSubTable = _mesa_CopyColorSubTable;
- exec->CopyColorTable = _mesa_CopyColorTable;
- exec->CopyConvolutionFilter1D = _mesa_CopyConvolutionFilter1D;
- exec->CopyConvolutionFilter2D = _mesa_CopyConvolutionFilter2D;
- exec->GetColorTable = _mesa_GetColorTable;
- exec->GetColorTableEXT = _mesa_GetColorTable;
- exec->GetColorTableParameterfv = _mesa_GetColorTableParameterfv;
- exec->GetColorTableParameterfvEXT = _mesa_GetColorTableParameterfv;
- exec->GetColorTableParameteriv = _mesa_GetColorTableParameteriv;
- exec->GetColorTableParameterivEXT = _mesa_GetColorTableParameteriv;
- exec->GetConvolutionFilter = _mesa_GetConvolutionFilter;
- exec->GetConvolutionFilterEXT = _mesa_GetConvolutionFilter;
- exec->GetConvolutionParameterfv = _mesa_GetConvolutionParameterfv;
- exec->GetConvolutionParameterfvEXT = _mesa_GetConvolutionParameterfv;
- exec->GetConvolutionParameteriv = _mesa_GetConvolutionParameteriv;
- exec->GetConvolutionParameterivEXT = _mesa_GetConvolutionParameteriv;
- exec->GetHistogram = _mesa_GetHistogram;
- exec->GetHistogramEXT = _mesa_GetHistogram;
- exec->GetHistogramParameterfv = _mesa_GetHistogramParameterfv;
- exec->GetHistogramParameterfvEXT = _mesa_GetHistogramParameterfv;
- exec->GetHistogramParameteriv = _mesa_GetHistogramParameteriv;
- exec->GetHistogramParameterivEXT = _mesa_GetHistogramParameteriv;
- exec->GetMinmax = _mesa_GetMinmax;
- exec->GetMinmaxEXT = _mesa_GetMinmax;
- exec->GetMinmaxParameterfv = _mesa_GetMinmaxParameterfv;
- exec->GetMinmaxParameterfvEXT = _mesa_GetMinmaxParameterfv;
- exec->GetMinmaxParameteriv = _mesa_GetMinmaxParameteriv;
- exec->GetMinmaxParameterivEXT = _mesa_GetMinmaxParameteriv;
- exec->GetSeparableFilter = _mesa_GetSeparableFilter;
- exec->GetSeparableFilterEXT = _mesa_GetSeparableFilter;
- exec->Histogram = _mesa_Histogram;
- exec->Minmax = _mesa_Minmax;
- exec->ResetHistogram = _mesa_ResetHistogram;
- exec->ResetMinmax = _mesa_ResetMinmax;
- exec->SeparableFilter2D = _mesa_SeparableFilter2D;
+ SET_BlendColor(exec, _mesa_BlendColor);
+ SET_BlendEquation(exec, _mesa_BlendEquation);
+ SET_BlendEquationSeparateEXT(exec, _mesa_BlendEquationSeparateEXT);
+ SET_ColorSubTable(exec, _mesa_ColorSubTable);
+ SET_ColorTable(exec, _mesa_ColorTable);
+ SET_ColorTableParameterfv(exec, _mesa_ColorTableParameterfv);
+ SET_ColorTableParameteriv(exec, _mesa_ColorTableParameteriv);
+ SET_ConvolutionFilter1D(exec, _mesa_ConvolutionFilter1D);
+ SET_ConvolutionFilter2D(exec, _mesa_ConvolutionFilter2D);
+ SET_ConvolutionParameterf(exec, _mesa_ConvolutionParameterf);
+ SET_ConvolutionParameterfv(exec, _mesa_ConvolutionParameterfv);
+ SET_ConvolutionParameteri(exec, _mesa_ConvolutionParameteri);
+ SET_ConvolutionParameteriv(exec, _mesa_ConvolutionParameteriv);
+ SET_CopyColorSubTable(exec, _mesa_CopyColorSubTable);
+ SET_CopyColorTable(exec, _mesa_CopyColorTable);
+ SET_CopyConvolutionFilter1D(exec, _mesa_CopyConvolutionFilter1D);
+ SET_CopyConvolutionFilter2D(exec, _mesa_CopyConvolutionFilter2D);
+ SET_GetColorTable(exec, _mesa_GetColorTable);
+ SET_GetColorTableEXT(exec, _mesa_GetColorTable);
+ SET_GetColorTableParameterfv(exec, _mesa_GetColorTableParameterfv);
+ SET_GetColorTableParameterfvEXT(exec, _mesa_GetColorTableParameterfv);
+ SET_GetColorTableParameteriv(exec, _mesa_GetColorTableParameteriv);
+ SET_GetColorTableParameterivEXT(exec, _mesa_GetColorTableParameteriv);
+ SET_GetConvolutionFilter(exec, _mesa_GetConvolutionFilter);
+ SET_GetConvolutionFilterEXT(exec, _mesa_GetConvolutionFilter);
+ SET_GetConvolutionParameterfv(exec, _mesa_GetConvolutionParameterfv);
+ SET_GetConvolutionParameterfvEXT(exec, _mesa_GetConvolutionParameterfv);
+ SET_GetConvolutionParameteriv(exec, _mesa_GetConvolutionParameteriv);
+ SET_GetConvolutionParameterivEXT(exec, _mesa_GetConvolutionParameteriv);
+ SET_GetHistogram(exec, _mesa_GetHistogram);
+ SET_GetHistogramEXT(exec, _mesa_GetHistogram);
+ SET_GetHistogramParameterfv(exec, _mesa_GetHistogramParameterfv);
+ SET_GetHistogramParameterfvEXT(exec, _mesa_GetHistogramParameterfv);
+ SET_GetHistogramParameteriv(exec, _mesa_GetHistogramParameteriv);
+ SET_GetHistogramParameterivEXT(exec, _mesa_GetHistogramParameteriv);
+ SET_GetMinmax(exec, _mesa_GetMinmax);
+ SET_GetMinmaxEXT(exec, _mesa_GetMinmax);
+ SET_GetMinmaxParameterfv(exec, _mesa_GetMinmaxParameterfv);
+ SET_GetMinmaxParameterfvEXT(exec, _mesa_GetMinmaxParameterfv);
+ SET_GetMinmaxParameteriv(exec, _mesa_GetMinmaxParameteriv);
+ SET_GetMinmaxParameterivEXT(exec, _mesa_GetMinmaxParameteriv);
+ SET_GetSeparableFilter(exec, _mesa_GetSeparableFilter);
+ SET_GetSeparableFilterEXT(exec, _mesa_GetSeparableFilter);
+ SET_Histogram(exec, _mesa_Histogram);
+ SET_Minmax(exec, _mesa_Minmax);
+ SET_ResetHistogram(exec, _mesa_ResetHistogram);
+ SET_ResetMinmax(exec, _mesa_ResetMinmax);
+ SET_SeparableFilter2D(exec, _mesa_SeparableFilter2D);
#endif
/* OpenGL 2.0 */
- exec->StencilFuncSeparate = _mesa_StencilFuncSeparate;
- exec->StencilMaskSeparate = _mesa_StencilMaskSeparate;
- exec->StencilOpSeparate = _mesa_StencilOpSeparate;
+ SET_StencilFuncSeparate(exec, _mesa_StencilFuncSeparate);
+ SET_StencilMaskSeparate(exec, _mesa_StencilMaskSeparate);
+ SET_StencilOpSeparate(exec, _mesa_StencilOpSeparate);
/* 2. GL_EXT_blend_color */
#if 0
-/* exec->BlendColorEXT = _mesa_BlendColorEXT; */
+/* SET_BlendColorEXT(exec, _mesa_BlendColorEXT); */
#endif
/* 3. GL_EXT_polygon_offset */
#if _HAVE_FULL_GL
- exec->PolygonOffsetEXT = _mesa_PolygonOffsetEXT;
+ SET_PolygonOffsetEXT(exec, _mesa_PolygonOffsetEXT);
#endif
/* 6. GL_EXT_texture3d */
#if 0
-/* exec->CopyTexSubImage3DEXT = _mesa_CopyTexSubImage3D; */
-/* exec->TexImage3DEXT = _mesa_TexImage3DEXT; */
-/* exec->TexSubImage3DEXT = _mesa_TexSubImage3D; */
+/* SET_CopyTexSubImage3DEXT(exec, _mesa_CopyTexSubImage3D); */
+/* SET_TexImage3DEXT(exec, _mesa_TexImage3DEXT); */
+/* SET_TexSubImage3DEXT(exec, _mesa_TexSubImage3D); */
#endif
/* 11. GL_EXT_histogram */
#if _HAVE_FULL_GL
- exec->GetHistogramEXT = _mesa_GetHistogram;
- exec->GetHistogramParameterfvEXT = _mesa_GetHistogramParameterfv;
- exec->GetHistogramParameterivEXT = _mesa_GetHistogramParameteriv;
- exec->GetMinmaxEXT = _mesa_GetMinmax;
- exec->GetMinmaxParameterfvEXT = _mesa_GetMinmaxParameterfv;
- exec->GetMinmaxParameterivEXT = _mesa_GetMinmaxParameteriv;
+ SET_GetHistogramEXT(exec, _mesa_GetHistogram);
+ SET_GetHistogramParameterfvEXT(exec, _mesa_GetHistogramParameterfv);
+ SET_GetHistogramParameterivEXT(exec, _mesa_GetHistogramParameteriv);
+ SET_GetMinmaxEXT(exec, _mesa_GetMinmax);
+ SET_GetMinmaxParameterfvEXT(exec, _mesa_GetMinmaxParameterfv);
+ SET_GetMinmaxParameterivEXT(exec, _mesa_GetMinmaxParameteriv);
#endif
/* ?. GL_SGIX_pixel_texture */
#if _HAVE_FULL_GL
- exec->PixelTexGenSGIX = _mesa_PixelTexGenSGIX;
+ SET_PixelTexGenSGIX(exec, _mesa_PixelTexGenSGIX);
#endif
/* 15. GL_SGIS_pixel_texture */
#if _HAVE_FULL_GL
- exec->PixelTexGenParameteriSGIS = _mesa_PixelTexGenParameteriSGIS;
- exec->PixelTexGenParameterivSGIS = _mesa_PixelTexGenParameterivSGIS;
- exec->PixelTexGenParameterfSGIS = _mesa_PixelTexGenParameterfSGIS;
- exec->PixelTexGenParameterfvSGIS = _mesa_PixelTexGenParameterfvSGIS;
- exec->GetPixelTexGenParameterivSGIS = _mesa_GetPixelTexGenParameterivSGIS;
- exec->GetPixelTexGenParameterfvSGIS = _mesa_GetPixelTexGenParameterfvSGIS;
+ SET_PixelTexGenParameteriSGIS(exec, _mesa_PixelTexGenParameteriSGIS);
+ SET_PixelTexGenParameterivSGIS(exec, _mesa_PixelTexGenParameterivSGIS);
+ SET_PixelTexGenParameterfSGIS(exec, _mesa_PixelTexGenParameterfSGIS);
+ SET_PixelTexGenParameterfvSGIS(exec, _mesa_PixelTexGenParameterfvSGIS);
+ SET_GetPixelTexGenParameterivSGIS(exec, _mesa_GetPixelTexGenParameterivSGIS);
+ SET_GetPixelTexGenParameterfvSGIS(exec, _mesa_GetPixelTexGenParameterfvSGIS);
#endif
/* 30. GL_EXT_vertex_array */
#if _HAVE_FULL_GL
- exec->ColorPointerEXT = _mesa_ColorPointerEXT;
- exec->EdgeFlagPointerEXT = _mesa_EdgeFlagPointerEXT;
- exec->IndexPointerEXT = _mesa_IndexPointerEXT;
- exec->NormalPointerEXT = _mesa_NormalPointerEXT;
- exec->TexCoordPointerEXT = _mesa_TexCoordPointerEXT;
- exec->VertexPointerEXT = _mesa_VertexPointerEXT;
+ SET_ColorPointerEXT(exec, _mesa_ColorPointerEXT);
+ SET_EdgeFlagPointerEXT(exec, _mesa_EdgeFlagPointerEXT);
+ SET_IndexPointerEXT(exec, _mesa_IndexPointerEXT);
+ SET_NormalPointerEXT(exec, _mesa_NormalPointerEXT);
+ SET_TexCoordPointerEXT(exec, _mesa_TexCoordPointerEXT);
+ SET_VertexPointerEXT(exec, _mesa_VertexPointerEXT);
#endif
/* 37. GL_EXT_blend_minmax */
#if 0
- exec->BlendEquationEXT = _mesa_BlendEquationEXT;
+ SET_BlendEquationEXT(exec, _mesa_BlendEquationEXT);
#endif
/* 54. GL_EXT_point_parameters */
#if _HAVE_FULL_GL
- exec->PointParameterfEXT = _mesa_PointParameterfEXT;
- exec->PointParameterfvEXT = _mesa_PointParameterfvEXT;
+ SET_PointParameterfEXT(exec, _mesa_PointParameterfEXT);
+ SET_PointParameterfvEXT(exec, _mesa_PointParameterfvEXT);
#endif
/* 78. GL_EXT_paletted_texture */
#if 0
- exec->ColorTableEXT = _mesa_ColorTableEXT;
- exec->ColorSubTableEXT = _mesa_ColorSubTableEXT;
+ SET_ColorTableEXT(exec, _mesa_ColorTableEXT);
+ SET_ColorSubTableEXT(exec, _mesa_ColorSubTableEXT);
#endif
#if _HAVE_FULL_GL
- exec->GetColorTableEXT = _mesa_GetColorTable;
- exec->GetColorTableParameterfvEXT = _mesa_GetColorTableParameterfv;
- exec->GetColorTableParameterivEXT = _mesa_GetColorTableParameteriv;
+ SET_GetColorTableEXT(exec, _mesa_GetColorTable);
+ SET_GetColorTableParameterfvEXT(exec, _mesa_GetColorTableParameterfv);
+ SET_GetColorTableParameterivEXT(exec, _mesa_GetColorTableParameteriv);
#endif
/* 97. GL_EXT_compiled_vertex_array */
#if _HAVE_FULL_GL
- exec->LockArraysEXT = _mesa_LockArraysEXT;
- exec->UnlockArraysEXT = _mesa_UnlockArraysEXT;
+ SET_LockArraysEXT(exec, _mesa_LockArraysEXT);
+ SET_UnlockArraysEXT(exec, _mesa_UnlockArraysEXT);
#endif
/* 148. GL_EXT_multi_draw_arrays */
#if _HAVE_FULL_GL
- exec->MultiDrawArraysEXT = _mesa_MultiDrawArraysEXT;
- exec->MultiDrawElementsEXT = _mesa_MultiDrawElementsEXT;
+ SET_MultiDrawArraysEXT(exec, _mesa_MultiDrawArraysEXT);
+ SET_MultiDrawElementsEXT(exec, _mesa_MultiDrawElementsEXT);
#endif
/* 173. GL_INGR_blend_func_separate */
#if _HAVE_FULL_GL
- exec->BlendFuncSeparateEXT = _mesa_BlendFuncSeparateEXT;
+ SET_BlendFuncSeparateEXT(exec, _mesa_BlendFuncSeparateEXT);
#endif
/* 196. GL_MESA_resize_buffers */
#if _HAVE_FULL_GL
- exec->ResizeBuffersMESA = _mesa_ResizeBuffersMESA;
+ SET_ResizeBuffersMESA(exec, _mesa_ResizeBuffersMESA);
#endif
/* 197. GL_MESA_window_pos */
#if _HAVE_FULL_GL
- exec->WindowPos2dMESA = _mesa_WindowPos2dMESA;
- exec->WindowPos2dvMESA = _mesa_WindowPos2dvMESA;
- exec->WindowPos2fMESA = _mesa_WindowPos2fMESA;
- exec->WindowPos2fvMESA = _mesa_WindowPos2fvMESA;
- exec->WindowPos2iMESA = _mesa_WindowPos2iMESA;
- exec->WindowPos2ivMESA = _mesa_WindowPos2ivMESA;
- exec->WindowPos2sMESA = _mesa_WindowPos2sMESA;
- exec->WindowPos2svMESA = _mesa_WindowPos2svMESA;
- exec->WindowPos3dMESA = _mesa_WindowPos3dMESA;
- exec->WindowPos3dvMESA = _mesa_WindowPos3dvMESA;
- exec->WindowPos3fMESA = _mesa_WindowPos3fMESA;
- exec->WindowPos3fvMESA = _mesa_WindowPos3fvMESA;
- exec->WindowPos3iMESA = _mesa_WindowPos3iMESA;
- exec->WindowPos3ivMESA = _mesa_WindowPos3ivMESA;
- exec->WindowPos3sMESA = _mesa_WindowPos3sMESA;
- exec->WindowPos3svMESA = _mesa_WindowPos3svMESA;
- exec->WindowPos4dMESA = _mesa_WindowPos4dMESA;
- exec->WindowPos4dvMESA = _mesa_WindowPos4dvMESA;
- exec->WindowPos4fMESA = _mesa_WindowPos4fMESA;
- exec->WindowPos4fvMESA = _mesa_WindowPos4fvMESA;
- exec->WindowPos4iMESA = _mesa_WindowPos4iMESA;
- exec->WindowPos4ivMESA = _mesa_WindowPos4ivMESA;
- exec->WindowPos4sMESA = _mesa_WindowPos4sMESA;
- exec->WindowPos4svMESA = _mesa_WindowPos4svMESA;
+ SET_WindowPos2dMESA(exec, _mesa_WindowPos2dMESA);
+ SET_WindowPos2dvMESA(exec, _mesa_WindowPos2dvMESA);
+ SET_WindowPos2fMESA(exec, _mesa_WindowPos2fMESA);
+ SET_WindowPos2fvMESA(exec, _mesa_WindowPos2fvMESA);
+ SET_WindowPos2iMESA(exec, _mesa_WindowPos2iMESA);
+ SET_WindowPos2ivMESA(exec, _mesa_WindowPos2ivMESA);
+ SET_WindowPos2sMESA(exec, _mesa_WindowPos2sMESA);
+ SET_WindowPos2svMESA(exec, _mesa_WindowPos2svMESA);
+ SET_WindowPos3dMESA(exec, _mesa_WindowPos3dMESA);
+ SET_WindowPos3dvMESA(exec, _mesa_WindowPos3dvMESA);
+ SET_WindowPos3fMESA(exec, _mesa_WindowPos3fMESA);
+ SET_WindowPos3fvMESA(exec, _mesa_WindowPos3fvMESA);
+ SET_WindowPos3iMESA(exec, _mesa_WindowPos3iMESA);
+ SET_WindowPos3ivMESA(exec, _mesa_WindowPos3ivMESA);
+ SET_WindowPos3sMESA(exec, _mesa_WindowPos3sMESA);
+ SET_WindowPos3svMESA(exec, _mesa_WindowPos3svMESA);
+ SET_WindowPos4dMESA(exec, _mesa_WindowPos4dMESA);
+ SET_WindowPos4dvMESA(exec, _mesa_WindowPos4dvMESA);
+ SET_WindowPos4fMESA(exec, _mesa_WindowPos4fMESA);
+ SET_WindowPos4fvMESA(exec, _mesa_WindowPos4fvMESA);
+ SET_WindowPos4iMESA(exec, _mesa_WindowPos4iMESA);
+ SET_WindowPos4ivMESA(exec, _mesa_WindowPos4ivMESA);
+ SET_WindowPos4sMESA(exec, _mesa_WindowPos4sMESA);
+ SET_WindowPos4svMESA(exec, _mesa_WindowPos4svMESA);
#endif
/* 200. GL_IBM_multimode_draw_arrays */
#if _HAVE_FULL_GL
- exec->MultiModeDrawArraysIBM = _mesa_MultiModeDrawArraysIBM;
- exec->MultiModeDrawElementsIBM = _mesa_MultiModeDrawElementsIBM;
+ SET_MultiModeDrawArraysIBM(exec, _mesa_MultiModeDrawArraysIBM);
+ SET_MultiModeDrawElementsIBM(exec, _mesa_MultiModeDrawElementsIBM);
#endif
/* 233. GL_NV_vertex_program */
#if FEATURE_NV_vertex_program
- exec->BindProgramNV = _mesa_BindProgram;
- exec->DeleteProgramsNV = _mesa_DeletePrograms;
- exec->ExecuteProgramNV = _mesa_ExecuteProgramNV;
- exec->GenProgramsNV = _mesa_GenPrograms;
- exec->AreProgramsResidentNV = _mesa_AreProgramsResidentNV;
- exec->RequestResidentProgramsNV = _mesa_RequestResidentProgramsNV;
- exec->GetProgramParameterfvNV = _mesa_GetProgramParameterfvNV;
- exec->GetProgramParameterdvNV = _mesa_GetProgramParameterdvNV;
- exec->GetProgramivNV = _mesa_GetProgramivNV;
- exec->GetProgramStringNV = _mesa_GetProgramStringNV;
- exec->GetTrackMatrixivNV = _mesa_GetTrackMatrixivNV;
- exec->GetVertexAttribdvNV = _mesa_GetVertexAttribdvNV;
- exec->GetVertexAttribfvNV = _mesa_GetVertexAttribfvNV;
- exec->GetVertexAttribivNV = _mesa_GetVertexAttribivNV;
- exec->GetVertexAttribPointervNV = _mesa_GetVertexAttribPointervNV;
- exec->IsProgramNV = _mesa_IsProgram;
- exec->LoadProgramNV = _mesa_LoadProgramNV;
- exec->ProgramParameter4dNV = _mesa_ProgramParameter4dNV;
- exec->ProgramParameter4dvNV = _mesa_ProgramParameter4dvNV;
- exec->ProgramParameter4fNV = _mesa_ProgramParameter4fNV;
- exec->ProgramParameter4fvNV = _mesa_ProgramParameter4fvNV;
- exec->ProgramParameters4dvNV = _mesa_ProgramParameters4dvNV;
- exec->ProgramParameters4fvNV = _mesa_ProgramParameters4fvNV;
- exec->TrackMatrixNV = _mesa_TrackMatrixNV;
- exec->VertexAttribPointerNV = _mesa_VertexAttribPointerNV;
+ SET_BindProgramNV(exec, _mesa_BindProgram);
+ SET_DeleteProgramsNV(exec, _mesa_DeletePrograms);
+ SET_ExecuteProgramNV(exec, _mesa_ExecuteProgramNV);
+ SET_GenProgramsNV(exec, _mesa_GenPrograms);
+ SET_AreProgramsResidentNV(exec, _mesa_AreProgramsResidentNV);
+ SET_RequestResidentProgramsNV(exec, _mesa_RequestResidentProgramsNV);
+ SET_GetProgramParameterfvNV(exec, _mesa_GetProgramParameterfvNV);
+ SET_GetProgramParameterdvNV(exec, _mesa_GetProgramParameterdvNV);
+ SET_GetProgramivNV(exec, _mesa_GetProgramivNV);
+ SET_GetProgramStringNV(exec, _mesa_GetProgramStringNV);
+ SET_GetTrackMatrixivNV(exec, _mesa_GetTrackMatrixivNV);
+ SET_GetVertexAttribdvNV(exec, _mesa_GetVertexAttribdvNV);
+ SET_GetVertexAttribfvNV(exec, _mesa_GetVertexAttribfvNV);
+ SET_GetVertexAttribivNV(exec, _mesa_GetVertexAttribivNV);
+ SET_GetVertexAttribPointervNV(exec, _mesa_GetVertexAttribPointervNV);
+ SET_IsProgramNV(exec, _mesa_IsProgram);
+ SET_LoadProgramNV(exec, _mesa_LoadProgramNV);
+ SET_ProgramParameter4dNV(exec, _mesa_ProgramParameter4dNV);
+ SET_ProgramParameter4dvNV(exec, _mesa_ProgramParameter4dvNV);
+ SET_ProgramParameter4fNV(exec, _mesa_ProgramParameter4fNV);
+ SET_ProgramParameter4fvNV(exec, _mesa_ProgramParameter4fvNV);
+ SET_ProgramParameters4dvNV(exec, _mesa_ProgramParameters4dvNV);
+ SET_ProgramParameters4fvNV(exec, _mesa_ProgramParameters4fvNV);
+ SET_TrackMatrixNV(exec, _mesa_TrackMatrixNV);
+ SET_VertexAttribPointerNV(exec, _mesa_VertexAttribPointerNV);
/* glVertexAttrib*NV functions handled in api_loopback.c */
#endif
/* 282. GL_NV_fragment_program */
#if FEATURE_NV_fragment_program
- exec->ProgramNamedParameter4fNV = _mesa_ProgramNamedParameter4fNV;
- exec->ProgramNamedParameter4dNV = _mesa_ProgramNamedParameter4dNV;
- exec->ProgramNamedParameter4fvNV = _mesa_ProgramNamedParameter4fvNV;
- exec->ProgramNamedParameter4dvNV = _mesa_ProgramNamedParameter4dvNV;
- exec->GetProgramNamedParameterfvNV = _mesa_GetProgramNamedParameterfvNV;
- exec->GetProgramNamedParameterdvNV = _mesa_GetProgramNamedParameterdvNV;
- exec->ProgramLocalParameter4dARB = _mesa_ProgramLocalParameter4dARB;
- exec->ProgramLocalParameter4dvARB = _mesa_ProgramLocalParameter4dvARB;
- exec->ProgramLocalParameter4fARB = _mesa_ProgramLocalParameter4fARB;
- exec->ProgramLocalParameter4fvARB = _mesa_ProgramLocalParameter4fvARB;
- exec->GetProgramLocalParameterdvARB = _mesa_GetProgramLocalParameterdvARB;
- exec->GetProgramLocalParameterfvARB = _mesa_GetProgramLocalParameterfvARB;
+ SET_ProgramNamedParameter4fNV(exec, _mesa_ProgramNamedParameter4fNV);
+ SET_ProgramNamedParameter4dNV(exec, _mesa_ProgramNamedParameter4dNV);
+ SET_ProgramNamedParameter4fvNV(exec, _mesa_ProgramNamedParameter4fvNV);
+ SET_ProgramNamedParameter4dvNV(exec, _mesa_ProgramNamedParameter4dvNV);
+ SET_GetProgramNamedParameterfvNV(exec, _mesa_GetProgramNamedParameterfvNV);
+ SET_GetProgramNamedParameterdvNV(exec, _mesa_GetProgramNamedParameterdvNV);
+ SET_ProgramLocalParameter4dARB(exec, _mesa_ProgramLocalParameter4dARB);
+ SET_ProgramLocalParameter4dvARB(exec, _mesa_ProgramLocalParameter4dvARB);
+ SET_ProgramLocalParameter4fARB(exec, _mesa_ProgramLocalParameter4fARB);
+ SET_ProgramLocalParameter4fvARB(exec, _mesa_ProgramLocalParameter4fvARB);
+ SET_GetProgramLocalParameterdvARB(exec, _mesa_GetProgramLocalParameterdvARB);
+ SET_GetProgramLocalParameterfvARB(exec, _mesa_GetProgramLocalParameterfvARB);
#endif
/* 262. GL_NV_point_sprite */
#if _HAVE_FULL_GL
- exec->PointParameteriNV = _mesa_PointParameteriNV;
- exec->PointParameterivNV = _mesa_PointParameterivNV;
+ SET_PointParameteriNV(exec, _mesa_PointParameteriNV);
+ SET_PointParameterivNV(exec, _mesa_PointParameterivNV);
#endif
/* 268. GL_EXT_stencil_two_side */
#if _HAVE_FULL_GL
- exec->ActiveStencilFaceEXT = _mesa_ActiveStencilFaceEXT;
+ SET_ActiveStencilFaceEXT(exec, _mesa_ActiveStencilFaceEXT);
#endif
/* ???. GL_EXT_depth_bounds_test */
- exec->DepthBoundsEXT = _mesa_DepthBoundsEXT;
+ SET_DepthBoundsEXT(exec, _mesa_DepthBoundsEXT);
/* ARB 1. GL_ARB_multitexture */
#if _HAVE_FULL_GL
- exec->ActiveTextureARB = _mesa_ActiveTextureARB;
- exec->ClientActiveTextureARB = _mesa_ClientActiveTextureARB;
+ SET_ActiveTextureARB(exec, _mesa_ActiveTextureARB);
+ SET_ClientActiveTextureARB(exec, _mesa_ClientActiveTextureARB);
#endif
/* ARB 3. GL_ARB_transpose_matrix */
#if _HAVE_FULL_GL
- exec->LoadTransposeMatrixdARB = _mesa_LoadTransposeMatrixdARB;
- exec->LoadTransposeMatrixfARB = _mesa_LoadTransposeMatrixfARB;
- exec->MultTransposeMatrixdARB = _mesa_MultTransposeMatrixdARB;
- exec->MultTransposeMatrixfARB = _mesa_MultTransposeMatrixfARB;
+ SET_LoadTransposeMatrixdARB(exec, _mesa_LoadTransposeMatrixdARB);
+ SET_LoadTransposeMatrixfARB(exec, _mesa_LoadTransposeMatrixfARB);
+ SET_MultTransposeMatrixdARB(exec, _mesa_MultTransposeMatrixdARB);
+ SET_MultTransposeMatrixfARB(exec, _mesa_MultTransposeMatrixfARB);
#endif
/* ARB 5. GL_ARB_multisample */
#if _HAVE_FULL_GL
- exec->SampleCoverageARB = _mesa_SampleCoverageARB;
+ SET_SampleCoverageARB(exec, _mesa_SampleCoverageARB);
#endif
/* ARB 12. GL_ARB_texture_compression */
#if _HAVE_FULL_GL
- exec->CompressedTexImage3DARB = _mesa_CompressedTexImage3DARB;
- exec->CompressedTexImage2DARB = _mesa_CompressedTexImage2DARB;
- exec->CompressedTexImage1DARB = _mesa_CompressedTexImage1DARB;
- exec->CompressedTexSubImage3DARB = _mesa_CompressedTexSubImage3DARB;
- exec->CompressedTexSubImage2DARB = _mesa_CompressedTexSubImage2DARB;
- exec->CompressedTexSubImage1DARB = _mesa_CompressedTexSubImage1DARB;
- exec->GetCompressedTexImageARB = _mesa_GetCompressedTexImageARB;
+ SET_CompressedTexImage3DARB(exec, _mesa_CompressedTexImage3DARB);
+ SET_CompressedTexImage2DARB(exec, _mesa_CompressedTexImage2DARB);
+ SET_CompressedTexImage1DARB(exec, _mesa_CompressedTexImage1DARB);
+ SET_CompressedTexSubImage3DARB(exec, _mesa_CompressedTexSubImage3DARB);
+ SET_CompressedTexSubImage2DARB(exec, _mesa_CompressedTexSubImage2DARB);
+ SET_CompressedTexSubImage1DARB(exec, _mesa_CompressedTexSubImage1DARB);
+ SET_GetCompressedTexImageARB(exec, _mesa_GetCompressedTexImageARB);
#endif
/* ARB 14. GL_ARB_point_parameters */
/* glVertexAttrib4NivARB handled in api_loopback.c */
/* glVertexAttrib4NusvARB handled in api_loopback.c */
/* glVertexAttrib4NuivARB handled in api_loopback.c */
- exec->VertexAttribPointerARB = _mesa_VertexAttribPointerARB;
- exec->EnableVertexAttribArrayARB = _mesa_EnableVertexAttribArrayARB;
- exec->DisableVertexAttribArrayARB = _mesa_DisableVertexAttribArrayARB;
- exec->ProgramStringARB = _mesa_ProgramStringARB;
+ SET_VertexAttribPointerARB(exec, _mesa_VertexAttribPointerARB);
+ SET_EnableVertexAttribArrayARB(exec, _mesa_EnableVertexAttribArrayARB);
+ SET_DisableVertexAttribArrayARB(exec, _mesa_DisableVertexAttribArrayARB);
+ SET_ProgramStringARB(exec, _mesa_ProgramStringARB);
/* glBindProgramARB aliases glBindProgramNV */
/* glDeleteProgramsARB aliases glDeleteProgramsNV */
/* glGenProgramsARB aliases glGenProgramsNV */
/* glIsProgramARB aliases glIsProgramNV */
- exec->GetVertexAttribdvARB = _mesa_GetVertexAttribdvARB;
- exec->GetVertexAttribfvARB = _mesa_GetVertexAttribfvARB;
- exec->GetVertexAttribivARB = _mesa_GetVertexAttribivARB;
+ SET_GetVertexAttribdvARB(exec, _mesa_GetVertexAttribdvARB);
+ SET_GetVertexAttribfvARB(exec, _mesa_GetVertexAttribfvARB);
+ SET_GetVertexAttribivARB(exec, _mesa_GetVertexAttribivARB);
/* glGetVertexAttribPointervARB aliases glGetVertexAttribPointervNV */
- exec->ProgramEnvParameter4dARB = _mesa_ProgramEnvParameter4dARB;
- exec->ProgramEnvParameter4dvARB = _mesa_ProgramEnvParameter4dvARB;
- exec->ProgramEnvParameter4fARB = _mesa_ProgramEnvParameter4fARB;
- exec->ProgramEnvParameter4fvARB = _mesa_ProgramEnvParameter4fvARB;
- exec->ProgramLocalParameter4dARB = _mesa_ProgramLocalParameter4dARB;
- exec->ProgramLocalParameter4dvARB = _mesa_ProgramLocalParameter4dvARB;
- exec->ProgramLocalParameter4fARB = _mesa_ProgramLocalParameter4fARB;
- exec->ProgramLocalParameter4fvARB = _mesa_ProgramLocalParameter4fvARB;
- exec->GetProgramEnvParameterdvARB = _mesa_GetProgramEnvParameterdvARB;
- exec->GetProgramEnvParameterfvARB = _mesa_GetProgramEnvParameterfvARB;
- exec->GetProgramLocalParameterdvARB = _mesa_GetProgramLocalParameterdvARB;
- exec->GetProgramLocalParameterfvARB = _mesa_GetProgramLocalParameterfvARB;
- exec->GetProgramivARB = _mesa_GetProgramivARB;
- exec->GetProgramStringARB = _mesa_GetProgramStringARB;
+ SET_ProgramEnvParameter4dARB(exec, _mesa_ProgramEnvParameter4dARB);
+ SET_ProgramEnvParameter4dvARB(exec, _mesa_ProgramEnvParameter4dvARB);
+ SET_ProgramEnvParameter4fARB(exec, _mesa_ProgramEnvParameter4fARB);
+ SET_ProgramEnvParameter4fvARB(exec, _mesa_ProgramEnvParameter4fvARB);
+ SET_ProgramLocalParameter4dARB(exec, _mesa_ProgramLocalParameter4dARB);
+ SET_ProgramLocalParameter4dvARB(exec, _mesa_ProgramLocalParameter4dvARB);
+ SET_ProgramLocalParameter4fARB(exec, _mesa_ProgramLocalParameter4fARB);
+ SET_ProgramLocalParameter4fvARB(exec, _mesa_ProgramLocalParameter4fvARB);
+ SET_GetProgramEnvParameterdvARB(exec, _mesa_GetProgramEnvParameterdvARB);
+ SET_GetProgramEnvParameterfvARB(exec, _mesa_GetProgramEnvParameterfvARB);
+ SET_GetProgramLocalParameterdvARB(exec, _mesa_GetProgramLocalParameterdvARB);
+ SET_GetProgramLocalParameterfvARB(exec, _mesa_GetProgramLocalParameterfvARB);
+ SET_GetProgramivARB(exec, _mesa_GetProgramivARB);
+ SET_GetProgramStringARB(exec, _mesa_GetProgramStringARB);
#endif
/* ARB 28. GL_ARB_vertex_buffer_object */
#if FEATURE_ARB_vertex_buffer_object
- exec->BindBufferARB = _mesa_BindBufferARB;
- exec->BufferDataARB = _mesa_BufferDataARB;
- exec->BufferSubDataARB = _mesa_BufferSubDataARB;
- exec->DeleteBuffersARB = _mesa_DeleteBuffersARB;
- exec->GenBuffersARB = _mesa_GenBuffersARB;
- exec->GetBufferParameterivARB = _mesa_GetBufferParameterivARB;
- exec->GetBufferPointervARB = _mesa_GetBufferPointervARB;
- exec->GetBufferSubDataARB = _mesa_GetBufferSubDataARB;
- exec->IsBufferARB = _mesa_IsBufferARB;
- exec->MapBufferARB = _mesa_MapBufferARB;
- exec->UnmapBufferARB = _mesa_UnmapBufferARB;
+ SET_BindBufferARB(exec, _mesa_BindBufferARB);
+ SET_BufferDataARB(exec, _mesa_BufferDataARB);
+ SET_BufferSubDataARB(exec, _mesa_BufferSubDataARB);
+ SET_DeleteBuffersARB(exec, _mesa_DeleteBuffersARB);
+ SET_GenBuffersARB(exec, _mesa_GenBuffersARB);
+ SET_GetBufferParameterivARB(exec, _mesa_GetBufferParameterivARB);
+ SET_GetBufferPointervARB(exec, _mesa_GetBufferPointervARB);
+ SET_GetBufferSubDataARB(exec, _mesa_GetBufferSubDataARB);
+ SET_IsBufferARB(exec, _mesa_IsBufferARB);
+ SET_MapBufferARB(exec, _mesa_MapBufferARB);
+ SET_UnmapBufferARB(exec, _mesa_UnmapBufferARB);
#endif
/* ARB 29. GL_ARB_occlusion_query */
#if FEATURE_ARB_occlusion_query
- exec->GenQueriesARB = _mesa_GenQueriesARB;
- exec->DeleteQueriesARB = _mesa_DeleteQueriesARB;
- exec->IsQueryARB = _mesa_IsQueryARB;
- exec->BeginQueryARB = _mesa_BeginQueryARB;
- exec->EndQueryARB = _mesa_EndQueryARB;
- exec->GetQueryivARB = _mesa_GetQueryivARB;
- exec->GetQueryObjectivARB = _mesa_GetQueryObjectivARB;
- exec->GetQueryObjectuivARB = _mesa_GetQueryObjectuivARB;
+ SET_GenQueriesARB(exec, _mesa_GenQueriesARB);
+ SET_DeleteQueriesARB(exec, _mesa_DeleteQueriesARB);
+ SET_IsQueryARB(exec, _mesa_IsQueryARB);
+ SET_BeginQueryARB(exec, _mesa_BeginQueryARB);
+ SET_EndQueryARB(exec, _mesa_EndQueryARB);
+ SET_GetQueryivARB(exec, _mesa_GetQueryivARB);
+ SET_GetQueryObjectivARB(exec, _mesa_GetQueryObjectivARB);
+ SET_GetQueryObjectuivARB(exec, _mesa_GetQueryObjectuivARB);
#endif
/* ARB 37. GL_ARB_draw_buffers */
- exec->DrawBuffersARB = _mesa_DrawBuffersARB;
+ SET_DrawBuffersARB(exec, _mesa_DrawBuffersARB);
#if FEATURE_ARB_shader_objects
- exec->DeleteObjectARB = _mesa_DeleteObjectARB;
- exec->GetHandleARB = _mesa_GetHandleARB;
- exec->DetachObjectARB = _mesa_DetachObjectARB;
- exec->CreateShaderObjectARB = _mesa_CreateShaderObjectARB;
- exec->ShaderSourceARB = _mesa_ShaderSourceARB;
- exec->CompileShaderARB = _mesa_CompileShaderARB;
- exec->CreateProgramObjectARB = _mesa_CreateProgramObjectARB;
- exec->AttachObjectARB = _mesa_AttachObjectARB;
- exec->LinkProgramARB = _mesa_LinkProgramARB;
- exec->UseProgramObjectARB = _mesa_UseProgramObjectARB;
- exec->ValidateProgramARB = _mesa_ValidateProgramARB;
- exec->Uniform1fARB = _mesa_Uniform1fARB;
- exec->Uniform2fARB = _mesa_Uniform2fARB;
- exec->Uniform3fARB = _mesa_Uniform3fARB;
- exec->Uniform4fARB = _mesa_Uniform4fARB;
- exec->Uniform1iARB = _mesa_Uniform1iARB;
- exec->Uniform2iARB = _mesa_Uniform2iARB;
- exec->Uniform3iARB = _mesa_Uniform3iARB;
- exec->Uniform4iARB = _mesa_Uniform4iARB;
- exec->Uniform1fvARB = _mesa_Uniform1fvARB;
- exec->Uniform2fvARB = _mesa_Uniform2fvARB;
- exec->Uniform3fvARB = _mesa_Uniform3fvARB;
- exec->Uniform4fvARB = _mesa_Uniform4fvARB;
- exec->Uniform1ivARB = _mesa_Uniform1ivARB;
- exec->Uniform2ivARB = _mesa_Uniform2ivARB;
- exec->Uniform3ivARB = _mesa_Uniform3ivARB;
- exec->Uniform4ivARB = _mesa_Uniform4ivARB;
- exec->UniformMatrix2fvARB = _mesa_UniformMatrix2fvARB;
- exec->UniformMatrix3fvARB = _mesa_UniformMatrix3fvARB;
- exec->UniformMatrix4fvARB = _mesa_UniformMatrix4fvARB;
- exec->GetObjectParameterfvARB = _mesa_GetObjectParameterfvARB;
- exec->GetObjectParameterivARB = _mesa_GetObjectParameterivARB;
- exec->GetInfoLogARB = _mesa_GetInfoLogARB;
- exec->GetAttachedObjectsARB = _mesa_GetAttachedObjectsARB;
- exec->GetUniformLocationARB = _mesa_GetUniformLocationARB;
- exec->GetActiveUniformARB = _mesa_GetActiveUniformARB;
- exec->GetUniformfvARB = _mesa_GetUniformfvARB;
- exec->GetUniformivARB = _mesa_GetUniformivARB;
- exec->GetShaderSourceARB = _mesa_GetShaderSourceARB;
-#endif /* FEATURE_ARB_shader_objects */\r
-\r
-#if FEATURE_ARB_vertex_shader\r
- exec->BindAttribLocationARB = _mesa_BindAttribLocationARB;\r
- exec->GetActiveAttribARB = _mesa_GetActiveAttribARB;\r
- exec->GetAttribLocationARB = _mesa_GetAttribLocationARB;\r
+ SET_DeleteObjectARB(exec, _mesa_DeleteObjectARB);
+ SET_GetHandleARB(exec, _mesa_GetHandleARB);
+ SET_DetachObjectARB(exec, _mesa_DetachObjectARB);
+ SET_CreateShaderObjectARB(exec, _mesa_CreateShaderObjectARB);
+ SET_ShaderSourceARB(exec, _mesa_ShaderSourceARB);
+ SET_CompileShaderARB(exec, _mesa_CompileShaderARB);
+ SET_CreateProgramObjectARB(exec, _mesa_CreateProgramObjectARB);
+ SET_AttachObjectARB(exec, _mesa_AttachObjectARB);
+ SET_LinkProgramARB(exec, _mesa_LinkProgramARB);
+ SET_UseProgramObjectARB(exec, _mesa_UseProgramObjectARB);
+ SET_ValidateProgramARB(exec, _mesa_ValidateProgramARB);
+ SET_Uniform1fARB(exec, _mesa_Uniform1fARB);
+ SET_Uniform2fARB(exec, _mesa_Uniform2fARB);
+ SET_Uniform3fARB(exec, _mesa_Uniform3fARB);
+ SET_Uniform4fARB(exec, _mesa_Uniform4fARB);
+ SET_Uniform1iARB(exec, _mesa_Uniform1iARB);
+ SET_Uniform2iARB(exec, _mesa_Uniform2iARB);
+ SET_Uniform3iARB(exec, _mesa_Uniform3iARB);
+ SET_Uniform4iARB(exec, _mesa_Uniform4iARB);
+ SET_Uniform1fvARB(exec, _mesa_Uniform1fvARB);
+ SET_Uniform2fvARB(exec, _mesa_Uniform2fvARB);
+ SET_Uniform3fvARB(exec, _mesa_Uniform3fvARB);
+ SET_Uniform4fvARB(exec, _mesa_Uniform4fvARB);
+ SET_Uniform1ivARB(exec, _mesa_Uniform1ivARB);
+ SET_Uniform2ivARB(exec, _mesa_Uniform2ivARB);
+ SET_Uniform3ivARB(exec, _mesa_Uniform3ivARB);
+ SET_Uniform4ivARB(exec, _mesa_Uniform4ivARB);
+ SET_UniformMatrix2fvARB(exec, _mesa_UniformMatrix2fvARB);
+ SET_UniformMatrix3fvARB(exec, _mesa_UniformMatrix3fvARB);
+ SET_UniformMatrix4fvARB(exec, _mesa_UniformMatrix4fvARB);
+ SET_GetObjectParameterfvARB(exec, _mesa_GetObjectParameterfvARB);
+ SET_GetObjectParameterivARB(exec, _mesa_GetObjectParameterivARB);
+ SET_GetInfoLogARB(exec, _mesa_GetInfoLogARB);
+ SET_GetAttachedObjectsARB(exec, _mesa_GetAttachedObjectsARB);
+ SET_GetUniformLocationARB(exec, _mesa_GetUniformLocationARB);
+ SET_GetActiveUniformARB(exec, _mesa_GetActiveUniformARB);
+ SET_GetUniformfvARB(exec, _mesa_GetUniformfvARB);
+ SET_GetUniformivARB(exec, _mesa_GetUniformivARB);
+ SET_GetShaderSourceARB(exec, _mesa_GetShaderSourceARB);
+#endif /* FEATURE_ARB_shader_objects */
+
+#if FEATURE_ARB_vertex_shader
+ SET_BindAttribLocationARB(exec, _mesa_BindAttribLocationARB);
+ SET_GetActiveAttribARB(exec, _mesa_GetActiveAttribARB);
+ SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB);
#endif /* FEATURE_ARB_vertex_shader */
/* GL_ATI_fragment_shader */
#if FEATURE_ATI_fragment_shader
- exec->GenFragmentShadersATI = _mesa_GenFragmentShadersATI;
- exec->BindFragmentShaderATI = _mesa_BindFragmentShaderATI;
- exec->DeleteFragmentShaderATI = _mesa_DeleteFragmentShaderATI;
- exec->BeginFragmentShaderATI = _mesa_BeginFragmentShaderATI;
- exec->EndFragmentShaderATI = _mesa_EndFragmentShaderATI;
- exec->PassTexCoordATI = _mesa_PassTexCoordATI;
- exec->SampleMapATI = _mesa_SampleMapATI;
- exec->ColorFragmentOp1ATI = _mesa_ColorFragmentOp1ATI;
- exec->ColorFragmentOp2ATI = _mesa_ColorFragmentOp2ATI;
- exec->ColorFragmentOp3ATI = _mesa_ColorFragmentOp3ATI;
- exec->AlphaFragmentOp1ATI = _mesa_AlphaFragmentOp1ATI;
- exec->AlphaFragmentOp2ATI = _mesa_AlphaFragmentOp2ATI;
- exec->AlphaFragmentOp3ATI = _mesa_AlphaFragmentOp3ATI;
- exec->SetFragmentShaderConstantATI = _mesa_SetFragmentShaderConstantATI;
+ SET_GenFragmentShadersATI(exec, _mesa_GenFragmentShadersATI);
+ SET_BindFragmentShaderATI(exec, _mesa_BindFragmentShaderATI);
+ SET_DeleteFragmentShaderATI(exec, _mesa_DeleteFragmentShaderATI);
+ SET_BeginFragmentShaderATI(exec, _mesa_BeginFragmentShaderATI);
+ SET_EndFragmentShaderATI(exec, _mesa_EndFragmentShaderATI);
+ SET_PassTexCoordATI(exec, _mesa_PassTexCoordATI);
+ SET_SampleMapATI(exec, _mesa_SampleMapATI);
+ SET_ColorFragmentOp1ATI(exec, _mesa_ColorFragmentOp1ATI);
+ SET_ColorFragmentOp2ATI(exec, _mesa_ColorFragmentOp2ATI);
+ SET_ColorFragmentOp3ATI(exec, _mesa_ColorFragmentOp3ATI);
+ SET_AlphaFragmentOp1ATI(exec, _mesa_AlphaFragmentOp1ATI);
+ SET_AlphaFragmentOp2ATI(exec, _mesa_AlphaFragmentOp2ATI);
+ SET_AlphaFragmentOp3ATI(exec, _mesa_AlphaFragmentOp3ATI);
+ SET_SetFragmentShaderConstantATI(exec, _mesa_SetFragmentShaderConstantATI);
#endif
#if FEATURE_EXT_framebuffer_object
- exec->IsRenderbufferEXT = _mesa_IsRenderbufferEXT;
- exec->BindRenderbufferEXT = _mesa_BindRenderbufferEXT;
- exec->DeleteRenderbuffersEXT = _mesa_DeleteRenderbuffersEXT;
- exec->GenRenderbuffersEXT = _mesa_GenRenderbuffersEXT;
- exec->RenderbufferStorageEXT = _mesa_RenderbufferStorageEXT;
- exec->GetRenderbufferParameterivEXT = _mesa_GetRenderbufferParameterivEXT;
- exec->IsFramebufferEXT = _mesa_IsFramebufferEXT;
- exec->BindFramebufferEXT = _mesa_BindFramebufferEXT;
- exec->DeleteFramebuffersEXT = _mesa_DeleteFramebuffersEXT;
- exec->GenFramebuffersEXT = _mesa_GenFramebuffersEXT;
- exec->CheckFramebufferStatusEXT = _mesa_CheckFramebufferStatusEXT;
- exec->FramebufferTexture1DEXT = _mesa_FramebufferTexture1DEXT;
- exec->FramebufferTexture2DEXT = _mesa_FramebufferTexture2DEXT;
- exec->FramebufferTexture3DEXT = _mesa_FramebufferTexture3DEXT;
- exec->FramebufferRenderbufferEXT = _mesa_FramebufferRenderbufferEXT;
- exec->GetFramebufferAttachmentParameterivEXT = _mesa_GetFramebufferAttachmentParameterivEXT;
- exec->GenerateMipmapEXT = _mesa_GenerateMipmapEXT;
+ SET_IsRenderbufferEXT(exec, _mesa_IsRenderbufferEXT);
+ SET_BindRenderbufferEXT(exec, _mesa_BindRenderbufferEXT);
+ SET_DeleteRenderbuffersEXT(exec, _mesa_DeleteRenderbuffersEXT);
+ SET_GenRenderbuffersEXT(exec, _mesa_GenRenderbuffersEXT);
+ SET_RenderbufferStorageEXT(exec, _mesa_RenderbufferStorageEXT);
+ SET_GetRenderbufferParameterivEXT(exec, _mesa_GetRenderbufferParameterivEXT);
+ SET_IsFramebufferEXT(exec, _mesa_IsFramebufferEXT);
+ SET_BindFramebufferEXT(exec, _mesa_BindFramebufferEXT);
+ SET_DeleteFramebuffersEXT(exec, _mesa_DeleteFramebuffersEXT);
+ SET_GenFramebuffersEXT(exec, _mesa_GenFramebuffersEXT);
+ SET_CheckFramebufferStatusEXT(exec, _mesa_CheckFramebufferStatusEXT);
+ SET_FramebufferTexture1DEXT(exec, _mesa_FramebufferTexture1DEXT);
+ SET_FramebufferTexture2DEXT(exec, _mesa_FramebufferTexture2DEXT);
+ SET_FramebufferTexture3DEXT(exec, _mesa_FramebufferTexture3DEXT);
+ SET_FramebufferRenderbufferEXT(exec, _mesa_FramebufferRenderbufferEXT);
+ SET_GetFramebufferAttachmentParameterivEXT(exec, _mesa_GetFramebufferAttachmentParameterivEXT);
+ SET_GenerateMipmapEXT(exec, _mesa_GenerateMipmapEXT);
#endif
}
#include "texstate.h"
#include "mtypes.h"
#include "varray.h"
-
+#include "dispatch.h"
#ifndef GL_BOOLEAN
#define GL_BOOLEAN 0x9999
for (i = 0; i < primcount; i++) {
if (count[i] > 0) {
- (ctx->Exec->DrawArrays)(mode, first[i], count[i]);
+ CALL_DrawArrays(ctx->Exec, (mode, first[i], count[i]));
}
}
}
for (i = 0; i < primcount; i++) {
if (count[i] > 0) {
- (ctx->Exec->DrawElements)(mode, count[i], type, indices[i]);
+ CALL_DrawElements(ctx->Exec, (mode, count[i], type, indices[i]));
}
}
}
for ( i = 0 ; i < primcount ; i++ ) {
if ( count[i] > 0 ) {
GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride));
- (ctx->Exec->DrawArrays)( m, first[i], count[i] );
+ CALL_DrawArrays(ctx->Exec, ( m, first[i], count[i] ));
}
}
}
for ( i = 0 ; i < primcount ; i++ ) {
if ( count[i] > 0 ) {
GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride));
- (ctx->Exec->DrawElements)( m, count[i], type, indices[i] );
+ CALL_DrawElements(ctx->Exec, ( m, count[i], type, indices[i] ));
}
}
}
\
/* Save the swapped function's dispatch entry so it can be */ \
/* restored later. */ \
- tnl->Swapped[tnl->SwapCount][0] = (void *)&(ctx->Exec->FUNC); \
+ tnl->Swapped[tnl->SwapCount][0] = (void *)&(GET_ ## FUNC (ctx->Exec)); \
*(func_ptr_t *)(tnl->Swapped[tnl->SwapCount]+1) = (func_ptr_t)TAG(FUNC); \
tnl->SwapCount++; \
\
_mesa_debug(ctx, " swapping gl" #FUNC"...\n" ); \
\
/* Install the tnl function pointer. */ \
- ctx->Exec->FUNC = tnl->Current->FUNC; \
+ SET_ ## FUNC(ctx->Exec, tnl->Current->FUNC); \
}
#define TAG(x) neutral_##x
static void
install_vtxfmt( struct _glapi_table *tab, const GLvertexformat *vfmt )
{
- tab->ArrayElement = vfmt->ArrayElement;
- tab->Color3f = vfmt->Color3f;
- tab->Color3fv = vfmt->Color3fv;
- tab->Color4f = vfmt->Color4f;
- tab->Color4fv = vfmt->Color4fv;
- tab->EdgeFlag = vfmt->EdgeFlag;
- tab->EdgeFlagv = vfmt->EdgeFlagv;
- tab->EvalCoord1f = vfmt->EvalCoord1f;
- tab->EvalCoord1fv = vfmt->EvalCoord1fv;
- tab->EvalCoord2f = vfmt->EvalCoord2f;
- tab->EvalCoord2fv = vfmt->EvalCoord2fv;
- tab->EvalPoint1 = vfmt->EvalPoint1;
- tab->EvalPoint2 = vfmt->EvalPoint2;
- tab->FogCoordfEXT = vfmt->FogCoordfEXT;
- tab->FogCoordfvEXT = vfmt->FogCoordfvEXT;
- tab->Indexf = vfmt->Indexf;
- tab->Indexfv = vfmt->Indexfv;
- tab->Materialfv = vfmt->Materialfv;
- tab->MultiTexCoord1fARB = vfmt->MultiTexCoord1fARB;
- tab->MultiTexCoord1fvARB = vfmt->MultiTexCoord1fvARB;
- tab->MultiTexCoord2fARB = vfmt->MultiTexCoord2fARB;
- tab->MultiTexCoord2fvARB = vfmt->MultiTexCoord2fvARB;
- tab->MultiTexCoord3fARB = vfmt->MultiTexCoord3fARB;
- tab->MultiTexCoord3fvARB = vfmt->MultiTexCoord3fvARB;
- tab->MultiTexCoord4fARB = vfmt->MultiTexCoord4fARB;
- tab->MultiTexCoord4fvARB = vfmt->MultiTexCoord4fvARB;
- tab->Normal3f = vfmt->Normal3f;
- tab->Normal3fv = vfmt->Normal3fv;
- tab->SecondaryColor3fEXT = vfmt->SecondaryColor3fEXT;
- tab->SecondaryColor3fvEXT = vfmt->SecondaryColor3fvEXT;
- tab->TexCoord1f = vfmt->TexCoord1f;
- tab->TexCoord1fv = vfmt->TexCoord1fv;
- tab->TexCoord2f = vfmt->TexCoord2f;
- tab->TexCoord2fv = vfmt->TexCoord2fv;
- tab->TexCoord3f = vfmt->TexCoord3f;
- tab->TexCoord3fv = vfmt->TexCoord3fv;
- tab->TexCoord4f = vfmt->TexCoord4f;
- tab->TexCoord4fv = vfmt->TexCoord4fv;
- tab->Vertex2f = vfmt->Vertex2f;
- tab->Vertex2fv = vfmt->Vertex2fv;
- tab->Vertex3f = vfmt->Vertex3f;
- tab->Vertex3fv = vfmt->Vertex3fv;
- tab->Vertex4f = vfmt->Vertex4f;
- tab->Vertex4fv = vfmt->Vertex4fv;
- tab->CallList = vfmt->CallList;
- tab->CallLists = vfmt->CallLists;
- tab->Begin = vfmt->Begin;
- tab->End = vfmt->End;
- tab->VertexAttrib1fNV = vfmt->VertexAttrib1fNV;
- tab->VertexAttrib1fvNV = vfmt->VertexAttrib1fvNV;
- tab->VertexAttrib2fNV = vfmt->VertexAttrib2fNV;
- tab->VertexAttrib2fvNV = vfmt->VertexAttrib2fvNV;
- tab->VertexAttrib3fNV = vfmt->VertexAttrib3fNV;
- 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;
- tab->DrawRangeElements = vfmt->DrawRangeElements;
- tab->EvalMesh1 = vfmt->EvalMesh1;
- tab->EvalMesh2 = vfmt->EvalMesh2;
+ SET_ArrayElement(tab, vfmt->ArrayElement);
+ SET_Color3f(tab, vfmt->Color3f);
+ SET_Color3fv(tab, vfmt->Color3fv);
+ SET_Color4f(tab, vfmt->Color4f);
+ SET_Color4fv(tab, vfmt->Color4fv);
+ SET_EdgeFlag(tab, vfmt->EdgeFlag);
+ SET_EdgeFlagv(tab, vfmt->EdgeFlagv);
+ SET_EvalCoord1f(tab, vfmt->EvalCoord1f);
+ SET_EvalCoord1fv(tab, vfmt->EvalCoord1fv);
+ SET_EvalCoord2f(tab, vfmt->EvalCoord2f);
+ SET_EvalCoord2fv(tab, vfmt->EvalCoord2fv);
+ SET_EvalPoint1(tab, vfmt->EvalPoint1);
+ SET_EvalPoint2(tab, vfmt->EvalPoint2);
+ SET_FogCoordfEXT(tab, vfmt->FogCoordfEXT);
+ SET_FogCoordfvEXT(tab, vfmt->FogCoordfvEXT);
+ SET_Indexf(tab, vfmt->Indexf);
+ SET_Indexfv(tab, vfmt->Indexfv);
+ SET_Materialfv(tab, vfmt->Materialfv);
+ SET_MultiTexCoord1fARB(tab, vfmt->MultiTexCoord1fARB);
+ SET_MultiTexCoord1fvARB(tab, vfmt->MultiTexCoord1fvARB);
+ SET_MultiTexCoord2fARB(tab, vfmt->MultiTexCoord2fARB);
+ SET_MultiTexCoord2fvARB(tab, vfmt->MultiTexCoord2fvARB);
+ SET_MultiTexCoord3fARB(tab, vfmt->MultiTexCoord3fARB);
+ SET_MultiTexCoord3fvARB(tab, vfmt->MultiTexCoord3fvARB);
+ SET_MultiTexCoord4fARB(tab, vfmt->MultiTexCoord4fARB);
+ SET_MultiTexCoord4fvARB(tab, vfmt->MultiTexCoord4fvARB);
+ SET_Normal3f(tab, vfmt->Normal3f);
+ SET_Normal3fv(tab, vfmt->Normal3fv);
+ SET_SecondaryColor3fEXT(tab, vfmt->SecondaryColor3fEXT);
+ SET_SecondaryColor3fvEXT(tab, vfmt->SecondaryColor3fvEXT);
+ SET_TexCoord1f(tab, vfmt->TexCoord1f);
+ SET_TexCoord1fv(tab, vfmt->TexCoord1fv);
+ SET_TexCoord2f(tab, vfmt->TexCoord2f);
+ SET_TexCoord2fv(tab, vfmt->TexCoord2fv);
+ SET_TexCoord3f(tab, vfmt->TexCoord3f);
+ SET_TexCoord3fv(tab, vfmt->TexCoord3fv);
+ SET_TexCoord4f(tab, vfmt->TexCoord4f);
+ SET_TexCoord4fv(tab, vfmt->TexCoord4fv);
+ SET_Vertex2f(tab, vfmt->Vertex2f);
+ SET_Vertex2fv(tab, vfmt->Vertex2fv);
+ SET_Vertex3f(tab, vfmt->Vertex3f);
+ SET_Vertex3fv(tab, vfmt->Vertex3fv);
+ SET_Vertex4f(tab, vfmt->Vertex4f);
+ SET_Vertex4fv(tab, vfmt->Vertex4fv);
+ SET_CallList(tab, vfmt->CallList);
+ SET_CallLists(tab, vfmt->CallLists);
+ SET_Begin(tab, vfmt->Begin);
+ SET_End(tab, vfmt->End);
+ SET_VertexAttrib1fNV(tab, vfmt->VertexAttrib1fNV);
+ SET_VertexAttrib1fvNV(tab, vfmt->VertexAttrib1fvNV);
+ SET_VertexAttrib2fNV(tab, vfmt->VertexAttrib2fNV);
+ SET_VertexAttrib2fvNV(tab, vfmt->VertexAttrib2fvNV);
+ SET_VertexAttrib3fNV(tab, vfmt->VertexAttrib3fNV);
+ SET_VertexAttrib3fvNV(tab, vfmt->VertexAttrib3fvNV);
+ SET_VertexAttrib4fNV(tab, vfmt->VertexAttrib4fNV);
+ SET_VertexAttrib4fvNV(tab, vfmt->VertexAttrib4fvNV);
+ SET_VertexAttrib1fARB(tab, vfmt->VertexAttrib1fARB);
+ SET_VertexAttrib1fvARB(tab, vfmt->VertexAttrib1fvARB);
+ SET_VertexAttrib2fARB(tab, vfmt->VertexAttrib2fARB);
+ SET_VertexAttrib2fvARB(tab, vfmt->VertexAttrib2fvARB);
+ SET_VertexAttrib3fARB(tab, vfmt->VertexAttrib3fARB);
+ SET_VertexAttrib3fvARB(tab, vfmt->VertexAttrib3fvARB);
+ SET_VertexAttrib4fARB(tab, vfmt->VertexAttrib4fARB);
+ SET_VertexAttrib4fvARB(tab, vfmt->VertexAttrib4fvARB);
+ SET_Rectf(tab, vfmt->Rectf);
+ SET_DrawArrays(tab, vfmt->DrawArrays);
+ SET_DrawElements(tab, vfmt->DrawElements);
+ SET_DrawRangeElements(tab, vfmt->DrawRangeElements);
+ SET_EvalMesh1(tab, vfmt->EvalMesh1);
+ SET_EvalMesh2(tab, vfmt->EvalMesh2);
ASSERT(tab->EvalMesh2);
}
#define PRE_LOOPBACK( FUNC )
#endif
+#include "dispatch.h"
+
static void GLAPIENTRY TAG(ArrayElement)( GLint i )
{
PRE_LOOPBACK( ArrayElement );
- GL_CALL(ArrayElement)( i );
+ CALL_ArrayElement(GET_DISPATCH(), ( i ));
}
static void GLAPIENTRY TAG(Color3f)( GLfloat r, GLfloat g, GLfloat b )
{
PRE_LOOPBACK( Color3f );
- GL_CALL(Color3f)( r, g, b );
+ CALL_Color3f(GET_DISPATCH(), ( r, g, b ));
}
static void GLAPIENTRY TAG(Color3fv)( const GLfloat *v )
{
PRE_LOOPBACK( Color3fv );
- GL_CALL(Color3fv)( v );
+ CALL_Color3fv(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(Color4f)( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
{
PRE_LOOPBACK( Color4f );
- GL_CALL(Color4f)( r, g, b, a );
+ CALL_Color4f(GET_DISPATCH(), ( r, g, b, a ));
}
static void GLAPIENTRY TAG(Color4fv)( const GLfloat *v )
{
PRE_LOOPBACK( Color4fv );
- GL_CALL(Color4fv)( v );
+ CALL_Color4fv(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(EdgeFlag)( GLboolean e )
{
PRE_LOOPBACK( EdgeFlag );
- GL_CALL(EdgeFlag)( e );
+ CALL_EdgeFlag(GET_DISPATCH(), ( e ));
}
static void GLAPIENTRY TAG(EdgeFlagv)( const GLboolean *v )
{
PRE_LOOPBACK( EdgeFlagv );
- GL_CALL(EdgeFlagv)( v );
+ CALL_EdgeFlagv(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(EvalCoord1f)( GLfloat s )
{
PRE_LOOPBACK( EvalCoord1f );
- GL_CALL(EvalCoord1f)( s );
+ CALL_EvalCoord1f(GET_DISPATCH(), ( s ));
}
static void GLAPIENTRY TAG(EvalCoord1fv)( const GLfloat *v )
{
PRE_LOOPBACK( EvalCoord1fv );
- GL_CALL(EvalCoord1fv)( v );
+ CALL_EvalCoord1fv(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(EvalCoord2f)( GLfloat s, GLfloat t )
{
PRE_LOOPBACK( EvalCoord2f );
- GL_CALL(EvalCoord2f)( s, t );
+ CALL_EvalCoord2f(GET_DISPATCH(), ( s, t ));
}
static void GLAPIENTRY TAG(EvalCoord2fv)( const GLfloat *v )
{
PRE_LOOPBACK( EvalCoord2fv );
- GL_CALL(EvalCoord2fv)( v );
+ CALL_EvalCoord2fv(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(EvalPoint1)( GLint i )
{
PRE_LOOPBACK( EvalPoint1 );
- GL_CALL(EvalPoint1)( i );
+ CALL_EvalPoint1(GET_DISPATCH(), ( i ));
}
static void GLAPIENTRY TAG(EvalPoint2)( GLint i, GLint j )
{
PRE_LOOPBACK( EvalPoint2 );
- GL_CALL(EvalPoint2)( i, j );
+ CALL_EvalPoint2(GET_DISPATCH(), ( i, j ));
}
static void GLAPIENTRY TAG(FogCoordfEXT)( GLfloat f )
{
PRE_LOOPBACK( FogCoordfEXT );
- GL_CALL(FogCoordfEXT)( f );
+ CALL_FogCoordfEXT(GET_DISPATCH(), ( f ));
}
static void GLAPIENTRY TAG(FogCoordfvEXT)( const GLfloat *v )
{
PRE_LOOPBACK( FogCoordfvEXT );
- GL_CALL(FogCoordfvEXT)( v );
+ CALL_FogCoordfvEXT(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(Indexf)( GLfloat f )
{
PRE_LOOPBACK( Indexf );
- GL_CALL(Indexf)( f );
+ CALL_Indexf(GET_DISPATCH(), ( f ));
}
static void GLAPIENTRY TAG(Indexfv)( const GLfloat *v )
{
PRE_LOOPBACK( Indexfv );
- GL_CALL(Indexfv)( v );
+ CALL_Indexfv(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(Materialfv)( GLenum face, GLenum pname, const GLfloat *v )
{
PRE_LOOPBACK( Materialfv );
- GL_CALL(Materialfv)( face, pname, v );
+ CALL_Materialfv(GET_DISPATCH(), ( face, pname, v ));
}
static void GLAPIENTRY TAG(MultiTexCoord1fARB)( GLenum target, GLfloat a )
{
PRE_LOOPBACK( MultiTexCoord1fARB );
- GL_CALL(MultiTexCoord1fARB)( target, a );
+ CALL_MultiTexCoord1fARB(GET_DISPATCH(), ( target, a ));
}
static void GLAPIENTRY TAG(MultiTexCoord1fvARB)( GLenum target, const GLfloat *tc )
{
PRE_LOOPBACK( MultiTexCoord1fvARB );
- GL_CALL(MultiTexCoord1fvARB)( target, tc );
+ CALL_MultiTexCoord1fvARB(GET_DISPATCH(), ( target, tc ));
}
static void GLAPIENTRY TAG(MultiTexCoord2fARB)( GLenum target, GLfloat s, GLfloat t )
{
PRE_LOOPBACK( MultiTexCoord2fARB );
- GL_CALL(MultiTexCoord2fARB)( target, s, t );
+ CALL_MultiTexCoord2fARB(GET_DISPATCH(), ( target, s, t ));
}
static void GLAPIENTRY TAG(MultiTexCoord2fvARB)( GLenum target, const GLfloat *tc )
{
PRE_LOOPBACK( MultiTexCoord2fvARB );
- GL_CALL(MultiTexCoord2fvARB)( target, tc );
+ CALL_MultiTexCoord2fvARB(GET_DISPATCH(), ( target, tc ));
}
static void GLAPIENTRY TAG(MultiTexCoord3fARB)( GLenum target, GLfloat s,
GLfloat t, GLfloat r )
{
PRE_LOOPBACK( MultiTexCoord3fARB );
- GL_CALL(MultiTexCoord3fARB)( target, s, t, r );
+ CALL_MultiTexCoord3fARB(GET_DISPATCH(), ( target, s, t, r ));
}
static void GLAPIENTRY TAG(MultiTexCoord3fvARB)( GLenum target, const GLfloat *tc )
{
PRE_LOOPBACK( MultiTexCoord3fvARB );
- GL_CALL(MultiTexCoord3fvARB)( target, tc );
+ CALL_MultiTexCoord3fvARB(GET_DISPATCH(), ( target, tc ));
}
static void GLAPIENTRY TAG(MultiTexCoord4fARB)( GLenum target, GLfloat s,
GLfloat t, GLfloat r, GLfloat q )
{
PRE_LOOPBACK( MultiTexCoord4fARB );
- GL_CALL(MultiTexCoord4fARB)( target, s, t, r, q );
+ CALL_MultiTexCoord4fARB(GET_DISPATCH(), ( target, s, t, r, q ));
}
static void GLAPIENTRY TAG(MultiTexCoord4fvARB)( GLenum target, const GLfloat *tc )
{
PRE_LOOPBACK( MultiTexCoord4fvARB );
- GL_CALL(MultiTexCoord4fvARB)( target, tc );
+ CALL_MultiTexCoord4fvARB(GET_DISPATCH(), ( target, tc ));
}
static void GLAPIENTRY TAG(Normal3f)( GLfloat x, GLfloat y, GLfloat z )
{
PRE_LOOPBACK( Normal3f );
- GL_CALL(Normal3f)( x, y, z );
+ CALL_Normal3f(GET_DISPATCH(), ( x, y, z ));
}
static void GLAPIENTRY TAG(Normal3fv)( const GLfloat *v )
{
PRE_LOOPBACK( Normal3fv );
- GL_CALL(Normal3fv)( v );
+ CALL_Normal3fv(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(SecondaryColor3fEXT)( GLfloat r, GLfloat g, GLfloat b )
{
PRE_LOOPBACK( SecondaryColor3fEXT );
- GL_CALL(SecondaryColor3fEXT)( r, g, b );
+ CALL_SecondaryColor3fEXT(GET_DISPATCH(), ( r, g, b ));
}
static void GLAPIENTRY TAG(SecondaryColor3fvEXT)( const GLfloat *v )
{
PRE_LOOPBACK( SecondaryColor3fvEXT );
- GL_CALL(SecondaryColor3fvEXT)( v );
+ CALL_SecondaryColor3fvEXT(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(TexCoord1f)( GLfloat s )
{
PRE_LOOPBACK( TexCoord1f );
- GL_CALL(TexCoord1f)( s );
+ CALL_TexCoord1f(GET_DISPATCH(), ( s ));
}
static void GLAPIENTRY TAG(TexCoord1fv)( const GLfloat *tc )
{
PRE_LOOPBACK( TexCoord1fv );
- GL_CALL(TexCoord1fv)( tc );
+ CALL_TexCoord1fv(GET_DISPATCH(), ( tc ));
}
static void GLAPIENTRY TAG(TexCoord2f)( GLfloat s, GLfloat t )
{
PRE_LOOPBACK( TexCoord2f );
- GL_CALL(TexCoord2f)( s, t );
+ CALL_TexCoord2f(GET_DISPATCH(), ( s, t ));
}
static void GLAPIENTRY TAG(TexCoord2fv)( const GLfloat *tc )
{
PRE_LOOPBACK( TexCoord2fv );
- GL_CALL(TexCoord2fv)( tc );
+ CALL_TexCoord2fv(GET_DISPATCH(), ( tc ));
}
static void GLAPIENTRY TAG(TexCoord3f)( GLfloat s, GLfloat t, GLfloat r )
{
PRE_LOOPBACK( TexCoord3f );
- GL_CALL(TexCoord3f)( s, t, r );
+ CALL_TexCoord3f(GET_DISPATCH(), ( s, t, r ));
}
static void GLAPIENTRY TAG(TexCoord3fv)( const GLfloat *tc )
{
PRE_LOOPBACK( TexCoord3fv );
- GL_CALL(TexCoord3fv)( tc );
+ CALL_TexCoord3fv(GET_DISPATCH(), ( tc ));
}
static void GLAPIENTRY TAG(TexCoord4f)( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
{
PRE_LOOPBACK( TexCoord4f );
- GL_CALL(TexCoord4f)( s, t, r, q );
+ CALL_TexCoord4f(GET_DISPATCH(), ( s, t, r, q ));
}
static void GLAPIENTRY TAG(TexCoord4fv)( const GLfloat *tc )
{
PRE_LOOPBACK( TexCoord4fv );
- GL_CALL(TexCoord4fv)( tc );
+ CALL_TexCoord4fv(GET_DISPATCH(), ( tc ));
}
static void GLAPIENTRY TAG(Vertex2f)( GLfloat x, GLfloat y )
{
PRE_LOOPBACK( Vertex2f );
- GL_CALL(Vertex2f)( x, y );
+ CALL_Vertex2f(GET_DISPATCH(), ( x, y ));
}
static void GLAPIENTRY TAG(Vertex2fv)( const GLfloat *v )
{
PRE_LOOPBACK( Vertex2fv );
- GL_CALL(Vertex2fv)( v );
+ CALL_Vertex2fv(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(Vertex3f)( GLfloat x, GLfloat y, GLfloat z )
{
PRE_LOOPBACK( Vertex3f );
- GL_CALL(Vertex3f)( x, y, z );
+ CALL_Vertex3f(GET_DISPATCH(), ( x, y, z ));
}
static void GLAPIENTRY TAG(Vertex3fv)( const GLfloat *v )
{
PRE_LOOPBACK( Vertex3fv );
- GL_CALL(Vertex3fv)( v );
+ CALL_Vertex3fv(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(Vertex4f)( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
PRE_LOOPBACK( Vertex4f );
- GL_CALL(Vertex4f)( x, y, z, w );
+ CALL_Vertex4f(GET_DISPATCH(), ( x, y, z, w ));
}
static void GLAPIENTRY TAG(Vertex4fv)( const GLfloat *v )
{
PRE_LOOPBACK( Vertex4fv );
- GL_CALL(Vertex4fv)( v );
+ CALL_Vertex4fv(GET_DISPATCH(), ( v ));
}
static void GLAPIENTRY TAG(CallList)( GLuint i )
{
PRE_LOOPBACK( CallList );
- GL_CALL(CallList)( i );
+ CALL_CallList(GET_DISPATCH(), ( i ));
}
static void GLAPIENTRY TAG(CallLists)( GLsizei sz, GLenum type, const GLvoid *v )
{
PRE_LOOPBACK( CallLists );
- GL_CALL(CallLists)( sz, type, v );
+ CALL_CallLists(GET_DISPATCH(), ( sz, type, v ));
}
static void GLAPIENTRY TAG(Begin)( GLenum mode )
{
PRE_LOOPBACK( Begin );
- GL_CALL(Begin)( mode );
+ CALL_Begin(GET_DISPATCH(), ( mode ));
}
static void GLAPIENTRY TAG(End)( void )
{
PRE_LOOPBACK( End );
- GL_CALL(End)();
+ CALL_End(GET_DISPATCH(), ());
}
static void GLAPIENTRY TAG(Rectf)( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
{
PRE_LOOPBACK( Rectf );
- GL_CALL(Rectf)( x1, y1, x2, y2 );
+ CALL_Rectf(GET_DISPATCH(), ( x1, y1, x2, y2 ));
}
static void GLAPIENTRY TAG(DrawArrays)( GLenum mode, GLint start, GLsizei count )
{
PRE_LOOPBACK( DrawArrays );
- GL_CALL(DrawArrays)( mode, start, count );
+ CALL_DrawArrays(GET_DISPATCH(), ( mode, start, count ));
}
static void GLAPIENTRY TAG(DrawElements)( GLenum mode, GLsizei count, GLenum type,
const GLvoid *indices )
{
PRE_LOOPBACK( DrawElements );
- GL_CALL(DrawElements)( mode, count, type, indices );
+ CALL_DrawElements(GET_DISPATCH(), ( mode, count, type, indices ));
}
static void GLAPIENTRY TAG(DrawRangeElements)( GLenum mode, GLuint start,
GLenum type, const GLvoid *indices )
{
PRE_LOOPBACK( DrawRangeElements );
- GL_CALL(DrawRangeElements)( mode, start, end, count, type, indices );
+ CALL_DrawRangeElements(GET_DISPATCH(), ( mode, start, end, count, type, indices ));
}
static void GLAPIENTRY TAG(EvalMesh1)( GLenum mode, GLint i1, GLint i2 )
{
PRE_LOOPBACK( EvalMesh1 );
- GL_CALL(EvalMesh1)( mode, i1, i2 );
+ CALL_EvalMesh1(GET_DISPATCH(), ( mode, i1, i2 ));
}
static void GLAPIENTRY TAG(EvalMesh2)( GLenum mode, GLint i1, GLint i2,
GLint j1, GLint j2 )
{
PRE_LOOPBACK( EvalMesh2 );
- GL_CALL(EvalMesh2)( mode, i1, i2, j1, j2 );
+ CALL_EvalMesh2(GET_DISPATCH(), ( mode, i1, i2, j1, j2 ));
}
static void GLAPIENTRY TAG(VertexAttrib1fNV)( GLuint index, GLfloat x )
{
PRE_LOOPBACK( VertexAttrib1fNV );
- GL_CALL(VertexAttrib1fNV)( index, x );
+ CALL_VertexAttrib1fNV(GET_DISPATCH(), ( index, x ));
}
static void GLAPIENTRY TAG(VertexAttrib1fvNV)( GLuint index, const GLfloat *v )
{
PRE_LOOPBACK( VertexAttrib1fvNV );
- GL_CALL(VertexAttrib1fvNV)( index, v );
+ CALL_VertexAttrib1fvNV(GET_DISPATCH(), ( index, v ));
}
static void GLAPIENTRY TAG(VertexAttrib2fNV)( GLuint index, GLfloat x, GLfloat y )
{
PRE_LOOPBACK( VertexAttrib2fNV );
- GL_CALL(VertexAttrib2fNV)( index, x, y );
+ CALL_VertexAttrib2fNV(GET_DISPATCH(), ( index, x, y ));
}
static void GLAPIENTRY TAG(VertexAttrib2fvNV)( GLuint index, const GLfloat *v )
{
PRE_LOOPBACK( VertexAttrib2fvNV );
- GL_CALL(VertexAttrib2fvNV)( index, v );
+ CALL_VertexAttrib2fvNV(GET_DISPATCH(), ( index, v ));
}
static void GLAPIENTRY TAG(VertexAttrib3fNV)( GLuint index, GLfloat x, GLfloat y, GLfloat z )
{
PRE_LOOPBACK( VertexAttrib3fNV );
- GL_CALL(VertexAttrib3fNV)( index, x, y, z );
+ CALL_VertexAttrib3fNV(GET_DISPATCH(), ( index, x, y, z ));
}
static void GLAPIENTRY TAG(VertexAttrib3fvNV)( GLuint index, const GLfloat *v )
{
PRE_LOOPBACK( VertexAttrib3fvNV );
- GL_CALL(VertexAttrib3fvNV)( index, v );
+ CALL_VertexAttrib3fvNV(GET_DISPATCH(), ( index, v ));
}
static void GLAPIENTRY TAG(VertexAttrib4fNV)( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
PRE_LOOPBACK( VertexAttrib4fNV );
- GL_CALL(VertexAttrib4fNV)( index, x, y, z, w );
+ CALL_VertexAttrib4fNV(GET_DISPATCH(), ( index, x, y, z, w ));
}
static void GLAPIENTRY TAG(VertexAttrib4fvNV)( GLuint index, const GLfloat *v )
{
PRE_LOOPBACK( VertexAttrib4fvNV );
- GL_CALL(VertexAttrib4fvNV)( index, v );
+ CALL_VertexAttrib4fvNV(GET_DISPATCH(), ( index, v ));
}
static void GLAPIENTRY TAG(VertexAttrib1fARB)( GLuint index, GLfloat x )
{
PRE_LOOPBACK( VertexAttrib1fARB );
- GL_CALL(VertexAttrib1fARB)( index, x );
+ CALL_VertexAttrib1fARB(GET_DISPATCH(), ( index, x ));
}
static void GLAPIENTRY TAG(VertexAttrib1fvARB)( GLuint index, const GLfloat *v )
{
PRE_LOOPBACK( VertexAttrib1fvARB );
- GL_CALL(VertexAttrib1fvARB)( index, v );
+ CALL_VertexAttrib1fvARB(GET_DISPATCH(), ( index, v ));
}
static void GLAPIENTRY TAG(VertexAttrib2fARB)( GLuint index, GLfloat x, GLfloat y )
{
PRE_LOOPBACK( VertexAttrib2fARB );
- GL_CALL(VertexAttrib2fARB)( index, x, y );
+ CALL_VertexAttrib2fARB(GET_DISPATCH(), ( index, x, y ));
}
static void GLAPIENTRY TAG(VertexAttrib2fvARB)( GLuint index, const GLfloat *v )
{
PRE_LOOPBACK( VertexAttrib2fvARB );
- GL_CALL(VertexAttrib2fvARB)( index, v );
+ CALL_VertexAttrib2fvARB(GET_DISPATCH(), ( 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 );
+ CALL_VertexAttrib3fARB(GET_DISPATCH(), ( index, x, y, z ));
}
static void GLAPIENTRY TAG(VertexAttrib3fvARB)( GLuint index, const GLfloat *v )
{
PRE_LOOPBACK( VertexAttrib3fvARB );
- GL_CALL(VertexAttrib3fvARB)( index, v );
+ CALL_VertexAttrib3fvARB(GET_DISPATCH(), ( 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 );
+ CALL_VertexAttrib4fARB(GET_DISPATCH(), ( index, x, y, z, w ));
}
static void GLAPIENTRY TAG(VertexAttrib4fvARB)( GLuint index, const GLfloat *v )
{
PRE_LOOPBACK( VertexAttrib4fvARB );
- GL_CALL(VertexAttrib4fvARB)( index, v );
+ CALL_VertexAttrib4fvARB(GET_DISPATCH(), ( index, v ));
}
#include "arbprogparse.h"
#include "grammar_mesa.h"
+#include "dispatch.h"
+
#ifndef __extension__
#if !defined(__GNUC__) || (__GNUC__ < 2) || \
((__GNUC__ == 2) && (__GNUC_MINOR__ <= 7))
static int extension_is_supported (const GLubyte *ext)
{
- const GLubyte *extensions = GL_CALL(GetString)(GL_EXTENSIONS);
+ GET_CURRENT_CONTEXT(ctx);
+ const GLubyte *extensions = CALL_GetString(GET_DISPATCH(), (GL_EXTENSIONS));
const GLubyte *end = extensions + _mesa_strlen ((const char *) extensions);
const GLint ext_len = (GLint)_mesa_strlen ((const char *) ext);
#include "t_save_api.h"
#include "t_context.h"
#include "t_pipeline.h"
+#include "dispatch.h"
static void fallback_drawarrays( GLcontext *ctx, GLenum mode, GLint start,
GLsizei count )
assert(!ctx->CompileFlag);
assert(ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1);
- GL_CALL(Begin)(mode);
+ CALL_Begin(GET_DISPATCH(), (mode));
for (i = 0; i < count; i++)
- GL_CALL(ArrayElement)( start + i );
- GL_CALL(End)();
+ CALL_ArrayElement(GET_DISPATCH(), ( start + i ));
+ CALL_End(GET_DISPATCH(), ());
}
/* Here, indices will already reflect the buffer object if active */
- GL_CALL(Begin)(mode);
+ CALL_Begin(GET_DISPATCH(), (mode));
for (i = 0 ; i < count ; i++) {
- GL_CALL(ArrayElement)( indices[i] );
+ CALL_ArrayElement(GET_DISPATCH(), ( indices[i] ));
}
- GL_CALL(End)();
+ CALL_End(GET_DISPATCH(), ());
}
#include "api_arrayelt.h"
#include "vtxfmt.h"
#include "t_save_api.h"
+#include "dispatch.h"
/*
* NOTE: Old 'parity' issue is gone, but copying can still be
{
GET_CURRENT_CONTEXT(ctx);
FALLBACK(ctx);
- ctx->Save->EvalCoord1f( u );
+ CALL_EvalCoord1f(ctx->Save, ( u ));
}
static void GLAPIENTRY _save_EvalCoord1fv( const GLfloat *v )
{
GET_CURRENT_CONTEXT(ctx);
FALLBACK(ctx);
- ctx->Save->EvalCoord1fv( v );
+ CALL_EvalCoord1fv(ctx->Save, ( v ));
}
static void GLAPIENTRY _save_EvalCoord2f( GLfloat u, GLfloat v )
{
GET_CURRENT_CONTEXT(ctx);
FALLBACK(ctx);
- ctx->Save->EvalCoord2f( u, v );
+ CALL_EvalCoord2f(ctx->Save, ( u, v ));
}
static void GLAPIENTRY _save_EvalCoord2fv( const GLfloat *v )
{
GET_CURRENT_CONTEXT(ctx);
FALLBACK(ctx);
- ctx->Save->EvalCoord2fv( v );
+ CALL_EvalCoord2fv(ctx->Save, ( v ));
}
static void GLAPIENTRY _save_EvalPoint1( GLint i )
{
GET_CURRENT_CONTEXT(ctx);
FALLBACK(ctx);
- ctx->Save->EvalPoint1( i );
+ CALL_EvalPoint1(ctx->Save, ( i ));
}
static void GLAPIENTRY _save_EvalPoint2( GLint i, GLint j )
{
GET_CURRENT_CONTEXT(ctx);
FALLBACK(ctx);
- ctx->Save->EvalPoint2( i, j );
+ CALL_EvalPoint2(ctx->Save, ( i, j ));
}
static void GLAPIENTRY _save_CallList( GLuint l )
{
GET_CURRENT_CONTEXT(ctx);
FALLBACK(ctx);
- ctx->Save->CallList( l );
+ CALL_CallList(ctx->Save, ( l ));
}
static void GLAPIENTRY _save_CallLists( GLsizei n, GLenum type, const GLvoid *v )
{
GET_CURRENT_CONTEXT(ctx);
FALLBACK(ctx);
- ctx->Save->CallLists( n, type, v );
+ CALL_CallLists(ctx->Save, ( n, type, v ));
}
{
GET_CURRENT_CONTEXT(ctx);
_save_NotifyBegin( ctx, GL_QUADS | PRIM_WEAK );
- GL_CALL(Vertex2f)( x1, y1 );
- GL_CALL(Vertex2f)( x2, y1 );
- GL_CALL(Vertex2f)( x2, y2 );
- GL_CALL(Vertex2f)( x1, y2 );
- GL_CALL(End)();
+ CALL_Vertex2f(GET_DISPATCH(), ( x1, y1 ));
+ CALL_Vertex2f(GET_DISPATCH(), ( x2, y1 ));
+ CALL_Vertex2f(GET_DISPATCH(), ( x2, y2 ));
+ CALL_Vertex2f(GET_DISPATCH(), ( x1, y2 ));
+ CALL_End(GET_DISPATCH(), ());
}
_save_NotifyBegin( ctx, mode | PRIM_WEAK );
for (i = 0; i < count; i++)
- GL_CALL(ArrayElement)(start + i);
- GL_CALL(End)();
+ CALL_ArrayElement(GET_DISPATCH(), (start + i));
+ CALL_End(GET_DISPATCH(), ());
}
switch (type) {
case GL_UNSIGNED_BYTE:
for (i = 0 ; i < count ; i++)
- GL_CALL(ArrayElement)( ((GLubyte *)indices)[i] );
+ CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] ));
break;
case GL_UNSIGNED_SHORT:
for (i = 0 ; i < count ; i++)
- GL_CALL(ArrayElement)( ((GLushort *)indices)[i] );
+ CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] ));
break;
case GL_UNSIGNED_INT:
for (i = 0 ; i < count ; i++)
- GL_CALL(ArrayElement)( ((GLuint *)indices)[i] );
+ CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] ));
break;
default:
_mesa_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
break;
}
- GL_CALL(End)();
+ CALL_End(GET_DISPATCH(), ());
}
static void GLAPIENTRY _save_OBE_DrawRangeElements(GLenum mode,
#include "mtypes.h"
#include "t_context.h"
#include "t_save_api.h"
+#include "dispatch.h"
/* If someone compiles a display list like:
* glBegin(Triangles)
/* Wrapper functions in case glVertexAttrib*fvNV doesn't exist */
static void VertexAttrib1fvNV(GLcontext *ctx, GLint target, const GLfloat *v)
{
- ctx->Exec->VertexAttrib1fvNV(target, v);
+ CALL_VertexAttrib1fvNV(ctx->Exec, (target, v));
}
static void VertexAttrib2fvNV(GLcontext *ctx, GLint target, const GLfloat *v)
{
- ctx->Exec->VertexAttrib2fvNV(target, v);
+ CALL_VertexAttrib2fvNV(ctx->Exec, (target, v));
}
static void VertexAttrib3fvNV(GLcontext *ctx, GLint target, const GLfloat *v)
{
- ctx->Exec->VertexAttrib3fvNV(target, v);
+ CALL_VertexAttrib3fvNV(ctx->Exec, (target, v));
}
static void VertexAttrib4fvNV(GLcontext *ctx, GLint target, const GLfloat *v)
{
- ctx->Exec->VertexAttrib4fvNV(target, v);
+ CALL_VertexAttrib4fvNV(ctx->Exec, (target, v));
}
static attr_func vert_attrfunc[4] = {
static void VertexAttrib1fvARB(GLcontext *ctx, GLint target, const GLfloat *v)
{
- ctx->Exec->VertexAttrib1fvARB(target, v);
+ CALL_VertexAttrib1fvARB(ctx->Exec, (target, v));
}
static void VertexAttrib2fvARB(GLcontext *ctx, GLint target, const GLfloat *v)
{
- ctx->Exec->VertexAttrib2fvARB(target, v);
+ CALL_VertexAttrib2fvARB(ctx->Exec, (target, v));
}
static void VertexAttrib3fvARB(GLcontext *ctx, GLint target, const GLfloat *v)
{
- ctx->Exec->VertexAttrib3fvARB(target, v);
+ CALL_VertexAttrib3fvARB(ctx->Exec, (target, v));
}
static void VertexAttrib4fvARB(GLcontext *ctx, GLint target, const GLfloat *v)
{
- ctx->Exec->VertexAttrib4fvARB(target, v);
+ CALL_VertexAttrib4fvARB(ctx->Exec, (target, v));
}
static attr_func vert_attrfunc_arb[4] = {
{
switch (target) {
case _TNL_ATTRIB_MAT_FRONT_SHININESS:
- ctx->Exec->Materialfv( GL_FRONT, GL_SHININESS, v );
+ CALL_Materialfv(ctx->Exec, ( GL_FRONT, GL_SHININESS, v ));
break;
case _TNL_ATTRIB_MAT_BACK_SHININESS:
- ctx->Exec->Materialfv( GL_BACK, GL_SHININESS, v );
+ CALL_Materialfv(ctx->Exec, ( GL_BACK, GL_SHININESS, v ));
break;
}
}
{
switch (target) {
case _TNL_ATTRIB_MAT_FRONT_INDEXES:
- ctx->Exec->Materialfv( GL_FRONT, GL_COLOR_INDEXES, v );
+ CALL_Materialfv(ctx->Exec, ( GL_FRONT, GL_COLOR_INDEXES, v ));
break;
case _TNL_ATTRIB_MAT_BACK_INDEXES:
- ctx->Exec->Materialfv( GL_BACK, GL_COLOR_INDEXES, v );
+ CALL_Materialfv(ctx->Exec, ( GL_BACK, GL_COLOR_INDEXES, v ));
break;
}
}
{
switch (target) {
case _TNL_ATTRIB_MAT_FRONT_EMISSION:
- ctx->Exec->Materialfv( GL_FRONT, GL_EMISSION, v );
+ CALL_Materialfv(ctx->Exec, ( GL_FRONT, GL_EMISSION, v ));
break;
case _TNL_ATTRIB_MAT_BACK_EMISSION:
- ctx->Exec->Materialfv( GL_BACK, GL_EMISSION, v );
+ CALL_Materialfv(ctx->Exec, ( GL_BACK, GL_EMISSION, v ));
break;
case _TNL_ATTRIB_MAT_FRONT_AMBIENT:
- ctx->Exec->Materialfv( GL_FRONT, GL_AMBIENT, v );
+ CALL_Materialfv(ctx->Exec, ( GL_FRONT, GL_AMBIENT, v ));
break;
case _TNL_ATTRIB_MAT_BACK_AMBIENT:
- ctx->Exec->Materialfv( GL_BACK, GL_AMBIENT, v );
+ CALL_Materialfv(ctx->Exec, ( GL_BACK, GL_AMBIENT, v ));
break;
case _TNL_ATTRIB_MAT_FRONT_DIFFUSE:
- ctx->Exec->Materialfv( GL_FRONT, GL_DIFFUSE, v );
+ CALL_Materialfv(ctx->Exec, ( GL_FRONT, GL_DIFFUSE, v ));
break;
case _TNL_ATTRIB_MAT_BACK_DIFFUSE:
- ctx->Exec->Materialfv( GL_BACK, GL_DIFFUSE, v );
+ CALL_Materialfv(ctx->Exec, ( GL_BACK, GL_DIFFUSE, v ));
break;
case _TNL_ATTRIB_MAT_FRONT_SPECULAR:
- ctx->Exec->Materialfv( GL_FRONT, GL_SPECULAR, v );
+ CALL_Materialfv(ctx->Exec, ( GL_FRONT, GL_SPECULAR, v ));
break;
case _TNL_ATTRIB_MAT_BACK_SPECULAR:
- ctx->Exec->Materialfv( GL_BACK, GL_SPECULAR, v );
+ CALL_Materialfv(ctx->Exec, ( GL_BACK, GL_SPECULAR, v ));
break;
}
}
static void index_attr1fv(GLcontext *ctx, GLint target, const GLfloat *v)
{
(void) target;
- ctx->Exec->Indexf(v[0]);
+ CALL_Indexf(ctx->Exec, (v[0]));
}
static void edgeflag_attr1fv(GLcontext *ctx, GLint target, const GLfloat *v)
{
(void) target;
- ctx->Exec->EdgeFlag((GLboolean)(v[0] == 1.0));
+ CALL_EdgeFlag(ctx->Exec, ((GLboolean)(v[0] == 1.0)));
}
struct loopback_attr {
GLuint k;
if (prim->mode & PRIM_BEGIN) {
- GL_CALL(Begin)( prim->mode & PRIM_MODE_MASK );
+ CALL_Begin(GET_DISPATCH(), ( prim->mode & PRIM_MODE_MASK ));
}
else {
assert(i == 0);
}
if (prim->mode & PRIM_END) {
- GL_CALL(End)();
+ CALL_End(GET_DISPATCH(), ());
}
else {
assert (i == list->prim_count-1);
#include "t_vtx_api.h"
#include "simple_list.h"
+#include "dispatch.h"
+
static void reset_attrfv( TNLcontext *tnl );
static tnl_attrfv_func choose[_TNL_MAX_ATTR_CODEGEN+1][4]; /* +1 for ERROR_ATTRIB */
if (!(tnl->Driver.NotifyBegin &&
tnl->Driver.NotifyBegin( ctx, mode )))
- ctx->Exec->Begin(mode);
+ CALL_Begin(ctx->Exec, (mode));
return;
}
#include "macros.h"
#include "math/m_eval.h"
#include "t_vtx_api.h"
+#include "dispatch.h"
static void clear_active_eval1( TNLcontext *tnl, GLuint attr )
map->Order);
if (tnl->vtx.eval.map1[0].sz == 4)
- GL_CALL(Vertex4fv)( vertex );
+ CALL_Vertex4fv(GET_DISPATCH(), ( vertex ));
else
- GL_CALL(Vertex3fv)( vertex );
+ CALL_Vertex3fv(GET_DISPATCH(), ( vertex ));
}
}
}
if (tnl->vtx.attrsz[0] == 4)
- GL_CALL(Vertex4fv)( vertex );
+ CALL_Vertex4fv(GET_DISPATCH(), ( vertex ));
else
- GL_CALL(Vertex3fv)( vertex );
+ CALL_Vertex3fv(GET_DISPATCH(), ( vertex ));
}
}
if ( ctx->Light.Enabled ) {
if ( ctx->Light.ColorMaterialEnabled ) {
- ctx->Exec->Color3f = TAG(ColorMaterial3f);
+ SET_Color3f(ctx->Exec, TAG(ColorMaterial3f));
} else {
- ctx->Exec->Color3f = _mesa_noop_Color3f;
+ SET_Color3f(ctx->Exec, _mesa_noop_Color3f);
}
} else {
- ctx->Exec->Color3f = TAG(Color3f);
+ SET_Color3f(ctx->Exec, TAG(Color3f));
}
glColor3f( r, g, b );
}
if ( ctx->Light.Enabled ) {
if ( ctx->Light.ColorMaterialEnabled ) {
- ctx->Exec->Color3fv = TAG(ColorMaterial3fv);
+ SET_Color3fv(ctx->Exec, TAG(ColorMaterial3fv));
} else {
- ctx->Exec->Color3fv = _mesa_noop_Color3fv;
+ SET_Color3fv(ctx->Exec, _mesa_noop_Color3fv);
}
} else {
- ctx->Exec->Color3fv = TAG(Color3fv);
+ SET_Color3fv(ctx->Exec, TAG(Color3fv));
}
glColor3fv( v );
}
if ( ctx->Light.Enabled ) {
if ( ctx->Light.ColorMaterialEnabled ) {
- ctx->Exec->Color3ub = TAG(ColorMaterial3ub);
+ SET_Color3ub(ctx->Exec, TAG(ColorMaterial3ub));
} else {
- ctx->Exec->Color3ub = _mesa_noop_Color3ub;
+ SET_Color3ub(ctx->Exec, _mesa_noop_Color3ub);
}
} else {
- ctx->Exec->Color3ub = TAG(Color3ub);
+ SET_Color3ub(ctx->Exec, TAG(Color3ub));
}
glColor3ub( r, g, b );
}
if ( ctx->Light.Enabled ) {
if ( ctx->Light.ColorMaterialEnabled ) {
- ctx->Exec->Color3ubv = TAG(ColorMaterial3ubv);
+ SET_Color3ubv(ctx->Exec, TAG(ColorMaterial3ubv));
} else {
- ctx->Exec->Color3ubv = _mesa_noop_Color3ubv;
+ SET_Color3ubv(ctx->Exec, _mesa_noop_Color3ubv);
}
} else {
- ctx->Exec->Color3ubv = TAG(Color3ubv);
+ SET_Color3ubv(ctx->Exec, TAG(Color3ubv));
}
glColor3ubv( v );
}
if ( ctx->Light.Enabled ) {
if ( ctx->Light.ColorMaterialEnabled ) {
- ctx->Exec->Color4f = TAG(ColorMaterial4f);
+ SET_Color4f(ctx->Exec, TAG(ColorMaterial4f));
} else {
- ctx->Exec->Color4f = _mesa_noop_Color4f;
+ SET_Color4f(ctx->Exec, _mesa_noop_Color4f);
}
} else {
- ctx->Exec->Color4f = TAG(Color4f);
+ SET_Color4f(ctx->Exec, TAG(Color4f));
}
glColor4f( r, g, b, a );
}
if ( ctx->Light.Enabled ) {
if ( ctx->Light.ColorMaterialEnabled ) {
- ctx->Exec->Color4fv = TAG(ColorMaterial4fv);
+ SET_Color4fv(ctx->Exec, TAG(ColorMaterial4fv));
} else {
- ctx->Exec->Color4fv = _mesa_noop_Color4fv;
+ SET_Color4fv(ctx->Exec, _mesa_noop_Color4fv);
}
} else {
- ctx->Exec->Color4fv = TAG(Color4fv);
+ SET_Color4fv(ctx->Exec, TAG(Color4fv));
}
glColor4fv( v );
}
if ( ctx->Light.Enabled ) {
if ( ctx->Light.ColorMaterialEnabled ) {
- ctx->Exec->Color4ub = TAG(ColorMaterial4ub);
+ SET_Color4ub(ctx->Exec, TAG(ColorMaterial4ub));
} else {
- ctx->Exec->Color4ub = _mesa_noop_Color4ub;
+ SET_Color4ub(ctx->Exec, _mesa_noop_Color4ub);
}
} else {
- ctx->Exec->Color4ub = TAG(Color4ub);
+ SET_Color4ub(ctx->Exec, TAG(Color4ub));
}
glColor4ub( r, g, b, a );
}
if ( ctx->Light.Enabled ) {
if ( ctx->Light.ColorMaterialEnabled ) {
- ctx->Exec->Color4ubv = TAG(ColorMaterial4ubv);
+ SET_Color4ubv(ctx->Exec, TAG(ColorMaterial4ubv));
} else {
- ctx->Exec->Color4ubv = _mesa_noop_Color4ubv;
+ SET_Color4ubv(ctx->Exec, _mesa_noop_Color4ubv);
}
} else {
- ctx->Exec->Color4ubv = TAG(Color4ubv);
+ SET_Color4ubv(ctx->Exec, TAG(Color4ubv));
}
glColor4ubv( v );
}
projects / platform / upstream / mesa.git / commitdiff