You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3621 lines
98 KiB
3621 lines
98 KiB
/******************************Module*Header*******************************\
|
|
* Module Name: dl_lcomp.c
|
|
*
|
|
* Display list compilation routines.
|
|
*
|
|
* Created: 12-24-1995
|
|
* Author: Hock San Lee [hockl]
|
|
*
|
|
* Copyright (c) 1995-96 Microsoft Corporation
|
|
\**************************************************************************/
|
|
/*
|
|
** Copyright 1992, Silicon Graphics, Inc.
|
|
** All Rights Reserved.
|
|
**
|
|
** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
|
|
** the contents of this file may not be disclosed to third parties, copied or
|
|
** duplicated in any form, in whole or in part, without the prior written
|
|
** permission of Silicon Graphics, Inc.
|
|
**
|
|
** RESTRICTED RIGHTS LEGEND:
|
|
** Use, duplication or disclosure by the Government is subject to restrictions
|
|
** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
|
|
** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
|
|
** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
|
|
** rights reserved under the Copyright Laws of the United States.
|
|
*/
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
/*
|
|
** Compilation routines for building display lists for all of the basic
|
|
** OpenGL commands. These were automatically generated at one point,
|
|
** but now the basic format has stabilized, and we make minor changes to
|
|
** individual routines from time to time.
|
|
*/
|
|
|
|
/***************************************************************************/
|
|
// Color functions.
|
|
// Compile only Color3ub, Color3f, Color4ub, and Color4f functions.
|
|
// Convert the other functions to one of the compiled Color functions.
|
|
|
|
void APIENTRY
|
|
__gllc_Color3ub ( IN GLubyte red, IN GLubyte green, IN GLubyte blue )
|
|
{
|
|
struct __gllc_Color3ubv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glColor3ub)(red, green, blue);
|
|
|
|
// Record "otherColor" here
|
|
if (gc->modes.colorIndexMode)
|
|
{
|
|
gc->dlist.beginRec->flags |= DLIST_BEGIN_HAS_OTHER_COLOR;
|
|
gc->dlist.beginRec->otherColor = gc->paTeb->otherColor;
|
|
}
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_Color3ubv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Color3ubv_Rec)),
|
|
DLIST_GENERIC_OP(Color3ubv));
|
|
if (data == NULL) return;
|
|
data->v[0] = red;
|
|
data->v[1] = green;
|
|
data->v[2] = blue;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_COLOR;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Color3ubv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3ubv ( IN const GLubyte v[3] )
|
|
{
|
|
__gllc_Color3ub(v[0], v[1], v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3f ( IN GLfloat red, IN GLfloat green, IN GLfloat blue )
|
|
{
|
|
struct __gllc_Color3fv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glColor3f)(red, green, blue);
|
|
|
|
// Record "otherColor" here
|
|
if (gc->modes.colorIndexMode)
|
|
{
|
|
gc->dlist.beginRec->flags |= DLIST_BEGIN_HAS_OTHER_COLOR;
|
|
gc->dlist.beginRec->otherColor = gc->paTeb->otherColor;
|
|
}
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_Color3fv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Color3fv_Rec)),
|
|
DLIST_GENERIC_OP(Color3fv));
|
|
if (data == NULL) return;
|
|
data->v[0] = red;
|
|
data->v[1] = green;
|
|
data->v[2] = blue;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_COLOR;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Color3fv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3fv ( IN const GLfloat v[3] )
|
|
{
|
|
__gllc_Color3f(v[0], v[1], v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3b ( IN GLbyte red, IN GLbyte green, IN GLbyte blue )
|
|
{
|
|
__gllc_Color3f(__GL_B_TO_FLOAT(red), __GL_B_TO_FLOAT(green),
|
|
__GL_B_TO_FLOAT(blue));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3bv ( IN const GLbyte v[3] )
|
|
{
|
|
__gllc_Color3f(__GL_B_TO_FLOAT(v[0]), __GL_B_TO_FLOAT(v[1]),
|
|
__GL_B_TO_FLOAT(v[2]));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3d ( IN GLdouble red, IN GLdouble green, IN GLdouble blue )
|
|
{
|
|
__gllc_Color3f((GLfloat) red, (GLfloat) green, (GLfloat) blue);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3dv ( IN const GLdouble v[3] )
|
|
{
|
|
__gllc_Color3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3i ( IN GLint red, IN GLint green, IN GLint blue )
|
|
{
|
|
__gllc_Color3f(__GL_I_TO_FLOAT(red), __GL_I_TO_FLOAT(green),
|
|
__GL_I_TO_FLOAT(blue));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3iv ( IN const GLint v[3] )
|
|
{
|
|
__gllc_Color3f(__GL_I_TO_FLOAT(v[0]), __GL_I_TO_FLOAT(v[1]),
|
|
__GL_I_TO_FLOAT(v[2]));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3s ( IN GLshort red, IN GLshort green, IN GLshort blue )
|
|
{
|
|
__gllc_Color3f(__GL_S_TO_FLOAT(red), __GL_S_TO_FLOAT(green),
|
|
__GL_S_TO_FLOAT(blue));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3sv ( IN const GLshort v[3] )
|
|
{
|
|
__gllc_Color3f(__GL_S_TO_FLOAT(v[0]), __GL_S_TO_FLOAT(v[1]),
|
|
__GL_S_TO_FLOAT(v[2]));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3ui ( IN GLuint red, IN GLuint green, IN GLuint blue )
|
|
{
|
|
__gllc_Color3f(__GL_UI_TO_FLOAT(red), __GL_UI_TO_FLOAT(green),
|
|
__GL_UI_TO_FLOAT(blue));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3uiv ( IN const GLuint v[3] )
|
|
{
|
|
__gllc_Color3f(__GL_UI_TO_FLOAT(v[0]), __GL_UI_TO_FLOAT(v[1]),
|
|
__GL_UI_TO_FLOAT(v[2]));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3us ( IN GLushort red, IN GLushort green, IN GLushort blue )
|
|
{
|
|
__gllc_Color3f(__GL_US_TO_FLOAT(red), __GL_US_TO_FLOAT(green),
|
|
__GL_US_TO_FLOAT(blue));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color3usv ( IN const GLushort v[3] )
|
|
{
|
|
__gllc_Color3f(__GL_US_TO_FLOAT(v[0]), __GL_US_TO_FLOAT(v[1]),
|
|
__GL_US_TO_FLOAT(v[2]));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4ub ( IN GLubyte red, IN GLubyte green, IN GLubyte blue, IN GLubyte alpha )
|
|
{
|
|
struct __gllc_Color4ubv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glColor4ub)(red, green, blue, alpha);
|
|
|
|
// Record "otherColor" here
|
|
if (gc->modes.colorIndexMode)
|
|
{
|
|
gc->dlist.beginRec->flags |= DLIST_BEGIN_HAS_OTHER_COLOR;
|
|
gc->dlist.beginRec->otherColor = gc->paTeb->otherColor;
|
|
}
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_Color4ubv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Color4ubv_Rec)),
|
|
DLIST_GENERIC_OP(Color4ubv));
|
|
if (data == NULL) return;
|
|
data->v[0] = red;
|
|
data->v[1] = green;
|
|
data->v[2] = blue;
|
|
data->v[3] = alpha;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_COLOR;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Color4ubv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4ubv ( IN const GLubyte v[4] )
|
|
{
|
|
__gllc_Color4ub(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4f ( IN GLfloat red, IN GLfloat green, IN GLfloat blue, IN GLfloat alpha )
|
|
{
|
|
struct __gllc_Color4fv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glColor4f)(red, green, blue, alpha);
|
|
|
|
// Record "otherColor" here
|
|
if (gc->modes.colorIndexMode)
|
|
{
|
|
gc->dlist.beginRec->flags |= DLIST_BEGIN_HAS_OTHER_COLOR;
|
|
gc->dlist.beginRec->otherColor = gc->paTeb->otherColor;
|
|
}
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_Color4fv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Color4fv_Rec)),
|
|
DLIST_GENERIC_OP(Color4fv));
|
|
if (data == NULL) return;
|
|
data->v[0] = red;
|
|
data->v[1] = green;
|
|
data->v[2] = blue;
|
|
data->v[3] = alpha;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_COLOR;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Color4fv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4fv ( IN const GLfloat v[4] )
|
|
{
|
|
__gllc_Color4f(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4b ( IN GLbyte red, IN GLbyte green, IN GLbyte blue, IN GLbyte alpha )
|
|
{
|
|
__gllc_Color4f(__GL_B_TO_FLOAT(red), __GL_B_TO_FLOAT(green),
|
|
__GL_B_TO_FLOAT(blue), __GL_B_TO_FLOAT(alpha));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4bv ( IN const GLbyte v[4] )
|
|
{
|
|
__gllc_Color4f(__GL_B_TO_FLOAT(v[0]), __GL_B_TO_FLOAT(v[1]),
|
|
__GL_B_TO_FLOAT(v[2]), __GL_B_TO_FLOAT(v[3]));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4d ( IN GLdouble red, IN GLdouble green, IN GLdouble blue, IN GLdouble alpha )
|
|
{
|
|
__gllc_Color4f((GLfloat) red, (GLfloat) green, (GLfloat) blue, (GLfloat) alpha);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4dv ( IN const GLdouble v[4] )
|
|
{
|
|
__gllc_Color4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4i ( IN GLint red, IN GLint green, IN GLint blue, IN GLint alpha )
|
|
{
|
|
__gllc_Color4f(__GL_I_TO_FLOAT(red), __GL_I_TO_FLOAT(green),
|
|
__GL_I_TO_FLOAT(blue), __GL_I_TO_FLOAT(alpha));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4iv ( IN const GLint v[4] )
|
|
{
|
|
__gllc_Color4f(__GL_I_TO_FLOAT(v[0]), __GL_I_TO_FLOAT(v[1]),
|
|
__GL_I_TO_FLOAT(v[2]), __GL_I_TO_FLOAT(v[3]));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4s ( IN GLshort red, IN GLshort green, IN GLshort blue, IN GLshort alpha )
|
|
{
|
|
__gllc_Color4f(__GL_S_TO_FLOAT(red), __GL_S_TO_FLOAT(green),
|
|
__GL_S_TO_FLOAT(blue), __GL_S_TO_FLOAT(alpha));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4sv ( IN const GLshort v[4] )
|
|
{
|
|
__gllc_Color4f(__GL_S_TO_FLOAT(v[0]), __GL_S_TO_FLOAT(v[1]),
|
|
__GL_S_TO_FLOAT(v[2]), __GL_S_TO_FLOAT(v[3]));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4ui ( IN GLuint red, IN GLuint green, IN GLuint blue, IN GLuint alpha )
|
|
{
|
|
__gllc_Color4f(__GL_UI_TO_FLOAT(red), __GL_UI_TO_FLOAT(green),
|
|
__GL_UI_TO_FLOAT(blue), __GL_UI_TO_FLOAT(alpha));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4uiv ( IN const GLuint v[4] )
|
|
{
|
|
__gllc_Color4f(__GL_UI_TO_FLOAT(v[0]), __GL_UI_TO_FLOAT(v[1]),
|
|
__GL_UI_TO_FLOAT(v[2]), __GL_UI_TO_FLOAT(v[3]));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4us ( IN GLushort red, IN GLushort green, IN GLushort blue, IN GLushort alpha )
|
|
{
|
|
__gllc_Color4f(__GL_US_TO_FLOAT(red), __GL_US_TO_FLOAT(green),
|
|
__GL_US_TO_FLOAT(blue), __GL_US_TO_FLOAT(alpha));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Color4usv ( IN const GLushort v[4] )
|
|
{
|
|
__gllc_Color4f(__GL_US_TO_FLOAT(v[0]), __GL_US_TO_FLOAT(v[1]),
|
|
__GL_US_TO_FLOAT(v[2]), __GL_US_TO_FLOAT(v[3]));
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// EdgeFlag functions.
|
|
// Compile only EdgeFlag function.
|
|
// Convert the other function to the compiled EdgeFlag function.
|
|
|
|
void APIENTRY
|
|
__gllc_EdgeFlag ( IN GLboolean flag )
|
|
{
|
|
struct __gllc_EdgeFlag_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glEdgeFlag)(flag);
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_EdgeFlag_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_EdgeFlag_Rec)),
|
|
DLIST_GENERIC_OP(EdgeFlag));
|
|
if (data == NULL) return;
|
|
data->flag = flag;
|
|
__glDlistAppendOp(gc, data, __glle_EdgeFlag);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EdgeFlagv ( IN const GLboolean flag[1] )
|
|
{
|
|
__gllc_EdgeFlag(flag[0]);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Index functions.
|
|
// Compile only Indexf function.
|
|
// Convert the other functions to the compiled Indexf function.
|
|
|
|
void APIENTRY
|
|
__gllc_Indexf ( IN GLfloat c )
|
|
{
|
|
struct __gllc_Indexf_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glIndexf)(c);
|
|
|
|
// Record "otherColor" here
|
|
if (!gc->modes.colorIndexMode)
|
|
{
|
|
gc->dlist.beginRec->flags |= DLIST_BEGIN_HAS_OTHER_COLOR;
|
|
gc->dlist.beginRec->otherColor.r = gc->paTeb->otherColor.r;
|
|
}
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_Indexf_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Indexf_Rec)),
|
|
DLIST_GENERIC_OP(Indexf));
|
|
if (data == NULL) return;
|
|
data->c = c;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_INDEX;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Indexf);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Indexfv ( IN const GLfloat c[1] )
|
|
{
|
|
__gllc_Indexf(c[0]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Indexd ( IN GLdouble c )
|
|
{
|
|
__gllc_Indexf((GLfloat) c);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Indexdv ( IN const GLdouble c[1] )
|
|
{
|
|
__gllc_Indexf((GLfloat) c[0]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Indexi ( IN GLint c )
|
|
{
|
|
__gllc_Indexf((GLfloat) c);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Indexiv ( IN const GLint c[1] )
|
|
{
|
|
__gllc_Indexf((GLfloat) c[0]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Indexs ( IN GLshort c )
|
|
{
|
|
__gllc_Indexf((GLfloat) c);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Indexsv ( IN const GLshort c[1] )
|
|
{
|
|
__gllc_Indexf((GLfloat) c[0]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Indexub ( IN GLubyte c )
|
|
{
|
|
__gllc_Indexf((GLfloat) c);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Indexubv ( IN const GLubyte c[1] )
|
|
{
|
|
__gllc_Indexf((GLfloat) c[0]);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Normal functions.
|
|
// Compile only Normal3b and Normal3f functions.
|
|
// Convert the other functions to one of the compiled Normal functions.
|
|
|
|
void APIENTRY
|
|
__gllc_Normal3b ( IN GLbyte nx, IN GLbyte ny, IN GLbyte nz )
|
|
{
|
|
struct __gllc_Normal3bv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glNormal3b)(nx, ny, nz);
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_Normal3bv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Normal3bv_Rec)),
|
|
DLIST_GENERIC_OP(Normal3bv));
|
|
if (data == NULL) return;
|
|
data->v[0] = nx;
|
|
data->v[1] = ny;
|
|
data->v[2] = nz;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_NORMAL;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Normal3bv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Normal3bv ( IN const GLbyte v[3] )
|
|
{
|
|
__gllc_Normal3b(v[0], v[1], v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Normal3f ( IN GLfloat nx, IN GLfloat ny, IN GLfloat nz )
|
|
{
|
|
struct __gllc_Normal3fv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glNormal3f)(nx, ny, nz);
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_Normal3fv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Normal3fv_Rec)),
|
|
DLIST_GENERIC_OP(Normal3fv));
|
|
if (data == NULL) return;
|
|
data->v[0] = nx;
|
|
data->v[1] = ny;
|
|
data->v[2] = nz;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_NORMAL;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Normal3fv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Normal3fv ( IN const GLfloat v[3] )
|
|
{
|
|
__gllc_Normal3f(v[0], v[1], v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Normal3d ( IN GLdouble nx, IN GLdouble ny, IN GLdouble nz )
|
|
{
|
|
__gllc_Normal3f((GLfloat) nx, (GLfloat) ny, (GLfloat) nz);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Normal3dv ( IN const GLdouble v[3] )
|
|
{
|
|
__gllc_Normal3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Normal3i ( IN GLint nx, IN GLint ny, IN GLint nz )
|
|
{
|
|
__gllc_Normal3f(__GL_I_TO_FLOAT(nx), __GL_I_TO_FLOAT(ny),
|
|
__GL_I_TO_FLOAT(nz));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Normal3iv ( IN const GLint v[3] )
|
|
{
|
|
__gllc_Normal3f(__GL_I_TO_FLOAT(v[0]), __GL_I_TO_FLOAT(v[1]),
|
|
__GL_I_TO_FLOAT(v[2]));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Normal3s ( IN GLshort nx, IN GLshort ny, IN GLshort nz )
|
|
{
|
|
__gllc_Normal3f(__GL_S_TO_FLOAT(nx), __GL_S_TO_FLOAT(ny),
|
|
__GL_S_TO_FLOAT(nz));
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Normal3sv ( IN const GLshort v[3] )
|
|
{
|
|
__gllc_Normal3f(__GL_S_TO_FLOAT(v[0]), __GL_S_TO_FLOAT(v[1]),
|
|
__GL_S_TO_FLOAT(v[2]));
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// RasterPos functions.
|
|
// Compile only RasterPos2f, RasterPos3f and RasterPos4f functions.
|
|
// Convert the other functions to one of the compiled RasterPos functions.
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos2f ( IN GLfloat x, IN GLfloat y )
|
|
{
|
|
struct __gllc_RasterPos2f_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_RasterPos2f_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_RasterPos2f_Rec)),
|
|
DLIST_GENERIC_OP(RasterPos2f));
|
|
if (data == NULL) return;
|
|
data->x = x;
|
|
data->y = y;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_RASTERPOS;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_RasterPos2f);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos2fv ( IN const GLfloat v[2] )
|
|
{
|
|
__gllc_RasterPos2f(v[0], v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos2d ( IN GLdouble x, IN GLdouble y )
|
|
{
|
|
__gllc_RasterPos2f((GLfloat) x, (GLfloat) y);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos2dv ( IN const GLdouble v[2] )
|
|
{
|
|
__gllc_RasterPos2f((GLfloat) v[0], (GLfloat) v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos2i ( IN GLint x, IN GLint y )
|
|
{
|
|
__gllc_RasterPos2f((GLfloat) x, (GLfloat) y);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos2iv ( IN const GLint v[2] )
|
|
{
|
|
__gllc_RasterPos2f((GLfloat) v[0], (GLfloat) v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos2s ( IN GLshort x, IN GLshort y )
|
|
{
|
|
__gllc_RasterPos2f((GLfloat) x, (GLfloat) y);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos2sv ( IN const GLshort v[2] )
|
|
{
|
|
__gllc_RasterPos2f((GLfloat) v[0], (GLfloat) v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos3f ( IN GLfloat x, IN GLfloat y, IN GLfloat z )
|
|
{
|
|
struct __gllc_RasterPos3fv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_RasterPos3fv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_RasterPos3fv_Rec)),
|
|
DLIST_GENERIC_OP(RasterPos3fv));
|
|
if (data == NULL) return;
|
|
data->v[0] = x;
|
|
data->v[1] = y;
|
|
data->v[2] = z;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_RASTERPOS;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_RasterPos3fv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos3fv ( IN const GLfloat v[3] )
|
|
{
|
|
__gllc_RasterPos3f(v[0], v[1], v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos3d ( IN GLdouble x, IN GLdouble y, IN GLdouble z )
|
|
{
|
|
__gllc_RasterPos3f((GLfloat) x, (GLfloat) y, (GLfloat) z);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos3dv ( IN const GLdouble v[3] )
|
|
{
|
|
__gllc_RasterPos3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos3i ( IN GLint x, IN GLint y, IN GLint z )
|
|
{
|
|
__gllc_RasterPos3f((GLfloat) x, (GLfloat) y, (GLfloat) z);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos3iv ( IN const GLint v[3] )
|
|
{
|
|
__gllc_RasterPos3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos3s ( IN GLshort x, IN GLshort y, IN GLshort z )
|
|
{
|
|
__gllc_RasterPos3f((GLfloat) x, (GLfloat) y, (GLfloat) z);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos3sv ( IN const GLshort v[3] )
|
|
{
|
|
__gllc_RasterPos3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos4f ( IN GLfloat x, IN GLfloat y, IN GLfloat z, IN GLfloat w )
|
|
{
|
|
struct __gllc_RasterPos4fv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_RasterPos4fv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_RasterPos4fv_Rec)),
|
|
DLIST_GENERIC_OP(RasterPos4fv));
|
|
if (data == NULL) return;
|
|
data->v[0] = x;
|
|
data->v[1] = y;
|
|
data->v[2] = z;
|
|
data->v[3] = w;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_RASTERPOS;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_RasterPos4fv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos4fv ( IN const GLfloat v[4] )
|
|
{
|
|
__gllc_RasterPos4f(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos4d ( IN GLdouble x, IN GLdouble y, IN GLdouble z, IN GLdouble w )
|
|
{
|
|
__gllc_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos4dv ( IN const GLdouble v[4] )
|
|
{
|
|
__gllc_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos4i ( IN GLint x, IN GLint y, IN GLint z, IN GLint w )
|
|
{
|
|
__gllc_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos4iv ( IN const GLint v[4] )
|
|
{
|
|
__gllc_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos4s ( IN GLshort x, IN GLshort y, IN GLshort z, IN GLshort w )
|
|
{
|
|
__gllc_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_RasterPos4sv ( IN const GLshort v[4] )
|
|
{
|
|
__gllc_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Rect functions.
|
|
// Compile only Rectf function.
|
|
// Convert the other functions to the compiled Rectf function.
|
|
|
|
void APIENTRY
|
|
__gllc_Rectf ( IN GLfloat x1, IN GLfloat y1, IN GLfloat x2, IN GLfloat y2 )
|
|
{
|
|
struct __gllc_Rectf_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Rectf_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Rectf_Rec)),
|
|
DLIST_GENERIC_OP(Rectf));
|
|
if (data == NULL) return;
|
|
data->x1 = x1;
|
|
data->y1 = y1;
|
|
data->x2 = x2;
|
|
data->y2 = y2;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_RECT;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Rectf);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Rectfv ( IN const GLfloat v1[2], IN const GLfloat v2[2] )
|
|
{
|
|
__gllc_Rectf(v1[0], v1[1], v2[0], v2[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Rectd ( IN GLdouble x1, IN GLdouble y1, IN GLdouble x2, IN GLdouble y2 )
|
|
{
|
|
__gllc_Rectf((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Rectdv ( IN const GLdouble v1[2], IN const GLdouble v2[2] )
|
|
{
|
|
__gllc_Rectf((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Recti ( IN GLint x1, IN GLint y1, IN GLint x2, IN GLint y2 )
|
|
{
|
|
__gllc_Rectf((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Rectiv ( IN const GLint v1[2], IN const GLint v2[2] )
|
|
{
|
|
__gllc_Rectf((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Rects ( IN GLshort x1, IN GLshort y1, IN GLshort x2, IN GLshort y2 )
|
|
{
|
|
__gllc_Rectf((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Rectsv ( IN const GLshort v1[2], IN const GLshort v2[2] )
|
|
{
|
|
__gllc_Rectf((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// TexCoord functions.
|
|
// Compile only TexCoord1f, TexCoord2f, TexCoord3f and TexCoord4f functions.
|
|
// Convert the other functions to one of the compiled TexCoord functions.
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord1f ( IN GLfloat s )
|
|
{
|
|
struct __gllc_TexCoord1f_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glTexCoord1f)(s);
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_TexCoord1f_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_TexCoord1f_Rec)),
|
|
DLIST_GENERIC_OP(TexCoord1f));
|
|
if (data == NULL) return;
|
|
data->s = s;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_TEXCOORDS;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_TexCoord1f);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord1fv ( IN const GLfloat v[1] )
|
|
{
|
|
__gllc_TexCoord1f(v[0]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord1d ( IN GLdouble s )
|
|
{
|
|
__gllc_TexCoord1f((GLfloat) s);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord1dv ( IN const GLdouble v[1] )
|
|
{
|
|
__gllc_TexCoord1f((GLfloat) v[0]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord1i ( IN GLint s )
|
|
{
|
|
__gllc_TexCoord1f((GLfloat) s);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord1iv ( IN const GLint v[1] )
|
|
{
|
|
__gllc_TexCoord1f((GLfloat) v[0]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord1s ( IN GLshort s )
|
|
{
|
|
__gllc_TexCoord1f((GLfloat) s);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord1sv ( IN const GLshort v[1] )
|
|
{
|
|
__gllc_TexCoord1f((GLfloat) v[0]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord2f ( IN GLfloat s, IN GLfloat t )
|
|
{
|
|
struct __gllc_TexCoord2f_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glTexCoord2f)(s, t);
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_TexCoord2f_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_TexCoord2f_Rec)),
|
|
DLIST_GENERIC_OP(TexCoord2f));
|
|
if (data == NULL) return;
|
|
data->s = s;
|
|
data->t = t;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_TEXCOORDS;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_TexCoord2f);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord2fv ( IN const GLfloat v[2] )
|
|
{
|
|
__gllc_TexCoord2f(v[0], v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord2d ( IN GLdouble s, IN GLdouble t )
|
|
{
|
|
__gllc_TexCoord2f((GLfloat) s, (GLfloat) t);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord2dv ( IN const GLdouble v[2] )
|
|
{
|
|
__gllc_TexCoord2f((GLfloat) v[0], (GLfloat) v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord2i ( IN GLint s, IN GLint t )
|
|
{
|
|
__gllc_TexCoord2f((GLfloat) s, (GLfloat) t);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord2iv ( IN const GLint v[2] )
|
|
{
|
|
__gllc_TexCoord2f((GLfloat) v[0], (GLfloat) v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord2s ( IN GLshort s, IN GLshort t )
|
|
{
|
|
__gllc_TexCoord2f((GLfloat) s, (GLfloat) t);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord2sv ( IN const GLshort v[2] )
|
|
{
|
|
__gllc_TexCoord2f((GLfloat) v[0], (GLfloat) v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord3f ( IN GLfloat s, IN GLfloat t, IN GLfloat r )
|
|
{
|
|
struct __gllc_TexCoord3fv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glTexCoord3f)(s, t, r);
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_TexCoord3fv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_TexCoord3fv_Rec)),
|
|
DLIST_GENERIC_OP(TexCoord3fv));
|
|
if (data == NULL) return;
|
|
data->v[0] = s;
|
|
data->v[1] = t;
|
|
data->v[2] = r;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_TEXCOORDS;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_TexCoord3fv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord3fv ( IN const GLfloat v[3] )
|
|
{
|
|
__gllc_TexCoord3f(v[0], v[1], v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord3d ( IN GLdouble s, IN GLdouble t, IN GLdouble r )
|
|
{
|
|
__gllc_TexCoord3f((GLfloat) s, (GLfloat) t, (GLfloat) r);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord3dv ( IN const GLdouble v[3] )
|
|
{
|
|
__gllc_TexCoord3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord3i ( IN GLint s, IN GLint t, IN GLint r )
|
|
{
|
|
__gllc_TexCoord3f((GLfloat) s, (GLfloat) t, (GLfloat) r);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord3iv ( IN const GLint v[3] )
|
|
{
|
|
__gllc_TexCoord3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord3s ( IN GLshort s, IN GLshort t, IN GLshort r )
|
|
{
|
|
__gllc_TexCoord3f((GLfloat) s, (GLfloat) t, (GLfloat) r);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord3sv ( IN const GLshort v[3] )
|
|
{
|
|
__gllc_TexCoord3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord4f ( IN GLfloat s, IN GLfloat t, IN GLfloat r, IN GLfloat q )
|
|
{
|
|
struct __gllc_TexCoord4fv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glTexCoord4f)(s, t, r, q);
|
|
return;
|
|
}
|
|
|
|
data = (struct __gllc_TexCoord4fv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_TexCoord4fv_Rec)),
|
|
DLIST_GENERIC_OP(TexCoord4fv));
|
|
if (data == NULL) return;
|
|
data->v[0] = s;
|
|
data->v[1] = t;
|
|
data->v[2] = r;
|
|
data->v[3] = q;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_TEXCOORDS;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_TexCoord4fv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord4fv ( IN const GLfloat v[4] )
|
|
{
|
|
__gllc_TexCoord4f(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord4d ( IN GLdouble s, IN GLdouble t, IN GLdouble r, IN GLdouble q )
|
|
{
|
|
__gllc_TexCoord4f((GLfloat) s, (GLfloat) t, (GLfloat) r, (GLfloat) q);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord4dv ( IN const GLdouble v[4] )
|
|
{
|
|
__gllc_TexCoord4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord4i ( IN GLint s, IN GLint t, IN GLint r, IN GLint q )
|
|
{
|
|
__gllc_TexCoord4f((GLfloat) s, (GLfloat) t, (GLfloat) r, (GLfloat) q);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord4iv ( IN const GLint v[4] )
|
|
{
|
|
__gllc_TexCoord4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord4s ( IN GLshort s, IN GLshort t, IN GLshort r, IN GLshort q )
|
|
{
|
|
__gllc_TexCoord4f((GLfloat) s, (GLfloat) t, (GLfloat) r, (GLfloat) q);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexCoord4sv ( IN const GLshort v[4] )
|
|
{
|
|
__gllc_TexCoord4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
|
|
}
|
|
|
|
#ifdef GL_WIN_multiple_textures
|
|
void APIENTRY __gllc_MultiTexCoord1dWIN
|
|
(GLbitfield mask, GLdouble s)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord1dvWIN
|
|
(GLbitfield mask, const GLdouble *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord1fWIN
|
|
(GLbitfield mask, GLfloat s)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord1fvWIN
|
|
(GLbitfield mask, const GLfloat *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord1iWIN
|
|
(GLbitfield mask, GLint s)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord1ivWIN
|
|
(GLbitfield mask, const GLint *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord1sWIN
|
|
(GLbitfield mask, GLshort s)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord1svWIN
|
|
(GLbitfield mask, const GLshort *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord2dWIN
|
|
(GLbitfield mask, GLdouble s, GLdouble t)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord2dvWIN
|
|
(GLbitfield mask, const GLdouble *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord2fWIN
|
|
(GLbitfield mask, GLfloat s, GLfloat t)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord2fvWIN
|
|
(GLbitfield mask, const GLfloat *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord2iWIN
|
|
(GLbitfield mask, GLint s, GLint t)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord2ivWIN
|
|
(GLbitfield mask, const GLint *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord2sWIN
|
|
(GLbitfield mask, GLshort s, GLshort t)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord2svWIN
|
|
(GLbitfield mask, const GLshort *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord3dWIN
|
|
(GLbitfield mask, GLdouble s, GLdouble t, GLdouble r)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord3dvWIN
|
|
(GLbitfield mask, const GLdouble *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord3fWIN
|
|
(GLbitfield mask, GLfloat s, GLfloat t, GLfloat r)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord3fvWIN
|
|
(GLbitfield mask, const GLfloat *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord3iWIN
|
|
(GLbitfield mask, GLint s, GLint t, GLint r)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord3ivWIN
|
|
(GLbitfield mask, const GLint *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord3sWIN
|
|
(GLbitfield mask, GLshort s, GLshort t, GLshort r)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord3svWIN
|
|
(GLbitfield mask, const GLshort *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord4dWIN
|
|
(GLbitfield mask, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord4dvWIN
|
|
(GLbitfield mask, const GLdouble *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord4fWIN
|
|
(GLbitfield mask, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord4fvWIN
|
|
(GLbitfield mask, const GLfloat *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord4iWIN
|
|
(GLbitfield mask, GLint s, GLint t, GLint r, GLint q)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord4ivWIN
|
|
(GLbitfield mask, const GLint *v)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord4sWIN
|
|
(GLbitfield mask, GLshort s, GLshort t, GLshort r, GLshort q)
|
|
{
|
|
}
|
|
|
|
void APIENTRY __gllc_MultiTexCoord4svWIN
|
|
(GLbitfield mask, const GLshort *v)
|
|
{
|
|
}
|
|
#endif // GL_WIN_multiple_textures
|
|
|
|
/***************************************************************************/
|
|
// Vertex functions.
|
|
// Compile only Vertex2f, Vertex3f and Vertex4f functions.
|
|
// Convert the other functions to one of the compiled Vertex functions.
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex2f ( IN GLfloat x, IN GLfloat y )
|
|
{
|
|
struct __gllc_Vertex2f_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update and record the poly data
|
|
// record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
POLYARRAY *pa;
|
|
|
|
pa = gc->paTeb;
|
|
|
|
// If we are in COMPILE_AND_EXECUTE mode or there are attribute
|
|
// changes associated with the vertex, process the poly data.
|
|
if (gc->dlist.mode == GL_COMPILE_AND_EXECUTE
|
|
|| pa->pdNextVertex->flags)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glVertex2f)(x, y);
|
|
__glDlistCompilePolyData(gc, GL_FALSE);
|
|
return;
|
|
}
|
|
|
|
// Otherwise, increment vertex count and compile a Vertex record
|
|
// instead.
|
|
gc->dlist.beginRec->nVertices++;
|
|
}
|
|
|
|
data = (struct __gllc_Vertex2f_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Vertex2f_Rec)),
|
|
DLIST_GENERIC_OP(Vertex2f));
|
|
if (data == NULL) return;
|
|
data->x = x;
|
|
data->y = y;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_VERTEX;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Vertex2f);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex2fv ( IN const GLfloat v[2] )
|
|
{
|
|
__gllc_Vertex2f(v[0], v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex2d ( IN GLdouble x, IN GLdouble y )
|
|
{
|
|
__gllc_Vertex2f((GLfloat) x, (GLfloat) y);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex2dv ( IN const GLdouble v[2] )
|
|
{
|
|
__gllc_Vertex2f((GLfloat) v[0], (GLfloat) v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex2i ( IN GLint x, IN GLint y )
|
|
{
|
|
__gllc_Vertex2f((GLfloat) x, (GLfloat) y);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex2iv ( IN const GLint v[2] )
|
|
{
|
|
__gllc_Vertex2f((GLfloat) v[0], (GLfloat) v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex2s ( IN GLshort x, IN GLshort y )
|
|
{
|
|
__gllc_Vertex2f((GLfloat) x, (GLfloat) y);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex2sv ( IN const GLshort v[2] )
|
|
{
|
|
__gllc_Vertex2f((GLfloat) v[0], (GLfloat) v[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex3f ( IN GLfloat x, IN GLfloat y, IN GLfloat z )
|
|
{
|
|
struct __gllc_Vertex3fv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update and record the poly data
|
|
// record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
POLYARRAY *pa;
|
|
|
|
pa = gc->paTeb;
|
|
|
|
// If we are in COMPILE_AND_EXECUTE mode or there are attribute
|
|
// changes associated with the vertex, process the poly data.
|
|
if (gc->dlist.mode == GL_COMPILE_AND_EXECUTE
|
|
|| pa->pdNextVertex->flags)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glVertex3f)(x, y, z);
|
|
__glDlistCompilePolyData(gc, GL_FALSE);
|
|
return;
|
|
}
|
|
|
|
// Otherwise, increment vertex count and compile a Vertex record
|
|
// instead.
|
|
gc->dlist.beginRec->nVertices++;
|
|
}
|
|
|
|
data = (struct __gllc_Vertex3fv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Vertex3fv_Rec)),
|
|
DLIST_GENERIC_OP(Vertex3fv));
|
|
if (data == NULL) return;
|
|
data->v[0] = x;
|
|
data->v[1] = y;
|
|
data->v[2] = z;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_VERTEX;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Vertex3fv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex3fv ( IN const GLfloat v[3] )
|
|
{
|
|
__gllc_Vertex3f(v[0], v[1], v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex3d ( IN GLdouble x, IN GLdouble y, IN GLdouble z )
|
|
{
|
|
__gllc_Vertex3f((GLfloat) x, (GLfloat) y, (GLfloat) z);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex3dv ( IN const GLdouble v[3] )
|
|
{
|
|
__gllc_Vertex3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex3i ( IN GLint x, IN GLint y, IN GLint z )
|
|
{
|
|
__gllc_Vertex3f((GLfloat) x, (GLfloat) y, (GLfloat) z);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex3iv ( IN const GLint v[3] )
|
|
{
|
|
__gllc_Vertex3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex3s ( IN GLshort x, IN GLshort y, IN GLshort z )
|
|
{
|
|
__gllc_Vertex3f((GLfloat) x, (GLfloat) y, (GLfloat) z);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex3sv ( IN const GLshort v[3] )
|
|
{
|
|
__gllc_Vertex3f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex4f ( IN GLfloat x, IN GLfloat y, IN GLfloat z, IN GLfloat w )
|
|
{
|
|
struct __gllc_Vertex4fv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update and record the poly data
|
|
// record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
POLYARRAY *pa;
|
|
|
|
pa = gc->paTeb;
|
|
|
|
// If we are in COMPILE_AND_EXECUTE mode or there are attribute
|
|
// changes associated with the vertex, process the poly data.
|
|
if (gc->dlist.mode == GL_COMPILE_AND_EXECUTE
|
|
|| pa->pdNextVertex->flags)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glVertex4f)(x, y, z, w);
|
|
__glDlistCompilePolyData(gc, GL_FALSE);
|
|
return;
|
|
}
|
|
|
|
// Otherwise, increment vertex count and compile a Vertex record
|
|
// instead.
|
|
gc->dlist.beginRec->nVertices++;
|
|
}
|
|
|
|
data = (struct __gllc_Vertex4fv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Vertex4fv_Rec)),
|
|
DLIST_GENERIC_OP(Vertex4fv));
|
|
if (data == NULL) return;
|
|
data->v[0] = x;
|
|
data->v[1] = y;
|
|
data->v[2] = z;
|
|
data->v[3] = w;
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_VERTEX;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Vertex4fv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex4fv ( IN const GLfloat v[4] )
|
|
{
|
|
__gllc_Vertex4f(v[0], v[1], v[2], v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex4d ( IN GLdouble x, IN GLdouble y, IN GLdouble z, IN GLdouble w )
|
|
{
|
|
__gllc_Vertex4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex4dv ( IN const GLdouble v[4] )
|
|
{
|
|
__gllc_Vertex4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex4i ( IN GLint x, IN GLint y, IN GLint z, IN GLint w )
|
|
{
|
|
__gllc_Vertex4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex4iv ( IN const GLint v[4] )
|
|
{
|
|
__gllc_Vertex4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex4s ( IN GLshort x, IN GLshort y, IN GLshort z, IN GLshort w )
|
|
{
|
|
__gllc_Vertex4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Vertex4sv ( IN const GLshort v[4] )
|
|
{
|
|
__gllc_Vertex4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Fog functions.
|
|
// Compile only Fogfv function.
|
|
// Convert the other functions to the compiled Fogfv function.
|
|
|
|
void APIENTRY
|
|
__gllc_Fogfv ( IN GLenum pname, IN const GLfloat params[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_Fogfv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = __glFogfv_size(pname) * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
size = sizeof(struct __gllc_Fogfv_Rec) + arraySize;
|
|
data = (struct __gllc_Fogfv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(Fogfv));
|
|
if (data == NULL) return;
|
|
data->pname = pname;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_Fogfv_Rec),
|
|
params, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_Fogfv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Fogf ( IN GLenum pname, IN GLfloat param )
|
|
{
|
|
// FOG_ASSERT
|
|
|
|
if (!RANGE(pname,GL_FOG_INDEX,GL_FOG_MODE))
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
__gllc_Fogfv(pname, ¶m);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Fogi ( IN GLenum pname, IN GLint param )
|
|
{
|
|
GLfloat fParam;
|
|
|
|
// FOG_ASSERT
|
|
|
|
if (!RANGE(pname,GL_FOG_INDEX,GL_FOG_MODE))
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
fParam = (GLfloat) param;
|
|
__gllc_Fogfv(pname, &fParam);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Fogiv ( IN GLenum pname, IN const GLint params[] )
|
|
{
|
|
GLfloat fParams[4];
|
|
|
|
switch (pname)
|
|
{
|
|
case GL_FOG_INDEX:
|
|
case GL_FOG_DENSITY:
|
|
case GL_FOG_START:
|
|
case GL_FOG_END:
|
|
case GL_FOG_MODE:
|
|
fParams[0] = (GLfloat) params[0];
|
|
break;
|
|
case GL_FOG_COLOR:
|
|
fParams[0] = __GL_I_TO_FLOAT(params[0]);
|
|
fParams[1] = __GL_I_TO_FLOAT(params[1]);
|
|
fParams[2] = __GL_I_TO_FLOAT(params[2]);
|
|
fParams[3] = __GL_I_TO_FLOAT(params[3]);
|
|
break;
|
|
}
|
|
|
|
__gllc_Fogfv(pname, fParams);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Light functions.
|
|
// Compile only Lightfv function.
|
|
// Convert the other functions to the compiled Lightfv function.
|
|
|
|
void APIENTRY
|
|
__gllc_Lightfv ( IN GLenum light, IN GLenum pname, IN const GLfloat params[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_Lightfv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = __glLightfv_size(pname) * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
size = sizeof(struct __gllc_Lightfv_Rec) + arraySize;
|
|
data = (struct __gllc_Lightfv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(Lightfv));
|
|
if (data == NULL) return;
|
|
data->light = light;
|
|
data->pname = pname;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_Lightfv_Rec),
|
|
params, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_Lightfv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Lightf ( IN GLenum light, IN GLenum pname, IN GLfloat param )
|
|
{
|
|
// LIGHT_SOURCE_ASSERT
|
|
|
|
if (!RANGE(pname,GL_SPOT_EXPONENT,GL_QUADRATIC_ATTENUATION))
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
__gllc_Lightfv(light, pname, ¶m);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Lighti ( IN GLenum light, IN GLenum pname, IN GLint param )
|
|
{
|
|
GLfloat fParam;
|
|
|
|
// LIGHT_SOURCE_ASSERT
|
|
|
|
if (!RANGE(pname,GL_SPOT_EXPONENT,GL_QUADRATIC_ATTENUATION))
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
fParam = (GLfloat) param;
|
|
__gllc_Lightfv(light, pname, &fParam);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Lightiv ( IN GLenum light, IN GLenum pname, IN const GLint params[] )
|
|
{
|
|
GLfloat fParams[4];
|
|
|
|
switch (pname)
|
|
{
|
|
case GL_AMBIENT:
|
|
case GL_DIFFUSE:
|
|
case GL_SPECULAR:
|
|
fParams[0] = __GL_I_TO_FLOAT(params[0]);
|
|
fParams[1] = __GL_I_TO_FLOAT(params[1]);
|
|
fParams[2] = __GL_I_TO_FLOAT(params[2]);
|
|
fParams[3] = __GL_I_TO_FLOAT(params[3]);
|
|
break;
|
|
case GL_POSITION:
|
|
fParams[3] = (GLfloat) params[3];
|
|
case GL_SPOT_DIRECTION:
|
|
fParams[2] = (GLfloat) params[2];
|
|
fParams[1] = (GLfloat) params[1];
|
|
case GL_SPOT_EXPONENT:
|
|
case GL_SPOT_CUTOFF:
|
|
case GL_CONSTANT_ATTENUATION:
|
|
case GL_LINEAR_ATTENUATION:
|
|
case GL_QUADRATIC_ATTENUATION:
|
|
fParams[0] = (GLfloat) params[0];
|
|
break;
|
|
}
|
|
|
|
__gllc_Lightfv(light, pname, fParams);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// LightModel functions.
|
|
// Compile only LightModelfv function.
|
|
// Convert the other functions to the compiled LightModelfv function.
|
|
|
|
void APIENTRY
|
|
__gllc_LightModelfv ( IN GLenum pname, IN const GLfloat params[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_LightModelfv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = __glLightModelfv_size(pname) * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
size = sizeof(struct __gllc_LightModelfv_Rec) + arraySize;
|
|
data = (struct __gllc_LightModelfv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(LightModelfv));
|
|
if (data == NULL) return;
|
|
data->pname = pname;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_LightModelfv_Rec),
|
|
params, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_LightModelfv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_LightModelf ( IN GLenum pname, IN GLfloat param )
|
|
{
|
|
// LIGHT_MODEL_ASSERT
|
|
|
|
if (!RANGE(pname,GL_LIGHT_MODEL_LOCAL_VIEWER,GL_LIGHT_MODEL_TWO_SIDE))
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
__gllc_LightModelfv(pname, ¶m);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_LightModeli ( IN GLenum pname, IN GLint param )
|
|
{
|
|
GLfloat fParam;
|
|
|
|
// LIGHT_MODEL_ASSERT
|
|
|
|
if (!RANGE(pname,GL_LIGHT_MODEL_LOCAL_VIEWER,GL_LIGHT_MODEL_TWO_SIDE))
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
fParam = (GLfloat) param;
|
|
__gllc_LightModelfv(pname, &fParam);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_LightModeliv ( IN GLenum pname, IN const GLint params[] )
|
|
{
|
|
GLfloat fParams[4];
|
|
|
|
switch (pname)
|
|
{
|
|
case GL_LIGHT_MODEL_AMBIENT:
|
|
fParams[0] = __GL_I_TO_FLOAT(params[0]);
|
|
fParams[1] = __GL_I_TO_FLOAT(params[1]);
|
|
fParams[2] = __GL_I_TO_FLOAT(params[2]);
|
|
fParams[3] = __GL_I_TO_FLOAT(params[3]);
|
|
break;
|
|
case GL_LIGHT_MODEL_LOCAL_VIEWER:
|
|
case GL_LIGHT_MODEL_TWO_SIDE:
|
|
fParams[0] = (GLfloat) params[0];
|
|
break;
|
|
}
|
|
|
|
__gllc_LightModelfv(pname, fParams);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Material functions.
|
|
// Compile only Materialfv function.
|
|
// Convert the other functions to the compiled Materialfv function.
|
|
|
|
void APIENTRY
|
|
__gllc_Materialfv ( IN GLenum face, IN GLenum pname, IN const GLfloat params[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
GLenum error;
|
|
struct __gllc_Materialfv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
#ifdef SGI
|
|
// Check this at playback time
|
|
error = __glErrorCheckMaterial(face, pname, params[0]);
|
|
if (error != GL_NO_ERROR) {
|
|
__gllc_Error(gc, error);
|
|
return;
|
|
}
|
|
#endif
|
|
arraySize = __glMaterialfv_size(pname) * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
// If we are compiling poly array primitive, update the poly data record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glMaterialfv)(face, pname, params);
|
|
return;
|
|
}
|
|
|
|
size = sizeof(struct __gllc_Materialfv_Rec) + arraySize;
|
|
data = (struct __gllc_Materialfv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(Materialfv));
|
|
if (data == NULL) return;
|
|
data->face = face;
|
|
data->pname = pname;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_Materialfv_Rec),
|
|
params, arraySize);
|
|
#ifndef NT
|
|
gc->dlist.listData.genericFlags |= __GL_DLFLAG_HAS_MATERIAL;
|
|
#endif
|
|
__glDlistAppendOp(gc, data, __glle_Materialfv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Materialf ( IN GLenum face, IN GLenum pname, IN GLfloat param )
|
|
{
|
|
if (pname != GL_SHININESS)
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
__gllc_Materialfv(face, pname, ¶m);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Materiali ( IN GLenum face, IN GLenum pname, IN GLint param )
|
|
{
|
|
GLfloat fParams[1];
|
|
|
|
if (pname != GL_SHININESS)
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
fParams[0] = (GLfloat) param;
|
|
__gllc_Materialfv(face, pname, fParams);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Materialiv ( IN GLenum face, IN GLenum pname, IN const GLint params[] )
|
|
{
|
|
GLfloat fParams[4];
|
|
|
|
switch (pname)
|
|
{
|
|
case GL_EMISSION:
|
|
case GL_AMBIENT:
|
|
case GL_DIFFUSE:
|
|
case GL_SPECULAR:
|
|
case GL_AMBIENT_AND_DIFFUSE:
|
|
fParams[0] = __GL_I_TO_FLOAT(params[0]);
|
|
fParams[1] = __GL_I_TO_FLOAT(params[1]);
|
|
fParams[2] = __GL_I_TO_FLOAT(params[2]);
|
|
fParams[3] = __GL_I_TO_FLOAT(params[3]);
|
|
break;
|
|
case GL_COLOR_INDEXES:
|
|
fParams[2] = (GLfloat) params[2];
|
|
fParams[1] = (GLfloat) params[1];
|
|
case GL_SHININESS:
|
|
fParams[0] = (GLfloat) params[0];
|
|
break;
|
|
}
|
|
|
|
__gllc_Materialfv(face, pname, fParams);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// TexParameter functions.
|
|
// Compile only TexParameterfv and TexParameteriv functions.
|
|
// Convert the other functions to one of the compiled TexParameter functions.
|
|
|
|
void APIENTRY
|
|
__gllc_TexParameterfv ( IN GLenum target, IN GLenum pname, IN const GLfloat params[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_TexParameterfv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = __glTexParameterfv_size(pname) * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
size = sizeof(struct __gllc_TexParameterfv_Rec) + arraySize;
|
|
data = (struct __gllc_TexParameterfv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(TexParameterfv));
|
|
if (data == NULL) return;
|
|
data->target = target;
|
|
data->pname = pname;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_TexParameterfv_Rec),
|
|
params, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_TexParameterfv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexParameterf ( IN GLenum target, IN GLenum pname, IN GLfloat param )
|
|
{
|
|
// TEX_PARAMETER_ASSERT
|
|
|
|
if (!RANGE(pname,GL_TEXTURE_MAG_FILTER,GL_TEXTURE_WRAP_T) &&
|
|
pname != GL_TEXTURE_PRIORITY)
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
__gllc_TexParameterfv(target, pname, ¶m);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexParameteriv ( IN GLenum target, IN GLenum pname, IN const GLint params[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_TexParameteriv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = __glTexParameteriv_size(pname) * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
size = sizeof(struct __gllc_TexParameteriv_Rec) + arraySize;
|
|
data = (struct __gllc_TexParameteriv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(TexParameteriv));
|
|
if (data == NULL) return;
|
|
data->target = target;
|
|
data->pname = pname;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_TexParameteriv_Rec),
|
|
params, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_TexParameteriv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexParameteri ( IN GLenum target, IN GLenum pname, IN GLint param )
|
|
{
|
|
// TEX_PARAMETER_ASSERT
|
|
|
|
if (!RANGE(pname,GL_TEXTURE_MAG_FILTER,GL_TEXTURE_WRAP_T) &&
|
|
pname != GL_TEXTURE_PRIORITY)
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
__gllc_TexParameteriv(target, pname, ¶m);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// TexEnv functions.
|
|
// Compile only TexEnvfv and TexEnviv functions.
|
|
// Convert the other functions to one of the compiled TexEnv functions.
|
|
|
|
void APIENTRY
|
|
__gllc_TexEnvfv ( IN GLenum target, IN GLenum pname, IN const GLfloat params[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_TexEnvfv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = __glTexEnvfv_size(pname) * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
size = sizeof(struct __gllc_TexEnvfv_Rec) + arraySize;
|
|
data = (struct __gllc_TexEnvfv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(TexEnvfv));
|
|
if (data == NULL) return;
|
|
data->target = target;
|
|
data->pname = pname;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_TexEnvfv_Rec),
|
|
params, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_TexEnvfv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexEnvf ( IN GLenum target, IN GLenum pname, IN GLfloat param )
|
|
{
|
|
if (pname != GL_TEXTURE_ENV_MODE)
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
__gllc_TexEnvfv(target, pname, ¶m);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexEnviv ( IN GLenum target, IN GLenum pname, IN const GLint params[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_TexEnviv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = __glTexEnviv_size(pname) * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
size = sizeof(struct __gllc_TexEnviv_Rec) + arraySize;
|
|
data = (struct __gllc_TexEnviv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(TexEnviv));
|
|
if (data == NULL) return;
|
|
data->target = target;
|
|
data->pname = pname;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_TexEnviv_Rec),
|
|
params, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_TexEnviv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexEnvi ( IN GLenum target, IN GLenum pname, IN GLint param )
|
|
{
|
|
if (pname != GL_TEXTURE_ENV_MODE)
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
__gllc_TexEnviv(target, pname, ¶m);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// TexGen functions.
|
|
// Compile only TexGenfv function.
|
|
// Convert the other functions to the compiled TexGenfv function.
|
|
|
|
void APIENTRY
|
|
__gllc_TexGenfv ( IN GLenum coord, IN GLenum pname, IN const GLfloat params[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_TexGenfv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = __glTexGenfv_size(pname) * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
size = sizeof(struct __gllc_TexGenfv_Rec) + arraySize;
|
|
data = (struct __gllc_TexGenfv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(TexGenfv));
|
|
if (data == NULL) return;
|
|
data->coord = coord;
|
|
data->pname = pname;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_TexGenfv_Rec),
|
|
params, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_TexGenfv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexGend ( IN GLenum coord, IN GLenum pname, IN GLdouble param )
|
|
{
|
|
GLfloat fParam;
|
|
|
|
if (pname != GL_TEXTURE_GEN_MODE)
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
fParam = (GLfloat) param;
|
|
__gllc_TexGenfv(coord, pname, &fParam);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexGendv ( IN GLenum coord, IN GLenum pname, IN const GLdouble params[] )
|
|
{
|
|
GLfloat fParams[4];
|
|
|
|
switch (pname)
|
|
{
|
|
case GL_OBJECT_PLANE:
|
|
case GL_EYE_PLANE:
|
|
fParams[3] = (GLfloat) params[3];
|
|
fParams[2] = (GLfloat) params[2];
|
|
fParams[1] = (GLfloat) params[1];
|
|
// fall through
|
|
case GL_TEXTURE_GEN_MODE:
|
|
fParams[0] = (GLfloat) params[0];
|
|
break;
|
|
}
|
|
|
|
__gllc_TexGenfv(coord, pname, fParams);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexGenf ( IN GLenum coord, IN GLenum pname, IN GLfloat param )
|
|
{
|
|
if (pname != GL_TEXTURE_GEN_MODE)
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
__gllc_TexGenfv(coord, pname, ¶m);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexGeni ( IN GLenum coord, IN GLenum pname, IN GLint param )
|
|
{
|
|
GLfloat fParam;
|
|
|
|
if (pname != GL_TEXTURE_GEN_MODE)
|
|
{
|
|
__gllc_InvalidEnum();
|
|
return;
|
|
}
|
|
|
|
fParam = (GLfloat) param;
|
|
__gllc_TexGenfv(coord, pname, &fParam);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_TexGeniv ( IN GLenum coord, IN GLenum pname, IN const GLint params[] )
|
|
{
|
|
GLfloat fParams[4];
|
|
|
|
switch (pname)
|
|
{
|
|
case GL_OBJECT_PLANE:
|
|
case GL_EYE_PLANE:
|
|
fParams[3] = (GLfloat) params[3];
|
|
fParams[2] = (GLfloat) params[2];
|
|
fParams[1] = (GLfloat) params[1];
|
|
// fall through
|
|
case GL_TEXTURE_GEN_MODE:
|
|
fParams[0] = (GLfloat) params[0];
|
|
break;
|
|
}
|
|
|
|
__gllc_TexGenfv(coord, pname, fParams);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// MapGrid functions.
|
|
// Compile only MapGrid1f and MapGrid2f functions.
|
|
// Convert the other functions to one of the compiled MapGrid functions.
|
|
|
|
void APIENTRY
|
|
__gllc_MapGrid1f ( IN GLint un, IN GLfloat u1, IN GLfloat u2 )
|
|
{
|
|
struct __gllc_MapGrid1f_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_MapGrid1f_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_MapGrid1f_Rec)),
|
|
DLIST_GENERIC_OP(MapGrid1f));
|
|
if (data == NULL) return;
|
|
data->un = un;
|
|
data->u1 = u1;
|
|
data->u2 = u2;
|
|
__glDlistAppendOp(gc, data, __glle_MapGrid1f);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_MapGrid1d ( IN GLint un, IN GLdouble u1, IN GLdouble u2 )
|
|
{
|
|
__gllc_MapGrid1f(un, (GLfloat) u1, (GLfloat) u2);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_MapGrid2f ( IN GLint un, IN GLfloat u1, IN GLfloat u2, IN GLint vn, IN GLfloat v1, IN GLfloat v2 )
|
|
{
|
|
struct __gllc_MapGrid2f_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_MapGrid2f_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_MapGrid2f_Rec)),
|
|
DLIST_GENERIC_OP(MapGrid2f));
|
|
if (data == NULL) return;
|
|
data->un = un;
|
|
data->u1 = u1;
|
|
data->u2 = u2;
|
|
data->vn = vn;
|
|
data->v1 = v1;
|
|
data->v2 = v2;
|
|
__glDlistAppendOp(gc, data, __glle_MapGrid2f);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_MapGrid2d ( IN GLint un, IN GLdouble u1, IN GLdouble u2, IN GLint vn, IN GLdouble v1, IN GLdouble v2 )
|
|
{
|
|
__gllc_MapGrid2f(un, (GLfloat) u1, (GLfloat) u2, vn, (GLfloat) v1, (GLfloat) v2);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// EvalCoord functions.
|
|
// Compile only EvalCoord1f and EvalCoord2f functions.
|
|
// Convert the other functions to one of the compiled EvalCoord functions.
|
|
|
|
void APIENTRY
|
|
__gllc_EvalCoord1f ( IN GLfloat u )
|
|
{
|
|
struct __gllc_EvalCoord1f_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update and record the poly data
|
|
// record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
POLYARRAY *pa;
|
|
|
|
pa = gc->paTeb;
|
|
|
|
// If we are in COMPILE_AND_EXECUTE mode or there are attribute
|
|
// changes associated with the vertex, process the poly data.
|
|
if (gc->dlist.mode == GL_COMPILE_AND_EXECUTE
|
|
|| pa->pdNextVertex->flags)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glEvalCoord1f)(u);
|
|
__glDlistCompilePolyData(gc, GL_FALSE);
|
|
return;
|
|
}
|
|
|
|
// Otherwise, increment vertex count and compile a EvalCoord record
|
|
// instead.
|
|
gc->dlist.beginRec->nVertices++;
|
|
}
|
|
|
|
data = (struct __gllc_EvalCoord1f_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_EvalCoord1f_Rec)),
|
|
DLIST_GENERIC_OP(EvalCoord1f));
|
|
if (data == NULL) return;
|
|
data->u = u;
|
|
__glDlistAppendOp(gc, data, __glle_EvalCoord1f);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalCoord1d ( IN GLdouble u )
|
|
{
|
|
__gllc_EvalCoord1f((GLfloat) u);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalCoord1dv ( IN const GLdouble u[1] )
|
|
{
|
|
__gllc_EvalCoord1f((GLfloat) u[0]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalCoord1fv ( IN const GLfloat u[1] )
|
|
{
|
|
__gllc_EvalCoord1f((GLfloat) u[0]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalCoord2f ( IN GLfloat u, IN GLfloat v )
|
|
{
|
|
struct __gllc_EvalCoord2f_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update and record the poly data
|
|
// record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
POLYARRAY *pa;
|
|
|
|
pa = gc->paTeb;
|
|
|
|
// If we are in COMPILE_AND_EXECUTE mode or there are attribute
|
|
// changes associated with the vertex, process the poly data.
|
|
if (gc->dlist.mode == GL_COMPILE_AND_EXECUTE
|
|
|| pa->pdNextVertex->flags)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glEvalCoord2f)(u, v);
|
|
__glDlistCompilePolyData(gc, GL_FALSE);
|
|
return;
|
|
}
|
|
|
|
// Otherwise, increment vertex count and compile a EvalCoord record
|
|
// instead.
|
|
gc->dlist.beginRec->nVertices++;
|
|
}
|
|
|
|
data = (struct __gllc_EvalCoord2f_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_EvalCoord2f_Rec)),
|
|
DLIST_GENERIC_OP(EvalCoord2f));
|
|
if (data == NULL) return;
|
|
data->u = u;
|
|
data->v = v;
|
|
__glDlistAppendOp(gc, data, __glle_EvalCoord2f);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalCoord2d ( IN GLdouble u, IN GLdouble v )
|
|
{
|
|
__gllc_EvalCoord2f((GLfloat) u, (GLfloat) v);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalCoord2dv ( IN const GLdouble u[2] )
|
|
{
|
|
__gllc_EvalCoord2f((GLfloat) u[0], (GLfloat) u[1]);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalCoord2fv ( IN const GLfloat u[2] )
|
|
{
|
|
__gllc_EvalCoord2f((GLfloat) u[0], (GLfloat) u[1]);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// LoadMatrix functions.
|
|
// Compile only LoadMatrixf function.
|
|
// Convert the other functions to the compiled LoadMatrixf function.
|
|
|
|
void APIENTRY
|
|
__gllc_LoadMatrixf ( IN const GLfloat m[16] )
|
|
{
|
|
struct __gllc_LoadMatrixf_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_LoadMatrixf_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_LoadMatrixf_Rec)),
|
|
DLIST_GENERIC_OP(LoadMatrixf));
|
|
if (data == NULL) return;
|
|
__GL_MEMCOPY(data->m, m, sizeof(data->m));
|
|
__glDlistAppendOp(gc, data, __glle_LoadMatrixf);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_LoadMatrixd ( IN const GLdouble m[16] )
|
|
{
|
|
GLfloat fm[16];
|
|
|
|
fm[ 0] = (GLfloat) m[ 0];
|
|
fm[ 1] = (GLfloat) m[ 1];
|
|
fm[ 2] = (GLfloat) m[ 2];
|
|
fm[ 3] = (GLfloat) m[ 3];
|
|
fm[ 4] = (GLfloat) m[ 4];
|
|
fm[ 5] = (GLfloat) m[ 5];
|
|
fm[ 6] = (GLfloat) m[ 6];
|
|
fm[ 7] = (GLfloat) m[ 7];
|
|
fm[ 8] = (GLfloat) m[ 8];
|
|
fm[ 9] = (GLfloat) m[ 9];
|
|
fm[10] = (GLfloat) m[10];
|
|
fm[11] = (GLfloat) m[11];
|
|
fm[12] = (GLfloat) m[12];
|
|
fm[13] = (GLfloat) m[13];
|
|
fm[14] = (GLfloat) m[14];
|
|
fm[15] = (GLfloat) m[15];
|
|
|
|
__gllc_LoadMatrixf(fm);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// MultMatrix functions.
|
|
// Compile only MultMatrixf function.
|
|
// Convert the other functions to the compiled MultMatrixf function.
|
|
|
|
void APIENTRY
|
|
__gllc_MultMatrixf ( IN const GLfloat m[16] )
|
|
{
|
|
struct __gllc_MultMatrixf_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_MultMatrixf_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_MultMatrixf_Rec)),
|
|
DLIST_GENERIC_OP(MultMatrixf));
|
|
if (data == NULL) return;
|
|
__GL_MEMCOPY(data->m, m, sizeof(data->m));
|
|
__glDlistAppendOp(gc, data, __glle_MultMatrixf);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_MultMatrixd ( IN const GLdouble m[16] )
|
|
{
|
|
GLfloat fm[16];
|
|
|
|
fm[ 0] = (GLfloat) m[ 0];
|
|
fm[ 1] = (GLfloat) m[ 1];
|
|
fm[ 2] = (GLfloat) m[ 2];
|
|
fm[ 3] = (GLfloat) m[ 3];
|
|
fm[ 4] = (GLfloat) m[ 4];
|
|
fm[ 5] = (GLfloat) m[ 5];
|
|
fm[ 6] = (GLfloat) m[ 6];
|
|
fm[ 7] = (GLfloat) m[ 7];
|
|
fm[ 8] = (GLfloat) m[ 8];
|
|
fm[ 9] = (GLfloat) m[ 9];
|
|
fm[10] = (GLfloat) m[10];
|
|
fm[11] = (GLfloat) m[11];
|
|
fm[12] = (GLfloat) m[12];
|
|
fm[13] = (GLfloat) m[13];
|
|
fm[14] = (GLfloat) m[14];
|
|
fm[15] = (GLfloat) m[15];
|
|
|
|
__gllc_MultMatrixf(fm);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Rotate functions.
|
|
// Compile only Rotatef function.
|
|
// Convert the other functions to the compiled Rotatef function.
|
|
|
|
void APIENTRY
|
|
__gllc_Rotatef ( IN GLfloat angle, IN GLfloat x, IN GLfloat y, IN GLfloat z )
|
|
{
|
|
struct __gllc_Rotatef_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Rotatef_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Rotatef_Rec)),
|
|
DLIST_GENERIC_OP(Rotatef));
|
|
if (data == NULL) return;
|
|
data->angle = angle;
|
|
data->x = x;
|
|
data->y = y;
|
|
data->z = z;
|
|
__glDlistAppendOp(gc, data, __glle_Rotatef);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Rotated ( IN GLdouble angle, IN GLdouble x, IN GLdouble y, IN GLdouble z )
|
|
{
|
|
__gllc_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Scale functions.
|
|
// Compile only Scalef function.
|
|
// Convert the other functions to the compiled Scalef function.
|
|
|
|
void APIENTRY
|
|
__gllc_Scalef ( IN GLfloat x, IN GLfloat y, IN GLfloat z )
|
|
{
|
|
struct __gllc_Scalef_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Scalef_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Scalef_Rec)),
|
|
DLIST_GENERIC_OP(Scalef));
|
|
if (data == NULL) return;
|
|
data->x = x;
|
|
data->y = y;
|
|
data->z = z;
|
|
__glDlistAppendOp(gc, data, __glle_Scalef);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Scaled ( IN GLdouble x, IN GLdouble y, IN GLdouble z )
|
|
{
|
|
__gllc_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Translate functions.
|
|
// Compile only Translatef function.
|
|
// Convert the other functions to the compiled Translatef function.
|
|
|
|
void APIENTRY
|
|
__gllc_Translatef ( IN GLfloat x, IN GLfloat y, IN GLfloat z )
|
|
{
|
|
struct __gllc_Translatef_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Translatef_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Translatef_Rec)),
|
|
DLIST_GENERIC_OP(Translatef));
|
|
if (data == NULL) return;
|
|
data->x = x;
|
|
data->y = y;
|
|
data->z = z;
|
|
__glDlistAppendOp(gc, data, __glle_Translatef);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Translated ( IN GLdouble x, IN GLdouble y, IN GLdouble z )
|
|
{
|
|
__gllc_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Other functions.
|
|
|
|
void APIENTRY
|
|
__gllc_ListBase ( IN GLuint base )
|
|
{
|
|
struct __gllc_ListBase_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ListBase_Rec *)
|
|
__glDlistAddOpUnaligned(gc,
|
|
DLIST_SIZE(sizeof(struct __gllc_ListBase_Rec)),
|
|
DLIST_GENERIC_OP(ListBase));
|
|
if (data == NULL) return;
|
|
data->base = base;
|
|
__glDlistAppendOp(gc, data, __glle_ListBase);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_ClipPlane ( IN GLenum plane, IN const GLdouble equation[4] )
|
|
{
|
|
struct __gllc_ClipPlane_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ClipPlane_Rec *)
|
|
__glDlistAddOpAligned(gc, DLIST_SIZE(sizeof(struct __gllc_ClipPlane_Rec)),
|
|
DLIST_GENERIC_OP(ClipPlane));
|
|
if (data == NULL) return;
|
|
data->plane = plane;
|
|
data->equation[0] = equation[0];
|
|
data->equation[1] = equation[1];
|
|
data->equation[2] = equation[2];
|
|
data->equation[3] = equation[3];
|
|
__glDlistAppendOp(gc, data, __glle_ClipPlane);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_ColorMaterial ( IN GLenum face, IN GLenum mode )
|
|
{
|
|
struct __gllc_ColorMaterial_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ColorMaterial_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_ColorMaterial_Rec)),
|
|
DLIST_GENERIC_OP(ColorMaterial));
|
|
if (data == NULL) return;
|
|
data->face = face;
|
|
data->mode = mode;
|
|
__glDlistAppendOp(gc, data, __glle_ColorMaterial);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_CullFace ( IN GLenum mode )
|
|
{
|
|
struct __gllc_CullFace_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_CullFace_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_CullFace_Rec)),
|
|
DLIST_GENERIC_OP(CullFace));
|
|
if (data == NULL) return;
|
|
data->mode = mode;
|
|
__glDlistAppendOp(gc, data, __glle_CullFace);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_FrontFace ( IN GLenum mode )
|
|
{
|
|
struct __gllc_FrontFace_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_FrontFace_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_FrontFace_Rec)),
|
|
DLIST_GENERIC_OP(FrontFace));
|
|
if (data == NULL) return;
|
|
data->mode = mode;
|
|
__glDlistAppendOp(gc, data, __glle_FrontFace);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Hint ( IN GLenum target, IN GLenum mode )
|
|
{
|
|
struct __gllc_Hint_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Hint_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Hint_Rec)),
|
|
DLIST_GENERIC_OP(Hint));
|
|
if (data == NULL) return;
|
|
data->target = target;
|
|
data->mode = mode;
|
|
__glDlistAppendOp(gc, data, __glle_Hint);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_LineStipple ( IN GLint factor, IN GLushort pattern )
|
|
{
|
|
struct __gllc_LineStipple_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_LineStipple_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_LineStipple_Rec)),
|
|
DLIST_GENERIC_OP(LineStipple));
|
|
if (data == NULL) return;
|
|
data->factor = factor;
|
|
data->pattern = pattern;
|
|
__glDlistAppendOp(gc, data, __glle_LineStipple);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_LineWidth ( IN GLfloat width )
|
|
{
|
|
struct __gllc_LineWidth_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_LineWidth_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_LineWidth_Rec)),
|
|
DLIST_GENERIC_OP(LineWidth));
|
|
if (data == NULL) return;
|
|
data->width = width;
|
|
__glDlistAppendOp(gc, data, __glle_LineWidth);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PointSize ( IN GLfloat size )
|
|
{
|
|
struct __gllc_PointSize_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_PointSize_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_PointSize_Rec)),
|
|
DLIST_GENERIC_OP(PointSize));
|
|
if (data == NULL) return;
|
|
data->size = size;
|
|
__glDlistAppendOp(gc, data, __glle_PointSize);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PolygonMode ( IN GLenum face, IN GLenum mode )
|
|
{
|
|
struct __gllc_PolygonMode_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_PolygonMode_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_PolygonMode_Rec)),
|
|
DLIST_GENERIC_OP(PolygonMode));
|
|
if (data == NULL) return;
|
|
data->face = face;
|
|
data->mode = mode;
|
|
__glDlistAppendOp(gc, data, __glle_PolygonMode);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Scissor ( IN GLint x, IN GLint y, IN GLsizei width, IN GLsizei height )
|
|
{
|
|
struct __gllc_Scissor_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Scissor_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Scissor_Rec)),
|
|
DLIST_GENERIC_OP(Scissor));
|
|
if (data == NULL) return;
|
|
data->x = x;
|
|
data->y = y;
|
|
data->width = width;
|
|
data->height = height;
|
|
__glDlistAppendOp(gc, data, __glle_Scissor);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_ShadeModel ( IN GLenum mode )
|
|
{
|
|
struct __gllc_ShadeModel_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ShadeModel_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_ShadeModel_Rec)),
|
|
DLIST_GENERIC_OP(ShadeModel));
|
|
if (data == NULL) return;
|
|
data->mode = mode;
|
|
__glDlistAppendOp(gc, data, __glle_ShadeModel);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_InitNames ( void )
|
|
{
|
|
void *data;
|
|
__GL_SETUP();
|
|
|
|
data = __glDlistAddOpUnaligned(gc, DLIST_SIZE(0), DLIST_GENERIC_OP(InitNames));
|
|
if (data == NULL) return;
|
|
__glDlistAppendOp(gc, data, __glle_InitNames);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_LoadName ( IN GLuint name )
|
|
{
|
|
struct __gllc_LoadName_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_LoadName_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_LoadName_Rec)),
|
|
DLIST_GENERIC_OP(LoadName));
|
|
if (data == NULL) return;
|
|
data->name = name;
|
|
__glDlistAppendOp(gc, data, __glle_LoadName);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PassThrough ( IN GLfloat token )
|
|
{
|
|
struct __gllc_PassThrough_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_PassThrough_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_PassThrough_Rec)),
|
|
DLIST_GENERIC_OP(PassThrough));
|
|
if (data == NULL) return;
|
|
data->token = token;
|
|
__glDlistAppendOp(gc, data, __glle_PassThrough);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PopName ( void )
|
|
{
|
|
void *data;
|
|
__GL_SETUP();
|
|
|
|
data = __glDlistAddOpUnaligned(gc, DLIST_SIZE(0), DLIST_GENERIC_OP(PopName));
|
|
if (data == NULL) return;
|
|
__glDlistAppendOp(gc, data, __glle_PopName);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PushName ( IN GLuint name )
|
|
{
|
|
struct __gllc_PushName_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_PushName_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_PushName_Rec)),
|
|
DLIST_GENERIC_OP(PushName));
|
|
if (data == NULL) return;
|
|
data->name = name;
|
|
__glDlistAppendOp(gc, data, __glle_PushName);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_DrawBuffer ( IN GLenum mode )
|
|
{
|
|
struct __gllc_DrawBuffer_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_DrawBuffer_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_DrawBuffer_Rec)),
|
|
DLIST_GENERIC_OP(DrawBuffer));
|
|
if (data == NULL) return;
|
|
data->mode = mode;
|
|
__glDlistAppendOp(gc, data, __glle_DrawBuffer);
|
|
#if 0
|
|
#ifdef NT
|
|
gc->dlist.drawBuffer = GL_TRUE;
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Clear ( IN GLbitfield mask )
|
|
{
|
|
struct __gllc_Clear_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Clear_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Clear_Rec)),
|
|
DLIST_GENERIC_OP(Clear));
|
|
if (data == NULL) return;
|
|
data->mask = mask;
|
|
__glDlistAppendOp(gc, data, __glle_Clear);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_ClearAccum ( IN GLfloat red, IN GLfloat green, IN GLfloat blue, IN GLfloat alpha )
|
|
{
|
|
struct __gllc_ClearAccum_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ClearAccum_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_ClearAccum_Rec)),
|
|
DLIST_GENERIC_OP(ClearAccum));
|
|
if (data == NULL) return;
|
|
data->red = red;
|
|
data->green = green;
|
|
data->blue = blue;
|
|
data->alpha = alpha;
|
|
__glDlistAppendOp(gc, data, __glle_ClearAccum);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_ClearIndex ( IN GLfloat c )
|
|
{
|
|
struct __gllc_ClearIndex_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ClearIndex_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_ClearIndex_Rec)),
|
|
DLIST_GENERIC_OP(ClearIndex));
|
|
if (data == NULL) return;
|
|
data->c = c;
|
|
__glDlistAppendOp(gc, data, __glle_ClearIndex);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_ClearColor ( IN GLclampf red, IN GLclampf green, IN GLclampf blue, IN GLclampf alpha )
|
|
{
|
|
struct __gllc_ClearColor_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ClearColor_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_ClearColor_Rec)),
|
|
DLIST_GENERIC_OP(ClearColor));
|
|
if (data == NULL) return;
|
|
data->red = red;
|
|
data->green = green;
|
|
data->blue = blue;
|
|
data->alpha = alpha;
|
|
__glDlistAppendOp(gc, data, __glle_ClearColor);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_ClearStencil ( IN GLint s )
|
|
{
|
|
struct __gllc_ClearStencil_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ClearStencil_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_ClearStencil_Rec)),
|
|
DLIST_GENERIC_OP(ClearStencil));
|
|
if (data == NULL) return;
|
|
data->s = s;
|
|
__glDlistAppendOp(gc, data, __glle_ClearStencil);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_ClearDepth ( IN GLclampd depth )
|
|
{
|
|
struct __gllc_ClearDepth_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ClearDepth_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_ClearDepth_Rec)),
|
|
DLIST_GENERIC_OP(ClearDepth));
|
|
if (data == NULL) return;
|
|
data->depth = depth;
|
|
__glDlistAppendOp(gc, data, __glle_ClearDepth);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_StencilMask ( IN GLuint mask )
|
|
{
|
|
struct __gllc_StencilMask_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_StencilMask_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_StencilMask_Rec)),
|
|
DLIST_GENERIC_OP(StencilMask));
|
|
if (data == NULL) return;
|
|
data->mask = mask;
|
|
__glDlistAppendOp(gc, data, __glle_StencilMask);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_ColorMask ( IN GLboolean red, IN GLboolean green, IN GLboolean blue, IN GLboolean alpha )
|
|
{
|
|
struct __gllc_ColorMask_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ColorMask_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_ColorMask_Rec)),
|
|
DLIST_GENERIC_OP(ColorMask));
|
|
if (data == NULL) return;
|
|
data->red = red;
|
|
data->green = green;
|
|
data->blue = blue;
|
|
data->alpha = alpha;
|
|
__glDlistAppendOp(gc, data, __glle_ColorMask);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_DepthMask ( IN GLboolean flag )
|
|
{
|
|
struct __gllc_DepthMask_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_DepthMask_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_DepthMask_Rec)),
|
|
DLIST_GENERIC_OP(DepthMask));
|
|
if (data == NULL) return;
|
|
data->flag = flag;
|
|
__glDlistAppendOp(gc, data, __glle_DepthMask);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_IndexMask ( IN GLuint mask )
|
|
{
|
|
struct __gllc_IndexMask_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_IndexMask_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_IndexMask_Rec)),
|
|
DLIST_GENERIC_OP(IndexMask));
|
|
if (data == NULL) return;
|
|
data->mask = mask;
|
|
__glDlistAppendOp(gc, data, __glle_IndexMask);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Accum ( IN GLenum op, IN GLfloat value )
|
|
{
|
|
struct __gllc_Accum_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Accum_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Accum_Rec)),
|
|
DLIST_GENERIC_OP(Accum));
|
|
if (data == NULL) return;
|
|
data->op = op;
|
|
data->value = value;
|
|
__glDlistAppendOp(gc, data, __glle_Accum);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Disable ( IN GLenum cap )
|
|
{
|
|
struct __gllc_Disable_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Disable_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Disable_Rec)),
|
|
DLIST_GENERIC_OP(Disable));
|
|
if (data == NULL) return;
|
|
data->cap = cap;
|
|
__glDlistAppendOp(gc, data, __glle_Disable);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Enable ( IN GLenum cap )
|
|
{
|
|
struct __gllc_Enable_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Enable_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Enable_Rec)),
|
|
DLIST_GENERIC_OP(Enable));
|
|
if (data == NULL) return;
|
|
data->cap = cap;
|
|
__glDlistAppendOp(gc, data, __glle_Enable);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PopAttrib ( void )
|
|
{
|
|
void *data;
|
|
__GL_SETUP();
|
|
|
|
data = __glDlistAddOpUnaligned(gc, DLIST_SIZE(0), DLIST_GENERIC_OP(PopAttrib));
|
|
if (data == NULL) return;
|
|
__glDlistAppendOp(gc, data, __glle_PopAttrib);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PushAttrib ( IN GLbitfield mask )
|
|
{
|
|
struct __gllc_PushAttrib_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_PushAttrib_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_PushAttrib_Rec)),
|
|
DLIST_GENERIC_OP(PushAttrib));
|
|
if (data == NULL) return;
|
|
data->mask = mask;
|
|
__glDlistAppendOp(gc, data, __glle_PushAttrib);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalMesh1 ( IN GLenum mode, IN GLint i1, IN GLint i2 )
|
|
{
|
|
struct __gllc_EvalMesh1_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_EvalMesh1_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_EvalMesh1_Rec)),
|
|
DLIST_GENERIC_OP(EvalMesh1));
|
|
if (data == NULL) return;
|
|
data->mode = mode;
|
|
data->i1 = i1;
|
|
data->i2 = i2;
|
|
__glDlistAppendOp(gc, data, __glle_EvalMesh1);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalPoint1 ( IN GLint i )
|
|
{
|
|
struct __gllc_EvalPoint1_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update and record the poly data
|
|
// record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
POLYARRAY *pa;
|
|
|
|
pa = gc->paTeb;
|
|
|
|
// If we are in COMPILE_AND_EXECUTE mode or there are attribute
|
|
// changes associated with the vertex, process the poly data.
|
|
if (gc->dlist.mode == GL_COMPILE_AND_EXECUTE
|
|
|| pa->pdNextVertex->flags)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glEvalPoint1)(i);
|
|
__glDlistCompilePolyData(gc, GL_FALSE);
|
|
return;
|
|
}
|
|
|
|
// Otherwise, increment vertex count and compile a EvalPoint record
|
|
// instead.
|
|
gc->dlist.beginRec->nVertices++;
|
|
}
|
|
|
|
data = (struct __gllc_EvalPoint1_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_EvalPoint1_Rec)),
|
|
DLIST_GENERIC_OP(EvalPoint1));
|
|
if (data == NULL) return;
|
|
data->i = i;
|
|
__glDlistAppendOp(gc, data, __glle_EvalPoint1);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalMesh2 ( IN GLenum mode, IN GLint i1, IN GLint i2, IN GLint j1, IN GLint j2 )
|
|
{
|
|
struct __gllc_EvalMesh2_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_EvalMesh2_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_EvalMesh2_Rec)),
|
|
DLIST_GENERIC_OP(EvalMesh2));
|
|
if (data == NULL) return;
|
|
data->mode = mode;
|
|
data->i1 = i1;
|
|
data->i2 = i2;
|
|
data->j1 = j1;
|
|
data->j2 = j2;
|
|
__glDlistAppendOp(gc, data, __glle_EvalMesh2);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_EvalPoint2 ( IN GLint i, IN GLint j )
|
|
{
|
|
struct __gllc_EvalPoint2_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
// If we are compiling poly array primitive, update and record the poly data
|
|
// record.
|
|
|
|
if (gc->dlist.beginRec)
|
|
{
|
|
POLYARRAY *pa;
|
|
|
|
pa = gc->paTeb;
|
|
|
|
// If we are in COMPILE_AND_EXECUTE mode or there are attribute
|
|
// changes associated with the vertex, process the poly data.
|
|
if (gc->dlist.mode == GL_COMPILE_AND_EXECUTE
|
|
|| pa->pdNextVertex->flags)
|
|
{
|
|
(*gc->savedCltProcTable.glDispatchTable.glEvalPoint2)(i, j);
|
|
__glDlistCompilePolyData(gc, GL_FALSE);
|
|
return;
|
|
}
|
|
|
|
// Otherwise, increment vertex count and compile a EvalPoint record
|
|
// instead.
|
|
gc->dlist.beginRec->nVertices++;
|
|
}
|
|
|
|
data = (struct __gllc_EvalPoint2_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_EvalPoint2_Rec)),
|
|
DLIST_GENERIC_OP(EvalPoint2));
|
|
if (data == NULL) return;
|
|
data->i = i;
|
|
data->j = j;
|
|
__glDlistAppendOp(gc, data, __glle_EvalPoint2);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_AlphaFunc ( IN GLenum func, IN GLclampf ref )
|
|
{
|
|
struct __gllc_AlphaFunc_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_AlphaFunc_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_AlphaFunc_Rec)),
|
|
DLIST_GENERIC_OP(AlphaFunc));
|
|
if (data == NULL) return;
|
|
data->func = func;
|
|
data->ref = ref;
|
|
__glDlistAppendOp(gc, data, __glle_AlphaFunc);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_BlendFunc ( IN GLenum sfactor, IN GLenum dfactor )
|
|
{
|
|
struct __gllc_BlendFunc_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_BlendFunc_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_BlendFunc_Rec)),
|
|
DLIST_GENERIC_OP(BlendFunc));
|
|
if (data == NULL) return;
|
|
data->sfactor = sfactor;
|
|
data->dfactor = dfactor;
|
|
__glDlistAppendOp(gc, data, __glle_BlendFunc);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_LogicOp ( IN GLenum opcode )
|
|
{
|
|
struct __gllc_LogicOp_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_LogicOp_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_LogicOp_Rec)),
|
|
DLIST_GENERIC_OP(LogicOp));
|
|
if (data == NULL) return;
|
|
data->opcode = opcode;
|
|
__glDlistAppendOp(gc, data, __glle_LogicOp);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_StencilFunc ( IN GLenum func, IN GLint ref, IN GLuint mask )
|
|
{
|
|
struct __gllc_StencilFunc_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_StencilFunc_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_StencilFunc_Rec)),
|
|
DLIST_GENERIC_OP(StencilFunc));
|
|
if (data == NULL) return;
|
|
data->func = func;
|
|
data->ref = ref;
|
|
data->mask = mask;
|
|
__glDlistAppendOp(gc, data, __glle_StencilFunc);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_StencilOp ( IN GLenum fail, IN GLenum zfail, IN GLenum zpass )
|
|
{
|
|
struct __gllc_StencilOp_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_StencilOp_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_StencilOp_Rec)),
|
|
DLIST_GENERIC_OP(StencilOp));
|
|
if (data == NULL) return;
|
|
data->fail = fail;
|
|
data->zfail = zfail;
|
|
data->zpass = zpass;
|
|
__glDlistAppendOp(gc, data, __glle_StencilOp);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_DepthFunc ( IN GLenum func )
|
|
{
|
|
struct __gllc_DepthFunc_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_DepthFunc_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_DepthFunc_Rec)),
|
|
DLIST_GENERIC_OP(DepthFunc));
|
|
if (data == NULL) return;
|
|
data->func = func;
|
|
__glDlistAppendOp(gc, data, __glle_DepthFunc);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PixelZoom ( IN GLfloat xfactor, IN GLfloat yfactor )
|
|
{
|
|
struct __gllc_PixelZoom_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_PixelZoom_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_PixelZoom_Rec)),
|
|
DLIST_GENERIC_OP(PixelZoom));
|
|
if (data == NULL) return;
|
|
data->xfactor = xfactor;
|
|
data->yfactor = yfactor;
|
|
__glDlistAppendOp(gc, data, __glle_PixelZoom);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PixelTransferf ( IN GLenum pname, IN GLfloat param )
|
|
{
|
|
struct __gllc_PixelTransferf_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_PixelTransferf_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_PixelTransferf_Rec)),
|
|
DLIST_GENERIC_OP(PixelTransferf));
|
|
if (data == NULL) return;
|
|
data->pname = pname;
|
|
data->param = param;
|
|
__glDlistAppendOp(gc, data, __glle_PixelTransferf);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PixelTransferi ( IN GLenum pname, IN GLint param )
|
|
{
|
|
struct __gllc_PixelTransferi_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_PixelTransferi_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_PixelTransferi_Rec)),
|
|
DLIST_GENERIC_OP(PixelTransferi));
|
|
if (data == NULL) return;
|
|
data->pname = pname;
|
|
data->param = param;
|
|
__glDlistAppendOp(gc, data, __glle_PixelTransferi);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PixelMapfv ( IN GLenum map, IN GLint mapsize, IN const GLfloat values[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_PixelMapfv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = mapsize * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidValue();
|
|
return;
|
|
}
|
|
size = sizeof(struct __gllc_PixelMapfv_Rec) + arraySize;
|
|
data = (struct __gllc_PixelMapfv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(PixelMapfv));
|
|
if (data == NULL) return;
|
|
data->map = map;
|
|
data->mapsize = mapsize;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_PixelMapfv_Rec),
|
|
values, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_PixelMapfv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PixelMapuiv ( IN GLenum map, IN GLint mapsize, IN const GLuint values[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_PixelMapuiv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = mapsize * 4;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidValue();
|
|
return;
|
|
}
|
|
size = sizeof(struct __gllc_PixelMapuiv_Rec) + arraySize;
|
|
data = (struct __gllc_PixelMapuiv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(PixelMapuiv));
|
|
if (data == NULL) return;
|
|
data->map = map;
|
|
data->mapsize = mapsize;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_PixelMapuiv_Rec),
|
|
values, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_PixelMapuiv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PixelMapusv ( IN GLenum map, IN GLint mapsize, IN const GLushort values[] )
|
|
{
|
|
GLuint size;
|
|
GLint arraySize;
|
|
struct __gllc_PixelMapusv_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
arraySize = mapsize * 2;
|
|
if (arraySize < 0) {
|
|
__gllc_InvalidValue();
|
|
return;
|
|
}
|
|
#ifdef NT
|
|
size = sizeof(struct __gllc_PixelMapusv_Rec) + __GL_PAD(arraySize);
|
|
#else
|
|
arraySize = __GL_PAD(arraySize);
|
|
size = sizeof(struct __gllc_PixelMapusv_Rec) + arraySize;
|
|
#endif
|
|
data = (struct __gllc_PixelMapusv_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(size), DLIST_GENERIC_OP(PixelMapusv));
|
|
if (data == NULL) return;
|
|
data->map = map;
|
|
data->mapsize = mapsize;
|
|
__GL_MEMCOPY((GLubyte *)data + sizeof(struct __gllc_PixelMapusv_Rec),
|
|
values, arraySize);
|
|
__glDlistAppendOp(gc, data, __glle_PixelMapusv);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_ReadBuffer ( IN GLenum mode )
|
|
{
|
|
struct __gllc_ReadBuffer_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_ReadBuffer_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_ReadBuffer_Rec)),
|
|
DLIST_GENERIC_OP(ReadBuffer));
|
|
if (data == NULL) return;
|
|
data->mode = mode;
|
|
__glDlistAppendOp(gc, data, __glle_ReadBuffer);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_CopyPixels ( IN GLint x, IN GLint y, IN GLsizei width, IN GLsizei height, IN GLenum type )
|
|
{
|
|
struct __gllc_CopyPixels_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_CopyPixels_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_CopyPixels_Rec)),
|
|
DLIST_GENERIC_OP(CopyPixels));
|
|
if (data == NULL) return;
|
|
data->x = x;
|
|
data->y = y;
|
|
data->width = width;
|
|
data->height = height;
|
|
data->type = type;
|
|
__glDlistAppendOp(gc, data, __glle_CopyPixels);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_DepthRange ( IN GLclampd zNear, IN GLclampd zFar )
|
|
{
|
|
struct __gllc_DepthRange_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_DepthRange_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_DepthRange_Rec)),
|
|
DLIST_GENERIC_OP(DepthRange));
|
|
if (data == NULL) return;
|
|
data->zNear = zNear;
|
|
data->zFar = zFar;
|
|
__glDlistAppendOp(gc, data, __glle_DepthRange);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Frustum ( IN GLdouble left, IN GLdouble right, IN GLdouble bottom, IN GLdouble top, IN GLdouble zNear, IN GLdouble zFar )
|
|
{
|
|
struct __gllc_Frustum_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Frustum_Rec *)
|
|
__glDlistAddOpAligned(gc, DLIST_SIZE(sizeof(struct __gllc_Frustum_Rec)),
|
|
DLIST_GENERIC_OP(Frustum));
|
|
if (data == NULL) return;
|
|
data->left = left;
|
|
data->right = right;
|
|
data->bottom = bottom;
|
|
data->top = top;
|
|
data->zNear = zNear;
|
|
data->zFar = zFar;
|
|
__glDlistAppendOp(gc, data, __glle_Frustum);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_LoadIdentity ( void )
|
|
{
|
|
void *data;
|
|
__GL_SETUP();
|
|
|
|
data = __glDlistAddOpUnaligned(gc, DLIST_SIZE(0), DLIST_GENERIC_OP(LoadIdentity));
|
|
if (data == NULL) return;
|
|
__glDlistAppendOp(gc, data, __glle_LoadIdentity);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_MatrixMode ( IN GLenum mode )
|
|
{
|
|
struct __gllc_MatrixMode_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_MatrixMode_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_MatrixMode_Rec)),
|
|
DLIST_GENERIC_OP(MatrixMode));
|
|
if (data == NULL) return;
|
|
data->mode = mode;
|
|
__glDlistAppendOp(gc, data, __glle_MatrixMode);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Ortho ( IN GLdouble left, IN GLdouble right, IN GLdouble bottom, IN GLdouble top, IN GLdouble zNear, IN GLdouble zFar )
|
|
{
|
|
struct __gllc_Ortho_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Ortho_Rec *)
|
|
__glDlistAddOpAligned(gc, DLIST_SIZE(sizeof(struct __gllc_Ortho_Rec)),
|
|
DLIST_GENERIC_OP(Ortho));
|
|
if (data == NULL) return;
|
|
data->left = left;
|
|
data->right = right;
|
|
data->bottom = bottom;
|
|
data->top = top;
|
|
data->zNear = zNear;
|
|
data->zFar = zFar;
|
|
__glDlistAppendOp(gc, data, __glle_Ortho);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PopMatrix ( void )
|
|
{
|
|
void *data;
|
|
__GL_SETUP();
|
|
|
|
data = __glDlistAddOpUnaligned(gc, DLIST_SIZE(0), DLIST_GENERIC_OP(PopMatrix));
|
|
if (data == NULL) return;
|
|
__glDlistAppendOp(gc, data, __glle_PopMatrix);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_PushMatrix ( void )
|
|
{
|
|
void *data;
|
|
__GL_SETUP();
|
|
|
|
data = __glDlistAddOpUnaligned(gc, DLIST_SIZE(0), DLIST_GENERIC_OP(PushMatrix));
|
|
if (data == NULL) return;
|
|
__glDlistAppendOp(gc, data, __glle_PushMatrix);
|
|
}
|
|
|
|
void APIENTRY
|
|
__gllc_Viewport ( IN GLint x, IN GLint y, IN GLsizei width, IN GLsizei height )
|
|
{
|
|
struct __gllc_Viewport_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_Viewport_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_Viewport_Rec)),
|
|
DLIST_GENERIC_OP(Viewport));
|
|
if (data == NULL) return;
|
|
data->x = x;
|
|
data->y = y;
|
|
data->width = width;
|
|
data->height = height;
|
|
__glDlistAppendOp(gc, data, __glle_Viewport);
|
|
}
|
|
|
|
void APIENTRY __gllc_BindTexture(GLenum target, GLuint texture)
|
|
{
|
|
struct __gllc_BindTexture_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_BindTexture_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_BindTexture_Rec)),
|
|
DLIST_GENERIC_OP(BindTexture));
|
|
if (data == NULL) return;
|
|
data->target = target;
|
|
data->texture = texture;
|
|
__glDlistAppendOp(gc, data, __glle_BindTexture);
|
|
}
|
|
|
|
void APIENTRY __gllc_PrioritizeTextures(GLsizei n, const GLuint *textures,
|
|
const GLclampf *priorities)
|
|
{
|
|
struct __gllc_PrioritizeTextures_Rec *data;
|
|
__GL_SETUP();
|
|
GLuint size;
|
|
GLubyte *extra;
|
|
|
|
size = DLIST_SIZE(sizeof(struct __gllc_PrioritizeTextures_Rec)+
|
|
n*(sizeof(GLuint)+sizeof(GLclampf)));
|
|
data = (struct __gllc_PrioritizeTextures_Rec *)
|
|
__glDlistAddOpUnaligned(gc, size,
|
|
DLIST_GENERIC_OP(PrioritizeTextures));
|
|
if (data == NULL) return;
|
|
data->n = n;
|
|
extra = (GLubyte *)data+sizeof(struct __gllc_PrioritizeTextures_Rec);
|
|
__GL_MEMCOPY(extra, textures, n*sizeof(GLuint));
|
|
extra += n*sizeof(GLuint);
|
|
__GL_MEMCOPY(extra, priorities, n*sizeof(GLclampf));
|
|
__glDlistAppendOp(gc, data, __glle_PrioritizeTextures);
|
|
}
|
|
|
|
void APIENTRY __gllc_CopyTexImage1D(GLenum target, GLint level,
|
|
GLenum internalformat, GLint x, GLint y,
|
|
GLsizei width, GLint border)
|
|
{
|
|
struct __gllc_CopyTexImage1D_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_CopyTexImage1D_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_CopyTexImage1D_Rec)),
|
|
DLIST_GENERIC_OP(CopyTexImage1D));
|
|
if (data == NULL) return;
|
|
data->target = target;
|
|
data->level = level;
|
|
data->internalformat = internalformat;
|
|
data->x = x;
|
|
data->y = y;
|
|
data->width = width;
|
|
data->border = border;
|
|
__glDlistAppendOp(gc, data, __glle_CopyTexImage1D);
|
|
}
|
|
|
|
void APIENTRY __gllc_CopyTexImage2D(GLenum target, GLint level,
|
|
GLenum internalformat, GLint x, GLint y,
|
|
GLsizei width, GLsizei height, GLint border)
|
|
{
|
|
struct __gllc_CopyTexImage2D_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_CopyTexImage2D_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_CopyTexImage2D_Rec)),
|
|
DLIST_GENERIC_OP(CopyTexImage2D));
|
|
if (data == NULL) return;
|
|
data->target = target;
|
|
data->level = level;
|
|
data->internalformat = internalformat;
|
|
data->x = x;
|
|
data->y = y;
|
|
data->width = width;
|
|
data->height = height;
|
|
data->border = border;
|
|
__glDlistAppendOp(gc, data, __glle_CopyTexImage2D);
|
|
}
|
|
|
|
void APIENTRY __gllc_CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset,
|
|
GLint x, GLint y, GLsizei width)
|
|
{
|
|
struct __gllc_CopyTexSubImage1D_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_CopyTexSubImage1D_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_CopyTexSubImage1D_Rec)),
|
|
DLIST_GENERIC_OP(CopyTexSubImage1D));
|
|
if (data == NULL) return;
|
|
data->target = target;
|
|
data->level = level;
|
|
data->xoffset = xoffset;
|
|
data->x = x;
|
|
data->y = y;
|
|
data->width = width;
|
|
__glDlistAppendOp(gc, data, __glle_CopyTexSubImage1D);
|
|
}
|
|
|
|
void APIENTRY __gllc_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
|
|
GLint yoffset, GLint x, GLint y,
|
|
GLsizei width, GLsizei height)
|
|
{
|
|
struct __gllc_CopyTexSubImage2D_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_CopyTexSubImage2D_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_CopyTexSubImage2D_Rec)),
|
|
DLIST_GENERIC_OP(CopyTexSubImage2D));
|
|
if (data == NULL) return;
|
|
data->target = target;
|
|
data->level = level;
|
|
data->xoffset = xoffset;
|
|
data->yoffset = yoffset;
|
|
data->x = x;
|
|
data->y = y;
|
|
data->width = width;
|
|
data->height = height;
|
|
__glDlistAppendOp(gc, data, __glle_CopyTexSubImage2D);
|
|
}
|
|
|
|
void APIENTRY __gllc_PolygonOffset(GLfloat factor, GLfloat units)
|
|
{
|
|
struct __gllc_PolygonOffset_Rec *data;
|
|
__GL_SETUP();
|
|
|
|
data = (struct __gllc_PolygonOffset_Rec *)
|
|
__glDlistAddOpUnaligned(gc, DLIST_SIZE(sizeof(struct __gllc_PolygonOffset_Rec)),
|
|
DLIST_GENERIC_OP(PolygonOffset));
|
|
if (data == NULL) return;
|
|
data->factor = factor;
|
|
data->units = units;
|
|
__glDlistAppendOp(gc, data, __glle_PolygonOffset);
|
|
}
|