This is api.c in view mode; [Download] [Up]
/* $Id: api.c,v 1.22 1997/06/20 01:56:30 brianp Exp $ */
/*
* Mesa 3-D graphics library
* Version: 2.3
* Copyright (C) 1995-1997 Brian Paul
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
* $Log: api.c,v $
* Revision 1.22 1997/06/20 01:56:30 brianp
* added Color4ubv API pointer
*
* Revision 1.21 1997/06/06 02:58:39 brianp
* fixed unitialized reads in glTexEnvi, glTexParameteri (Andre' Johansen)
*
* Revision 1.20 1997/05/28 03:23:09 brianp
* added precompiled header (PCH) support
*
* Revision 1.19 1997/04/24 01:50:53 brianp
* optimized glColor3f, glColor3fv, glColor4fv
*
* Revision 1.18 1997/04/24 00:30:17 brianp
* optimized glTexCoord2() code
*
* Revision 1.17 1997/04/20 16:18:15 brianp
* added glOrtho and glFrustum API pointers
*
* Revision 1.16 1997/04/16 23:55:33 brianp
* added optimized glTexCoord2f code
*
* Revision 1.15 1997/04/14 22:18:23 brianp
* added optimized glVertex3fv code
*
* Revision 1.14 1997/04/07 02:56:39 brianp
* added API.Vertex[23] functions
*
* Revision 1.13 1997/04/02 03:49:02 brianp
* added APIENTRY keyword, per Kendall Bennett
*
* Revision 1.12 1997/04/02 03:09:44 brianp
* added LoadIdentity API pointer
*
* Revision 1.11 1997/02/19 18:09:10 brianp
* now only print "no rendering context" error if MESA_DEBUG is set
*
* Revision 1.10 1997/02/10 19:49:29 brianp
* added glResizeBuffersMESA() code
*
* Revision 1.9 1997/02/09 18:49:52 brianp
* added GL_EXT_texture3D support
*
* Revision 1.8 1997/01/08 20:55:25 brianp
* added GL_EXT_texture_object API functions
*
* Revision 1.7 1996/11/09 01:41:17 brianp
* check if there's no rendering context and return gracefully
*
* Revision 1.6 1996/11/07 04:12:13 brianp
* glTexImage[12]D() reimplemented
*
* Revision 1.5 1996/10/11 03:41:44 brianp
* added glPolygonOffsetEXT()
*
* Revision 1.4 1996/09/27 01:23:50 brianp
* added extra error checking when DEBUG is defined
*
* Revision 1.3 1996/09/26 22:52:12 brianp
* added glInterleavedArrays
*
* Revision 1.2 1996/09/14 06:27:22 brianp
* some functions didn't return needed values
*
* Revision 1.1 1996/09/13 01:38:16 brianp
* Initial revision
*
*/
#ifdef PCH
#include "all.h"
#else
#include <stdio.h>
#include <stdlib.h>
#include "bitmap.h"
#include "context.h"
#include "eval.h"
#include "image.h"
#include "macros.h"
#include "matrix.h"
#include "teximage.h"
#include "types.h"
#include "vb.h"
#endif
/*
* Single/multiple thread context selection.
*/
#ifdef MULTI_THREADING
/* Get the context associated with the calling thread */
#define GET_CONTEXT GLcontext *CC = gl_get_thread_context()
#else
/* CC is a global pointer for all threads in the address space */
#define GET_CONTEXT
#endif /*MULTI_THREADED*/
/*
* Make sure there's a rendering context.
*/
#define CHECK_CONTEXT \
if (!CC) { \
if (getenv("MESA_DEBUG")) { \
fprintf(stderr,"Mesa user error: no rendering context.\n"); \
} \
return; \
}
#define CHECK_CONTEXT_RETURN(R) \
if (!CC) { \
if (getenv("MESA_DEBUG")) { \
fprintf(stderr,"Mesa user error: no rendering context.\n"); \
} \
return (R); \
}
/*
* An optimization in a few performance-critical functions.
*/
#define SHORTCUT
/*
* Windows 95/NT DLL stuff.
*/
#ifndef WINDOWS_NT
#define APIENTRY
#endif
void APIENTRY glAccum( GLenum op, GLfloat value )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Accum)(CC, op, value);
}
void APIENTRY glAlphaFunc( GLenum func, GLclampf ref )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.AlphaFunc)(CC, func, ref);
}
GLboolean APIENTRY glAreTexturesResident( GLsizei n, const GLuint *textures,
GLboolean *residences )
{
GET_CONTEXT;
CHECK_CONTEXT_RETURN(GL_FALSE);
return (*CC->API.AreTexturesResident)(CC, n, textures, residences);
}
void APIENTRY glArrayElement( GLint i )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ArrayElement)(CC, i);
}
void APIENTRY glBegin( GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Begin)( CC, mode );
}
void APIENTRY glBindTexture( GLenum target, GLuint texture )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.BindTexture)(CC, target, texture);
}
void APIENTRY glBitmap( GLsizei width, GLsizei height,
GLfloat xorig, GLfloat yorig,
GLfloat xmove, GLfloat ymove,
const GLubyte *bitmap )
{
GET_CONTEXT;
CHECK_CONTEXT;
if (!CC->CompileFlag) {
/* execute only, try optimized case where no unpacking needed */
if ( CC->Unpack.LsbFirst==GL_FALSE
&& CC->Unpack.Alignment==1
&& CC->Unpack.RowLength==0
&& CC->Unpack.SkipPixels==0
&& CC->Unpack.SkipRows==0) {
/* Special case: no unpacking needed */
struct gl_image image;
image.Width = width;
image.Height = height;
image.Components = 0;
image.Type = GL_BITMAP;
image.Data = (GLvoid *) bitmap;
(*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
xmove, ymove, &image );
}
else {
struct gl_image *image;
image = gl_unpack_bitmap( CC, width, height, bitmap );
(*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
xmove, ymove, image );
gl_free_image( image );
}
}
else {
/* compile and maybe execute */
struct gl_image *image;
image = gl_unpack_bitmap( CC, width, height, bitmap );
(*CC->API.Bitmap)(CC, width, height, xorig, yorig, xmove, ymove, image );
}
}
void APIENTRY glBlendFunc( GLenum sfactor, GLenum dfactor )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.BlendFunc)(CC, sfactor, dfactor);
}
void APIENTRY glCallList( GLuint list )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.CallList)(CC, list);
}
void APIENTRY glCallLists( GLsizei n, GLenum type, const GLvoid *lists )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.CallLists)(CC, n, type, lists);
}
void APIENTRY glClear( GLbitfield mask )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Clear)(CC, mask);
}
void APIENTRY glClearAccum( GLfloat red, GLfloat green,
GLfloat blue, GLfloat alpha )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ClearAccum)(CC, red, green, blue, alpha);
}
void APIENTRY glClearIndex( GLfloat c )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ClearIndex)(CC, c);
}
void APIENTRY glClearColor( GLclampf red,
GLclampf green,
GLclampf blue,
GLclampf alpha )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ClearColor)(CC, red, green, blue, alpha);
}
void APIENTRY glClearDepth( GLclampd depth )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ClearDepth)( CC, depth );
}
void APIENTRY glClearStencil( GLint s )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ClearStencil)(CC, s);
}
void APIENTRY glClipPlane( GLenum plane, const GLdouble *equation )
{
GLfloat eq[4];
GET_CONTEXT;
CHECK_CONTEXT;
eq[0] = (GLfloat) equation[0];
eq[1] = (GLfloat) equation[1];
eq[2] = (GLfloat) equation[2];
eq[3] = (GLfloat) equation[3];
(*CC->API.ClipPlane)(CC, plane, eq );
}
void APIENTRY glColor3b( GLbyte red, GLbyte green, GLbyte blue )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
BYTE_TO_FLOAT(blue) );
}
void APIENTRY glColor3d( GLdouble red, GLdouble green, GLdouble blue )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, (GLfloat) red, (GLfloat) green, (GLfloat) blue );
}
void APIENTRY glColor3f( GLfloat red, GLfloat green, GLfloat blue )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, red, green, blue );
}
void APIENTRY glColor3i( GLint red, GLint green, GLint blue )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
INT_TO_FLOAT(blue) );
}
void APIENTRY glColor3s( GLshort red, GLshort green, GLshort blue )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
SHORT_TO_FLOAT(blue) );
}
void APIENTRY glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
{
GET_CONTEXT;
(*CC->API.Color4ub)( CC, red, green, blue, 255 );
}
void APIENTRY glColor3ui( GLuint red, GLuint green, GLuint blue )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
UINT_TO_FLOAT(blue) );
}
void APIENTRY glColor3us( GLushort red, GLushort green, GLushort blue )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
USHORT_TO_FLOAT(blue) );
}
void APIENTRY glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
BYTE_TO_FLOAT(blue), BYTE_TO_FLOAT(alpha) );
}
void APIENTRY glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, (GLfloat) red, (GLfloat) green,
(GLfloat) blue, (GLfloat) alpha );
}
void APIENTRY glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, red, green, blue, alpha );
}
void APIENTRY glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
INT_TO_FLOAT(blue), INT_TO_FLOAT(alpha) );
}
void APIENTRY glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
SHORT_TO_FLOAT(blue), SHORT_TO_FLOAT(alpha) );
}
void APIENTRY glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
{
GET_CONTEXT;
(*CC->API.Color4ub)( CC, red, green, blue, alpha );
}
void APIENTRY glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
UINT_TO_FLOAT(blue), UINT_TO_FLOAT(alpha) );
}
void APIENTRY glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
USHORT_TO_FLOAT(blue), USHORT_TO_FLOAT(alpha) );
}
void APIENTRY glColor3bv( const GLbyte *v )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
BYTE_TO_FLOAT(v[2]) );
}
void APIENTRY glColor3dv( const GLdouble *v )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, (GLdouble) v[0], (GLdouble) v[1], (GLdouble) v[2] );
}
void APIENTRY glColor3fv( const GLfloat *v )
{
GET_CONTEXT;
(*CC->API.Color3fv)( CC, v );
}
void APIENTRY glColor3iv( const GLint *v )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
INT_TO_FLOAT(v[2]) );
}
void APIENTRY glColor3sv( const GLshort *v )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
SHORT_TO_FLOAT(v[2]) );
}
void APIENTRY glColor3ubv( const GLubyte *v )
{
GET_CONTEXT;
(*CC->API.Color4ub)( CC, v[0], v[1], v[2], 255 );
}
void APIENTRY glColor3uiv( const GLuint *v )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
UINT_TO_FLOAT(v[2]) );
}
void APIENTRY glColor3usv( const GLushort *v )
{
GET_CONTEXT;
(*CC->API.Color3f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
USHORT_TO_FLOAT(v[2]) );
}
void APIENTRY glColor4bv( const GLbyte *v )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]) );
}
void APIENTRY glColor4dv( const GLdouble *v )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, (GLdouble) v[0], (GLdouble) v[1],
(GLdouble) v[2], (GLdouble) v[3] );
}
void APIENTRY glColor4fv( const GLfloat *v )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, v[0], v[1], v[2], v[3] );
}
void APIENTRY glColor4iv( const GLint *v )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]) );
}
void APIENTRY glColor4sv( const GLshort *v )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]) );
}
void APIENTRY glColor4ubv( const GLubyte *v )
{
GET_CONTEXT;
(*CC->API.Color4ubv)( CC, v );
}
void APIENTRY glColor4uiv( const GLuint *v )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]) );
}
void APIENTRY glColor4usv( const GLushort *v )
{
GET_CONTEXT;
(*CC->API.Color4f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]) );
}
void APIENTRY glColorMask( GLboolean red, GLboolean green,
GLboolean blue, GLboolean alpha )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ColorMask)(CC, red, green, blue, alpha);
}
void APIENTRY glColorMaterial( GLenum face, GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ColorMaterial)(CC, face, mode);
}
void APIENTRY glColorPointer( GLint size, GLenum type, GLsizei stride,
const GLvoid *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ColorPointer)(CC, size, type, stride, ptr);
}
void APIENTRY glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height,
GLenum type )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.CopyPixels)(CC, x, y, width, height, type);
}
void APIENTRY glCopyTexImage1D( GLenum target, GLint level,
GLenum internalformat,
GLint x, GLint y,
GLsizei width, GLint border )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.CopyTexImage1D)( CC, target, level, internalformat,
x, y, width, border );
}
void APIENTRY glCopyTexImage2D( GLenum target, GLint level,
GLenum internalformat,
GLint x, GLint y,
GLsizei width, GLsizei height, GLint border )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.CopyTexImage2D)( CC, target, level, internalformat,
x, y, width, height, border );
}
void APIENTRY glCopyTexSubImage1D( GLenum target, GLint level,
GLint xoffset, GLint x, GLint y,
GLsizei width )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.CopyTexSubImage1D)( CC, target, level, xoffset, x, y, width );
}
void APIENTRY glCopyTexSubImage2D( GLenum target, GLint level,
GLint xoffset, GLint yoffset,
GLint x, GLint y,
GLsizei width, GLsizei height )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.CopyTexSubImage2D)( CC, target, level, xoffset, yoffset,
x, y, width, height );
}
void APIENTRY glCullFace( GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.CullFace)(CC, mode);
}
void APIENTRY glDepthFunc( GLenum func )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DepthFunc)( CC, func );
}
void APIENTRY glDepthMask( GLboolean flag )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DepthMask)( CC, flag );
}
void APIENTRY glDepthRange( GLclampd near_val, GLclampd far_val )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DepthRange)( CC, near_val, far_val );
}
void APIENTRY glDeleteLists( GLuint list, GLsizei range )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DeleteLists)(CC, list, range);
}
void APIENTRY glDeleteTextures( GLsizei n, const GLuint *textures)
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DeleteTextures)(CC, n, textures);
}
void APIENTRY glDisable( GLenum cap )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Disable)( CC, cap );
}
void APIENTRY glDisableClientState( GLenum cap )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DisableClientState)( CC, cap );
}
void APIENTRY glDrawArrays( GLenum mode, GLint first, GLsizei count )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DrawArrays)(CC, mode, first, count);
}
void APIENTRY glDrawBuffer( GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DrawBuffer)(CC, mode);
}
void APIENTRY glDrawElements( GLenum mode, GLsizei count,
GLenum type, const GLvoid *indices )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DrawElements)( CC, mode, count, type, indices );
}
void APIENTRY glDrawPixels( GLsizei width, GLsizei height,
GLenum format, GLenum type, const GLvoid *pixels )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DrawPixels)( CC, width, height, format, type, pixels );
}
void APIENTRY glEnable( GLenum cap )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Enable)( CC, cap );
}
void APIENTRY glEnableClientState( GLenum cap )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EnableClientState)( CC, cap );
}
void APIENTRY glEnd( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.End)( CC );
}
void APIENTRY glEndList( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EndList)(CC);
}
void APIENTRY glEvalCoord1d( GLdouble u )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalCoord1f)( CC, (GLfloat) u );
}
void APIENTRY glEvalCoord1f( GLfloat u )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalCoord1f)( CC, u );
}
void APIENTRY glEvalCoord1dv( const GLdouble *u )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
}
void APIENTRY glEvalCoord1fv( const GLfloat *u )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
}
void APIENTRY glEvalCoord2d( GLdouble u, GLdouble v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalCoord2f)( CC, (GLfloat) u, (GLfloat) v );
}
void APIENTRY glEvalCoord2f( GLfloat u, GLfloat v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalCoord2f)( CC, u, v );
}
void APIENTRY glEvalCoord2dv( const GLdouble *u )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalCoord2f)( CC, (GLfloat) u[0], (GLfloat) u[1] );
}
void APIENTRY glEvalCoord2fv( const GLfloat *u )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalCoord2f)( CC, u[0], u[1] );
}
void APIENTRY glEvalPoint1( GLint i )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalPoint1)( CC, i );
}
void APIENTRY glEvalPoint2( GLint i, GLint j )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalPoint2)( CC, i, j );
}
void APIENTRY glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalMesh1)( CC, mode, i1, i2 );
}
void APIENTRY glEdgeFlag( GLboolean flag )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EdgeFlag)(CC, flag);
}
void APIENTRY glEdgeFlagv( const GLboolean *flag )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EdgeFlag)(CC, *flag);
}
void APIENTRY glEdgeFlagPointer( GLsizei stride, const GLboolean *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EdgeFlagPointer)(CC, stride, ptr);
}
void APIENTRY glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EvalMesh2)( CC, mode, i1, i2, j1, j2 );
}
void APIENTRY glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.FeedbackBuffer)(CC, size, type, buffer);
}
void APIENTRY glFinish( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Finish)(CC);
}
void APIENTRY glFlush( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Flush)(CC);
}
void APIENTRY glFogf( GLenum pname, GLfloat param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Fogfv)(CC, pname, ¶m);
}
void APIENTRY glFogi( GLenum pname, GLint param )
{
GLfloat fparam = (GLfloat) param;
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Fogfv)(CC, pname, &fparam);
}
void APIENTRY glFogfv( GLenum pname, const GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Fogfv)(CC, pname, params);
}
void APIENTRY glFogiv( GLenum pname, const GLint *params )
{
GLfloat p[4];
GET_CONTEXT;
CHECK_CONTEXT;
switch (pname) {
case GL_FOG_MODE:
case GL_FOG_DENSITY:
case GL_FOG_START:
case GL_FOG_END:
case GL_FOG_INDEX:
p[0] = (GLfloat) *params;
break;
case GL_FOG_COLOR:
p[0] = INT_TO_FLOAT( params[0] );
p[1] = INT_TO_FLOAT( params[1] );
p[2] = INT_TO_FLOAT( params[2] );
p[3] = INT_TO_FLOAT( params[3] );
break;
default:
/* Error will be caught later in gl_Fogfv */
;
}
(*CC->API.Fogfv)( CC, pname, p );
}
void APIENTRY glFrontFace( GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.FrontFace)(CC, mode);
}
void APIENTRY glFrustum( GLdouble left, GLdouble right,
GLdouble bottom, GLdouble top,
GLdouble nearval, GLdouble farval )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Frustum)(CC, left, right, bottom, top, nearval, farval);
}
GLuint APIENTRY glGenLists( GLsizei range )
{
GET_CONTEXT;
CHECK_CONTEXT_RETURN(0);
return (*CC->API.GenLists)(CC, range);
}
void APIENTRY glGenTextures( GLsizei n, GLuint *textures )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GenTextures)(CC, n, textures);
}
void APIENTRY glGetBooleanv( GLenum pname, GLboolean *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetBooleanv)(CC, pname, params);
}
void APIENTRY glGetClipPlane( GLenum plane, GLdouble *equation )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetClipPlane)(CC, plane, equation);
}
void APIENTRY glGetDoublev( GLenum pname, GLdouble *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetDoublev)(CC, pname, params);
}
GLenum APIENTRY glGetError( void )
{
GET_CONTEXT;
if (!CC) {
/* No current context */
return GL_NO_ERROR;
}
return (*CC->API.GetError)(CC);
}
void APIENTRY glGetFloatv( GLenum pname, GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetFloatv)(CC, pname, params);
}
void APIENTRY glGetIntegerv( GLenum pname, GLint *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetIntegerv)(CC, pname, params);
}
void APIENTRY glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetLightfv)(CC, light, pname, params);
}
void APIENTRY glGetLightiv( GLenum light, GLenum pname, GLint *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetLightiv)(CC, light, pname, params);
}
void APIENTRY glGetMapdv( GLenum target, GLenum query, GLdouble *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetMapdv)( CC, target, query, v );
}
void APIENTRY glGetMapfv( GLenum target, GLenum query, GLfloat *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetMapfv)( CC, target, query, v );
}
void APIENTRY glGetMapiv( GLenum target, GLenum query, GLint *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetMapiv)( CC, target, query, v );
}
void APIENTRY glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetMaterialfv)(CC, face, pname, params);
}
void APIENTRY glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetMaterialiv)(CC, face, pname, params);
}
void APIENTRY glGetPixelMapfv( GLenum map, GLfloat *values )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetPixelMapfv)(CC, map, values);
}
void APIENTRY glGetPixelMapuiv( GLenum map, GLuint *values )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetPixelMapuiv)(CC, map, values);
}
void APIENTRY glGetPixelMapusv( GLenum map, GLushort *values )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetPixelMapusv)(CC, map, values);
}
void APIENTRY glGetPointerv( GLenum pname, GLvoid **params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetPointerv)(CC, pname, params);
}
void APIENTRY glGetPolygonStipple( GLubyte *mask )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetPolygonStipple)(CC, mask);
}
const GLubyte * APIENTRY glGetString( GLenum name )
{
GET_CONTEXT;
CHECK_CONTEXT_RETURN(NULL);
return (*CC->API.GetString)(CC, name);
}
void APIENTRY glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetTexEnvfv)(CC, target, pname, params);
}
void APIENTRY glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetTexEnviv)(CC, target, pname, params);
}
void APIENTRY glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetTexGeniv)(CC, coord, pname, params);
}
void APIENTRY glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetTexGendv)(CC, coord, pname, params);
}
void APIENTRY glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetTexGenfv)(CC, coord, pname, params);
}
void APIENTRY glGetTexImage( GLenum target, GLint level, GLenum format,
GLenum type, GLvoid *pixels )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetTexImage)(CC, target, level, format, type, pixels);
}
void APIENTRY glGetTexLevelParameterfv( GLenum target, GLint level,
GLenum pname, GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetTexLevelParameterfv)(CC, target, level, pname, params);
}
void APIENTRY glGetTexLevelParameteriv( GLenum target, GLint level,
GLenum pname, GLint *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetTexLevelParameteriv)(CC, target, level, pname, params);
}
void APIENTRY glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params)
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetTexParameterfv)(CC, target, pname, params);
}
void APIENTRY glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetTexParameteriv)(CC, target, pname, params);
}
void APIENTRY glHint( GLenum target, GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Hint)(CC, target, mode);
}
void APIENTRY glIndexd( GLdouble c )
{
GET_CONTEXT;
(*CC->API.Indexf)( CC, (GLfloat) c );
}
void APIENTRY glIndexf( GLfloat c )
{
GET_CONTEXT;
(*CC->API.Indexf)( CC, c );
}
void APIENTRY glIndexi( GLint c )
{
GET_CONTEXT;
(*CC->API.Indexi)( CC, c );
}
void APIENTRY glIndexs( GLshort c )
{
GET_CONTEXT;
(*CC->API.Indexi)( CC, (GLint) c );
}
#ifdef GL_VERSION_1_1
void APIENTRY glIndexub( GLubyte c )
{
GET_CONTEXT;
(*CC->API.Indexi)( CC, (GLint) c );
}
#endif
void APIENTRY glIndexdv( const GLdouble *c )
{
GET_CONTEXT;
(*CC->API.Indexf)( CC, (GLfloat) *c );
}
void APIENTRY glIndexfv( const GLfloat *c )
{
GET_CONTEXT;
(*CC->API.Indexf)( CC, *c );
}
void APIENTRY glIndexiv( const GLint *c )
{
GET_CONTEXT;
(*CC->API.Indexi)( CC, *c );
}
void APIENTRY glIndexsv( const GLshort *c )
{
GET_CONTEXT;
(*CC->API.Indexi)( CC, (GLint) *c );
}
#ifdef GL_VERSION_1_1
void APIENTRY glIndexubv( const GLubyte *c )
{
GET_CONTEXT;
(*CC->API.Indexi)( CC, (GLint) *c );
}
#endif
void APIENTRY glIndexMask( GLuint mask )
{
GET_CONTEXT;
(*CC->API.IndexMask)(CC, mask);
}
void APIENTRY glIndexPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.IndexPointer)(CC, type, stride, ptr);
}
void APIENTRY glInterleavedArrays( GLenum format, GLsizei stride,
const GLvoid *pointer )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.InterleavedArrays)( CC, format, stride, pointer );
}
void APIENTRY glInitNames( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.InitNames)(CC);
}
GLboolean APIENTRY glIsList( GLuint list )
{
GET_CONTEXT;
CHECK_CONTEXT_RETURN(GL_FALSE);
return (*CC->API.IsList)(CC, list);
}
GLboolean APIENTRY glIsTexture( GLuint texture )
{
GET_CONTEXT;
CHECK_CONTEXT_RETURN(GL_FALSE);
return (*CC->API.IsTexture)(CC, texture);
}
void APIENTRY glLightf( GLenum light, GLenum pname, GLfloat param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Lightfv)( CC, light, pname, ¶m, 1 );
}
void APIENTRY glLighti( GLenum light, GLenum pname, GLint param )
{
GLfloat fparam = (GLfloat) param;
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Lightfv)( CC, light, pname, &fparam, 1 );
}
void APIENTRY glLightfv( GLenum light, GLenum pname, const GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Lightfv)( CC, light, pname, params, 4 );
}
void APIENTRY glLightiv( GLenum light, GLenum pname, const GLint *params )
{
GLfloat fparam[4];
GET_CONTEXT;
CHECK_CONTEXT;
switch (pname) {
case GL_AMBIENT:
case GL_DIFFUSE:
case GL_SPECULAR:
fparam[0] = INT_TO_FLOAT( params[0] );
fparam[1] = INT_TO_FLOAT( params[1] );
fparam[2] = INT_TO_FLOAT( params[2] );
fparam[3] = INT_TO_FLOAT( params[3] );
break;
case GL_POSITION:
fparam[0] = (GLfloat) params[0];
fparam[1] = (GLfloat) params[1];
fparam[2] = (GLfloat) params[2];
fparam[3] = (GLfloat) params[3];
break;
case GL_SPOT_DIRECTION:
fparam[0] = (GLfloat) params[0];
fparam[1] = (GLfloat) params[1];
fparam[2] = (GLfloat) params[2];
break;
case GL_SPOT_EXPONENT:
case GL_SPOT_CUTOFF:
case GL_CONSTANT_ATTENUATION:
case GL_LINEAR_ATTENUATION:
case GL_QUADRATIC_ATTENUATION:
fparam[0] = (GLfloat) params[0];
break;
default:
/* error will be caught later in gl_Lightfv */
;
}
(*CC->API.Lightfv)( CC, light, pname, fparam, 4 );
}
void APIENTRY glLightModelf( GLenum pname, GLfloat param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.LightModelfv)( CC, pname, ¶m );
}
void APIENTRY glLightModeli( GLenum pname, GLint param )
{
GLfloat fparam[4];
GET_CONTEXT;
CHECK_CONTEXT;
fparam[0] = (GLfloat) param;
(*CC->API.LightModelfv)( CC, pname, fparam );
}
void APIENTRY glLightModelfv( GLenum pname, const GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.LightModelfv)( CC, pname, params );
}
void APIENTRY glLightModeliv( GLenum pname, const GLint *params )
{
GLfloat fparam[4];
GET_CONTEXT;
CHECK_CONTEXT;
switch (pname) {
case GL_LIGHT_MODEL_AMBIENT:
fparam[0] = INT_TO_FLOAT( params[0] );
fparam[1] = INT_TO_FLOAT( params[1] );
fparam[2] = INT_TO_FLOAT( params[2] );
fparam[3] = INT_TO_FLOAT( params[3] );
break;
case GL_LIGHT_MODEL_LOCAL_VIEWER:
case GL_LIGHT_MODEL_TWO_SIDE:
fparam[0] = (GLfloat) params[0];
break;
default:
/* Error will be caught later in gl_LightModelfv */
;
}
(*CC->API.LightModelfv)( CC, pname, fparam );
}
void APIENTRY glLineWidth( GLfloat width )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.LineWidth)(CC, width);
}
void APIENTRY glLineStipple( GLint factor, GLushort pattern )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.LineStipple)(CC, factor, pattern);
}
void APIENTRY glListBase( GLuint base )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ListBase)(CC, base);
}
void APIENTRY glLoadIdentity( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.LoadIdentity)( CC );
}
void APIENTRY glLoadMatrixd( const GLdouble *m )
{
GLfloat fm[16];
GLuint i;
GET_CONTEXT;
CHECK_CONTEXT;
for (i=0;i<16;i++) {
fm[i] = (GLfloat) m[i];
}
(*CC->API.LoadMatrixf)( CC, fm );
}
void APIENTRY glLoadMatrixf( const GLfloat *m )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.LoadMatrixf)( CC, m );
}
void APIENTRY glLoadName( GLuint name )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.LoadName)(CC, name);
}
void APIENTRY glLogicOp( GLenum opcode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.LogicOp)(CC, opcode);
}
void APIENTRY glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
GLint order, const GLdouble *points )
{
GLfloat *pnts;
GLboolean retain;
GET_CONTEXT;
CHECK_CONTEXT;
pnts = gl_copy_map_points1d( target, stride, order, points );
retain = CC->CompileFlag;
(*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
}
void APIENTRY glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
GLint order, const GLfloat *points )
{
GLfloat *pnts;
GLboolean retain;
GET_CONTEXT;
CHECK_CONTEXT;
pnts = gl_copy_map_points1f( target, stride, order, points );
retain = CC->CompileFlag;
(*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
}
void APIENTRY glMap2d( GLenum target,
GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
const GLdouble *points )
{
GLfloat *pnts;
GLboolean retain;
GET_CONTEXT;
CHECK_CONTEXT;
pnts = gl_copy_map_points2d( target, ustride, uorder,
vstride, vorder, points );
retain = CC->CompileFlag;
(*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
v1, v2, vstride, vorder, pnts, retain );
}
void APIENTRY glMap2f( GLenum target,
GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
const GLfloat *points )
{
GLfloat *pnts;
GLboolean retain;
GET_CONTEXT;
CHECK_CONTEXT;
pnts = gl_copy_map_points2f( target, ustride, uorder,
vstride, vorder, points );
retain = CC->CompileFlag;
(*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
v1, v2, vstride, vorder, pnts, retain );
}
void APIENTRY glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.MapGrid1f)( CC, un, (GLfloat) u1, (GLfloat) u2 );
}
void APIENTRY glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.MapGrid1f)( CC, un, u1, u2 );
}
void APIENTRY glMapGrid2d( GLint un, GLdouble u1, GLdouble u2,
GLint vn, GLdouble v1, GLdouble v2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.MapGrid2f)( CC, un, (GLfloat) u1, (GLfloat) u2,
vn, (GLfloat) v1, (GLfloat) v2 );
}
void APIENTRY glMapGrid2f( GLint un, GLfloat u1, GLfloat u2,
GLint vn, GLfloat v1, GLfloat v2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.MapGrid2f)( CC, un, u1, u2, vn, v1, v2 );
}
void APIENTRY glMaterialf( GLenum face, GLenum pname, GLfloat param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Materialfv)( CC, face, pname, ¶m );
}
void APIENTRY glMateriali( GLenum face, GLenum pname, GLint param )
{
GLfloat fparam[4];
GET_CONTEXT;
CHECK_CONTEXT;
fparam[0] = (GLfloat) param;
(*CC->API.Materialfv)( CC, face, pname, fparam );
}
void APIENTRY glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Materialfv)( CC, face, pname, params );
}
void APIENTRY glMaterialiv( GLenum face, GLenum pname, const GLint *params )
{
GLfloat fparam[4];
GET_CONTEXT;
CHECK_CONTEXT;
switch (pname) {
case GL_AMBIENT:
case GL_DIFFUSE:
case GL_SPECULAR:
case GL_EMISSION:
case GL_AMBIENT_AND_DIFFUSE:
fparam[0] = INT_TO_FLOAT( params[0] );
fparam[1] = INT_TO_FLOAT( params[1] );
fparam[2] = INT_TO_FLOAT( params[2] );
fparam[3] = INT_TO_FLOAT( params[3] );
break;
case GL_SHININESS:
fparam[0] = (GLfloat) params[0];
break;
case GL_COLOR_INDEXES:
fparam[0] = (GLfloat) params[0];
fparam[1] = (GLfloat) params[1];
fparam[2] = (GLfloat) params[2];
break;
default:
/* Error will be caught later in gl_Materialfv */
;
}
(*CC->API.Materialfv)( CC, face, pname, fparam );
}
void APIENTRY glMatrixMode( GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.MatrixMode)( CC, mode );
}
void APIENTRY glMultMatrixd( const GLdouble *m )
{
GLfloat fm[16];
GLuint i;
GET_CONTEXT;
CHECK_CONTEXT;
for (i=0;i<16;i++) {
fm[i] = (GLfloat) m[i];
}
(*CC->API.MultMatrixf)( CC, fm );
}
void APIENTRY glMultMatrixf( const GLfloat *m )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.MultMatrixf)( CC, m );
}
void APIENTRY glNewList( GLuint list, GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.NewList)(CC, list, mode);
}
void APIENTRY glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
{
GET_CONTEXT;
(*CC->API.Normal3f)( CC, BYTE_TO_FLOAT(nx),
BYTE_TO_FLOAT(ny), BYTE_TO_FLOAT(nz) );
}
void APIENTRY glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
{
GLfloat fx, fy, fz;
GET_CONTEXT;
if (ABSD(nx)<0.00001) fx = 0.0F; else fx = nx;
if (ABSD(ny)<0.00001) fy = 0.0F; else fy = ny;
if (ABSD(nz)<0.00001) fz = 0.0F; else fz = nz;
(*CC->API.Normal3f)( CC, fx, fy, fz );
}
void APIENTRY glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
{
GET_CONTEXT;
#ifdef SHORTCUT
if (CC->CompileFlag) {
(*CC->Save.Normal3f)( CC, nx, ny, nz );
}
else {
/* Execute */
CC->Current.Normal[0] = nx;
CC->Current.Normal[1] = ny;
CC->Current.Normal[2] = nz;
CC->VB->MonoNormal = GL_FALSE;
}
#else
(*CC->API.Normal3f)( CC, nx, ny, nz );
#endif
}
void APIENTRY glNormal3i( GLint nx, GLint ny, GLint nz )
{
GET_CONTEXT;
(*CC->API.Normal3f)( CC, INT_TO_FLOAT(nx),
INT_TO_FLOAT(ny), INT_TO_FLOAT(nz) );
}
void APIENTRY glNormal3s( GLshort nx, GLshort ny, GLshort nz )
{
GET_CONTEXT;
(*CC->API.Normal3f)( CC, SHORT_TO_FLOAT(nx),
SHORT_TO_FLOAT(ny), SHORT_TO_FLOAT(nz) );
}
void APIENTRY glNormal3bv( const GLbyte *v )
{
GET_CONTEXT;
(*CC->API.Normal3f)( CC, BYTE_TO_FLOAT(v[0]),
BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]) );
}
void APIENTRY glNormal3dv( const GLdouble *v )
{
GLfloat fx, fy, fz;
GET_CONTEXT;
if (ABSD(v[0])<0.00001) fx = 0.0F; else fx = v[0];
if (ABSD(v[1])<0.00001) fy = 0.0F; else fy = v[1];
if (ABSD(v[2])<0.00001) fz = 0.0F; else fz = v[2];
(*CC->API.Normal3f)( CC, fx, fy, fz );
}
void APIENTRY glNormal3fv( const GLfloat *v )
{
GET_CONTEXT;
#ifdef SHORTCUT
if (CC->CompileFlag) {
(*CC->Save.Normal3fv)( CC, v );
}
else {
/* Execute */
GLfloat *n = CC->Current.Normal;
n[0] = v[0];
n[1] = v[1];
n[2] = v[2];
CC->VB->MonoNormal = GL_FALSE;
}
#else
(*CC->API.Normal3fv)( CC, v );
#endif
}
void APIENTRY glNormal3iv( const GLint *v )
{
GET_CONTEXT;
(*CC->API.Normal3f)( CC, INT_TO_FLOAT(v[0]),
INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]) );
}
void APIENTRY glNormal3sv( const GLshort *v )
{
GET_CONTEXT;
(*CC->API.Normal3f)( CC, SHORT_TO_FLOAT(v[0]),
SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]) );
}
void APIENTRY glNormalPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.NormalPointer)(CC, type, stride, ptr);
}
void APIENTRY glOrtho( GLdouble left, GLdouble right,
GLdouble bottom, GLdouble top,
GLdouble nearval, GLdouble farval )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Ortho)(CC, left, right, bottom, top, nearval, farval);
}
void APIENTRY glPassThrough( GLfloat token )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PassThrough)(CC, token);
}
void APIENTRY glPixelMapfv( GLenum map, GLint mapsize, const GLfloat *values )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PixelMapfv)( CC, map, mapsize, values );
}
void APIENTRY glPixelMapuiv( GLenum map, GLint mapsize, const GLuint *values )
{
GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
GLuint i;
GET_CONTEXT;
CHECK_CONTEXT;
if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
for (i=0;i<mapsize;i++) {
fvalues[i] = (GLfloat) values[i];
}
}
else {
for (i=0;i<mapsize;i++) {
fvalues[i] = UINT_TO_FLOAT( values[i] );
}
}
(*CC->API.PixelMapfv)( CC, map, mapsize, fvalues );
}
void APIENTRY glPixelMapusv( GLenum map, GLint mapsize, const GLushort *values )
{
GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
GLuint i;
GET_CONTEXT;
CHECK_CONTEXT;
if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
for (i=0;i<mapsize;i++) {
fvalues[i] = (GLfloat) values[i];
}
}
else {
for (i=0;i<mapsize;i++) {
fvalues[i] = USHORT_TO_FLOAT( values[i] );
}
}
(*CC->API.PixelMapfv)( CC, map, mapsize, fvalues );
}
void APIENTRY glPixelStoref( GLenum pname, GLfloat param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PixelStorei)( CC, pname, (GLint) param );
}
void APIENTRY glPixelStorei( GLenum pname, GLint param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PixelStorei)( CC, pname, param );
}
void APIENTRY glPixelTransferf( GLenum pname, GLfloat param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PixelTransferf)(CC, pname, param);
}
void APIENTRY glPixelTransferi( GLenum pname, GLint param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PixelTransferf)(CC, pname, (GLfloat) param);
}
void APIENTRY glPixelZoom( GLfloat xfactor, GLfloat yfactor )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PixelZoom)(CC, xfactor, yfactor);
}
void APIENTRY glPointSize( GLfloat size )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PointSize)(CC, size);
}
void APIENTRY glPolygonMode( GLenum face, GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PolygonMode)(CC, face, mode);
}
void APIENTRY glPolygonOffset( GLfloat factor, GLfloat units )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PolygonOffset)( CC, factor, units );
}
#ifdef GL_EXT_polygon_offset
void APIENTRY glPolygonOffsetEXT( GLfloat factor, GLfloat bias )
{
glPolygonOffset( factor, bias * DEPTH_SCALE );
}
#endif
void APIENTRY glPolygonStipple( const GLubyte *mask )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PolygonStipple)(CC, mask);
}
void APIENTRY glPopAttrib( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PopAttrib)(CC);
}
void APIENTRY glPopClientAttrib( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PopClientAttrib)(CC);
}
void APIENTRY glPopMatrix( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PopMatrix)( CC );
}
void APIENTRY glPopName( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PopName)(CC);
}
void APIENTRY glPrioritizeTextures( GLsizei n, const GLuint *textures,
const GLclampf *priorities )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PrioritizeTextures)(CC, n, textures, priorities);
}
void APIENTRY glPushMatrix( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PushMatrix)( CC );
}
void APIENTRY glRasterPos2d( GLdouble x, GLdouble y )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
}
void APIENTRY glRasterPos2f( GLfloat x, GLfloat y )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
}
void APIENTRY glRasterPos2i( GLint x, GLint y )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
}
void APIENTRY glRasterPos2s( GLshort x, GLshort y )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
}
void APIENTRY glRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
}
void APIENTRY glRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
}
void APIENTRY glRasterPos3i( GLint x, GLint y, GLint z )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
}
void APIENTRY glRasterPos3s( GLshort x, GLshort y, GLshort z )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
}
void APIENTRY glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y,
(GLfloat) z, (GLfloat) w );
}
void APIENTRY glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, x, y, z, w );
}
void APIENTRY glRasterPos4i( GLint x, GLint y, GLint z, GLint w )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y,
(GLfloat) z, (GLfloat) w );
}
void APIENTRY glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y,
(GLfloat) z, (GLfloat) w );
}
void APIENTRY glRasterPos2dv( const GLdouble *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
}
void APIENTRY glRasterPos2fv( const GLfloat *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
}
void APIENTRY glRasterPos2iv( const GLint *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
}
void APIENTRY glRasterPos2sv( const GLshort *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
}
/*** 3 element vector ***/
void APIENTRY glRasterPos3dv( const GLdouble *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], 1.0F );
}
void APIENTRY glRasterPos3fv( const GLfloat *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], 1.0F );
}
void APIENTRY glRasterPos3iv( const GLint *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], 1.0F );
}
void APIENTRY glRasterPos3sv( const GLshort *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], 1.0F );
}
void APIENTRY glRasterPos4dv( const GLdouble *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], (GLfloat) v[3] );
}
void APIENTRY glRasterPos4fv( const GLfloat *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, v[0], v[1], v[2], v[3] );
}
void APIENTRY glRasterPos4iv( const GLint *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], (GLfloat) v[3] );
}
void APIENTRY glRasterPos4sv( const GLshort *v )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], (GLfloat) v[3] );
}
void APIENTRY glReadBuffer( GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ReadBuffer)( CC, mode );
}
void APIENTRY glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type, GLvoid *pixels )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ReadPixels)( CC, x, y, width, height, format, type, pixels );
}
void APIENTRY glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Rectf)( CC, (GLfloat) x1, (GLfloat) y1,
(GLfloat) x2, (GLfloat) y2 );
}
void APIENTRY glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Rectf)( CC, x1, y1, x2, y2 );
}
void APIENTRY glRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Rectf)( CC, (GLfloat) x1, (GLfloat) y1,
(GLfloat) x2, (GLfloat) y2 );
}
void APIENTRY glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Rectf)( CC, (GLfloat) x1, (GLfloat) y1,
(GLfloat) x2, (GLfloat) y2 );
}
void APIENTRY glRectdv( const GLdouble *v1, const GLdouble *v2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Rectf)(CC, (GLfloat) v1[0], (GLfloat) v1[1],
(GLfloat) v2[0], (GLfloat) v2[1]);
}
void APIENTRY glRectfv( const GLfloat *v1, const GLfloat *v2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Rectf)(CC, v1[0], v1[1], v2[0], v2[1]);
}
void APIENTRY glRectiv( const GLint *v1, const GLint *v2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Rectf)( CC, (GLfloat) v1[0], (GLfloat) v1[1],
(GLfloat) v2[0], (GLfloat) v2[1] );
}
void APIENTRY glRectsv( const GLshort *v1, const GLshort *v2 )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Rectf)(CC, (GLfloat) v1[0], (GLfloat) v1[1],
(GLfloat) v2[0], (GLfloat) v2[1]);
}
void APIENTRY glScissor( GLint x, GLint y, GLsizei width, GLsizei height)
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Scissor)(CC, x, y, width, height);
}
GLboolean APIENTRY glIsEnabled( GLenum cap )
{
GET_CONTEXT;
CHECK_CONTEXT_RETURN(GL_FALSE);
return (*CC->API.IsEnabled)( CC, cap );
}
void APIENTRY glPushAttrib( GLbitfield mask )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PushAttrib)(CC, mask);
}
void APIENTRY glPushClientAttrib( GLbitfield mask )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PushClientAttrib)(CC, mask);
}
void APIENTRY glPushName( GLuint name )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.PushName)(CC, name);
}
GLint APIENTRY glRenderMode( GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT_RETURN(0);
return (*CC->API.RenderMode)(CC, mode);
}
void APIENTRY glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Rotatef)( CC, (GLfloat) angle,
(GLfloat) x, (GLfloat) y, (GLfloat) z );
}
void APIENTRY glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Rotatef)( CC, angle, x, y, z );
}
void APIENTRY glSelectBuffer( GLsizei size, GLuint *buffer )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.SelectBuffer)(CC, size, buffer);
}
void APIENTRY glScaled( GLdouble x, GLdouble y, GLdouble z )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Scalef)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
}
void APIENTRY glScalef( GLfloat x, GLfloat y, GLfloat z )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Scalef)( CC, x, y, z );
}
void APIENTRY glShadeModel( GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ShadeModel)(CC, mode);
}
void APIENTRY glStencilFunc( GLenum func, GLint ref, GLuint mask )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.StencilFunc)(CC, func, ref, mask);
}
void APIENTRY glStencilMask( GLuint mask )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.StencilMask)(CC, mask);
}
void APIENTRY glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.StencilOp)(CC, fail, zfail, zpass);
}
void APIENTRY glTexCoord1d( GLdouble s )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) s, 0.0, 0.0, 1.0 );
}
void APIENTRY glTexCoord1f( GLfloat s )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, s, 0.0, 0.0, 1.0 );
}
void APIENTRY glTexCoord1i( GLint s )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) s, 0.0, 0.0, 1.0 );
}
void APIENTRY glTexCoord1s( GLshort s )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) s, 0.0, 0.0, 1.0 );
}
void APIENTRY glTexCoord2d( GLdouble s, GLdouble t )
{
GET_CONTEXT;
(*CC->API.TexCoord2f)( CC, (GLfloat) s, (GLfloat) t );
}
void APIENTRY glTexCoord2f( GLfloat s, GLfloat t )
{
GET_CONTEXT;
(*CC->API.TexCoord2f)( CC, s, t );
}
void APIENTRY glTexCoord2i( GLint s, GLint t )
{
GET_CONTEXT;
(*CC->API.TexCoord2f)( CC, (GLfloat) s, (GLfloat) t );
}
void APIENTRY glTexCoord2s( GLshort s, GLshort t )
{
GET_CONTEXT;
(*CC->API.TexCoord2f)( CC, (GLfloat) s, (GLfloat) t );
}
void APIENTRY glTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t, (GLfloat) r, 1.0 );
}
void APIENTRY glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, s, t, r, 1.0 );
}
void APIENTRY glTexCoord3i( GLint s, GLint t, GLint r )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
(GLfloat) r, 1.0 );
}
void APIENTRY glTexCoord3s( GLshort s, GLshort t, GLshort r )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
(GLfloat) r, 1.0 );
}
void APIENTRY glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
(GLfloat) r, (GLfloat) q );
}
void APIENTRY glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, s, t, r, q );
}
void APIENTRY glTexCoord4i( GLint s, GLint t, GLint r, GLint q )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
(GLfloat) r, (GLfloat) q );
}
void APIENTRY glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
(GLfloat) r, (GLfloat) q );
}
void APIENTRY glTexCoord1dv( const GLdouble *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) *v, 0.0, 0.0, 1.0 );
}
void APIENTRY glTexCoord1fv( const GLfloat *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, *v, 0.0, 0.0, 1.0 );
}
void APIENTRY glTexCoord1iv( const GLint *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, *v, 0.0, 0.0, 1.0 );
}
void APIENTRY glTexCoord1sv( const GLshort *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) *v, 0.0, 0.0, 1.0 );
}
void APIENTRY glTexCoord2dv( const GLdouble *v )
{
GET_CONTEXT;
(*CC->API.TexCoord2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
}
void APIENTRY glTexCoord2fv( const GLfloat *v )
{
GET_CONTEXT;
(*CC->API.TexCoord2f)( CC, v[0], v[1] );
}
void APIENTRY glTexCoord2iv( const GLint *v )
{
GET_CONTEXT;
(*CC->API.TexCoord2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
}
void APIENTRY glTexCoord2sv( const GLshort *v )
{
GET_CONTEXT;
(*CC->API.TexCoord2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
}
void APIENTRY glTexCoord3dv( const GLdouble *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], 1.0 );
}
void APIENTRY glTexCoord3fv( const GLfloat *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, v[0], v[1], v[2], 1.0 );
}
void APIENTRY glTexCoord3iv( const GLint *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], 1.0 );
}
void APIENTRY glTexCoord3sv( const GLshort *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], 1.0 );
}
void APIENTRY glTexCoord4dv( const GLdouble *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], (GLfloat) v[3] );
}
void APIENTRY glTexCoord4fv( const GLfloat *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, v[0], v[1], v[2], v[3] );
}
void APIENTRY glTexCoord4iv( const GLint *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], (GLfloat) v[3] );
}
void APIENTRY glTexCoord4sv( const GLshort *v )
{
GET_CONTEXT;
(*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], (GLfloat) v[3] );
}
void APIENTRY glTexCoordPointer( GLint size, GLenum type, GLsizei stride,
const GLvoid *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexCoordPointer)(CC, size, type, stride, ptr);
}
void APIENTRY glTexGend( GLenum coord, GLenum pname, GLdouble param )
{
GLfloat p = (GLfloat) param;
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexGenfv)( CC, coord, pname, &p );
}
void APIENTRY glTexGenf( GLenum coord, GLenum pname, GLfloat param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexGenfv)( CC, coord, pname, ¶m );
}
void APIENTRY glTexGeni( GLenum coord, GLenum pname, GLint param )
{
GLfloat p = (GLfloat) param;
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexGenfv)( CC, coord, pname, &p );
}
void APIENTRY glTexGendv( GLenum coord, GLenum pname, const GLdouble *params )
{
GLfloat p[4];
GET_CONTEXT;
CHECK_CONTEXT;
p[0] = params[0];
p[1] = params[1];
p[2] = params[2];
p[3] = params[3];
(*CC->API.TexGenfv)( CC, coord, pname, p );
}
void APIENTRY glTexGeniv( GLenum coord, GLenum pname, const GLint *params )
{
GLfloat p[4];
GET_CONTEXT;
CHECK_CONTEXT;
p[0] = params[0];
p[1] = params[1];
p[2] = params[2];
p[3] = params[3];
(*CC->API.TexGenfv)( CC, coord, pname, p );
}
void APIENTRY glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexGenfv)( CC, coord, pname, params );
}
void APIENTRY glTexEnvf( GLenum target, GLenum pname, GLfloat param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexEnvfv)( CC, target, pname, ¶m );
}
void APIENTRY glTexEnvi( GLenum target, GLenum pname, GLint param )
{
GLfloat p[4];
p[0] = (GLfloat) param;
p[1] = p[2] = p[3] = 0.0;
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexEnvfv)( CC, target, pname, p );
}
void APIENTRY glTexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexEnvfv)( CC, target, pname, param );
}
void APIENTRY glTexEnviv( GLenum target, GLenum pname, const GLint *param )
{
GLfloat p[4];
p[0] = INT_TO_FLOAT( param[0] );
p[1] = INT_TO_FLOAT( param[1] );
p[2] = INT_TO_FLOAT( param[2] );
p[3] = INT_TO_FLOAT( param[3] );
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexEnvfv)( CC, target, pname, p );
}
void APIENTRY glTexImage1D( GLenum target, GLint level, GLint internalformat,
GLsizei width, GLint border,
GLenum format, GLenum type, const GLvoid *pixels )
{
struct gl_image *teximage;
GLenum destType;
GET_CONTEXT;
CHECK_CONTEXT;
if (type==GL_UNSIGNED_BYTE) {
destType = GL_UNSIGNED_BYTE;
}
else if (type==GL_BITMAP) {
destType = GL_BITMAP;
}
else {
destType = GL_FLOAT;
}
teximage = gl_unpack_image( CC, width, 1, format, type,
destType, pixels, GL_FALSE );
(*CC->API.TexImage1D)( CC, target, level, internalformat,
width, border, format, type, teximage );
}
void APIENTRY glTexImage2D( GLenum target, GLint level, GLint internalformat,
GLsizei width, GLsizei height, GLint border,
GLenum format, GLenum type, const GLvoid *pixels )
{
struct gl_image *teximage;
GLenum destType;
GET_CONTEXT;
CHECK_CONTEXT;
if (type==GL_UNSIGNED_BYTE) {
destType = GL_UNSIGNED_BYTE;
}
else if (type==GL_BITMAP) {
destType = GL_BITMAP;
}
else {
destType = GL_FLOAT;
}
teximage = gl_unpack_image( CC, width, height, format, type,
destType, pixels, GL_FALSE );
(*CC->API.TexImage2D)( CC, target, level, internalformat,
width, height, border, format, type, teximage );
}
void APIENTRY glTexParameterf( GLenum target, GLenum pname, GLfloat param )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexParameterfv)( CC, target, pname, ¶m );
}
void APIENTRY glTexParameteri( GLenum target, GLenum pname, GLint param )
{
GLfloat fparam[4];
fparam[0] = (GLfloat) param;
fparam[1] = fparam[2] = fparam[3] = 0.0;
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexParameterfv)( CC, target, pname, fparam );
}
void APIENTRY glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexParameterfv)( CC, target, pname, params );
}
void APIENTRY glTexParameteriv( GLenum target, GLenum pname, const GLint *params )
{
GLfloat p[4];
GET_CONTEXT;
CHECK_CONTEXT;
if (pname==GL_TEXTURE_BORDER_COLOR) {
p[0] = INT_TO_FLOAT( params[0] );
p[1] = INT_TO_FLOAT( params[1] );
p[2] = INT_TO_FLOAT( params[2] );
p[3] = INT_TO_FLOAT( params[3] );
}
else {
p[0] = (GLfloat) params[0];
p[1] = (GLfloat) params[1];
p[2] = (GLfloat) params[2];
p[3] = (GLfloat) params[3];
}
(*CC->API.TexParameterfv)( CC, target, pname, p );
}
void APIENTRY glTexSubImage1D( GLenum target, GLint level, GLint xoffset,
GLsizei width, GLenum format,
GLenum type, const GLvoid *pixels )
{
struct gl_image *image;
GET_CONTEXT;
CHECK_CONTEXT;
image = gl_unpack_texsubimage( CC, width, 1, format, type, pixels );
(*CC->API.TexSubImage1D)( CC, target, level, xoffset, width,
format, type, image );
}
void APIENTRY glTexSubImage2D( GLenum target, GLint level,
GLint xoffset, GLint yoffset,
GLsizei width, GLsizei height,
GLenum format, GLenum type,
const GLvoid *pixels )
{
struct gl_image *image;
GET_CONTEXT;
CHECK_CONTEXT;
image = gl_unpack_texsubimage( CC, width, height, format, type, pixels );
(*CC->API.TexSubImage2D)( CC, target, level, xoffset, yoffset,
width, height, format, type, image );
}
void APIENTRY glTranslated( GLdouble x, GLdouble y, GLdouble z )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Translatef)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
}
void APIENTRY glTranslatef( GLfloat x, GLfloat y, GLfloat z )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.Translatef)( CC, x, y, z );
}
void APIENTRY glVertex2d( GLdouble x, GLdouble y )
{
GET_CONTEXT;
(*CC->API.Vertex2f)( CC, (GLfloat) x, (GLfloat) y );
}
void APIENTRY glVertex2f( GLfloat x, GLfloat y )
{
GET_CONTEXT;
(*CC->API.Vertex2f)( CC, x, y );
}
void APIENTRY glVertex2i( GLint x, GLint y )
{
GET_CONTEXT;
(*CC->API.Vertex2f)( CC, (GLfloat) x, (GLfloat) y );
}
void APIENTRY glVertex2s( GLshort x, GLshort y )
{
GET_CONTEXT;
(*CC->API.Vertex2f)( CC, (GLfloat) x, (GLfloat) y );
}
void APIENTRY glVertex3d( GLdouble x, GLdouble y, GLdouble z )
{
GET_CONTEXT;
(*CC->API.Vertex3f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
}
void APIENTRY glVertex3f( GLfloat x, GLfloat y, GLfloat z )
{
GET_CONTEXT;
(*CC->API.Vertex3f)( CC, x, y, z );
}
void APIENTRY glVertex3i( GLint x, GLint y, GLint z )
{
GET_CONTEXT;
(*CC->API.Vertex3f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
}
void APIENTRY glVertex3s( GLshort x, GLshort y, GLshort z )
{
GET_CONTEXT;
(*CC->API.Vertex3f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
}
void APIENTRY glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
GET_CONTEXT;
(*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y,
(GLfloat) z, (GLfloat) w );
}
void APIENTRY glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
GET_CONTEXT;
(*CC->API.Vertex4f)( CC, x, y, z, w );
}
void APIENTRY glVertex4i( GLint x, GLint y, GLint z, GLint w )
{
GET_CONTEXT;
(*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y,
(GLfloat) z, (GLfloat) w );
}
void APIENTRY glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
{
GET_CONTEXT;
(*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y,
(GLfloat) z, (GLfloat) w );
}
void APIENTRY glVertex2dv( const GLdouble *v )
{
GET_CONTEXT;
(*CC->API.Vertex2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
}
void APIENTRY glVertex2fv( const GLfloat *v )
{
GET_CONTEXT;
(*CC->API.Vertex2f)( CC, v[0], v[1] );
}
void APIENTRY glVertex2iv( const GLint *v )
{
GET_CONTEXT;
(*CC->API.Vertex2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
}
void APIENTRY glVertex2sv( const GLshort *v )
{
GET_CONTEXT;
(*CC->API.Vertex2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
}
void APIENTRY glVertex3dv( const GLdouble *v )
{
GET_CONTEXT;
(*CC->API.Vertex3f)( CC, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
}
void APIENTRY glVertex3fv( const GLfloat *v )
{
GET_CONTEXT;
(*CC->API.Vertex3fv)( CC, v );
}
void APIENTRY glVertex3iv( const GLint *v )
{
GET_CONTEXT;
(*CC->API.Vertex3f)( CC, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
}
void APIENTRY glVertex3sv( const GLshort *v )
{
GET_CONTEXT;
(*CC->API.Vertex3f)( CC, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
}
void APIENTRY glVertex4dv( const GLdouble *v )
{
GET_CONTEXT;
(*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], (GLfloat) v[3] );
}
void APIENTRY glVertex4fv( const GLfloat *v )
{
GET_CONTEXT;
(*CC->API.Vertex4f)( CC, v[0], v[1], v[2], v[3] );
}
void APIENTRY glVertex4iv( const GLint *v )
{
GET_CONTEXT;
(*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], (GLfloat) v[3] );
}
void APIENTRY glVertex4sv( const GLshort *v )
{
GET_CONTEXT;
(*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
(GLfloat) v[2], (GLfloat) v[3] );
}
void APIENTRY glVertexPointer( GLint size, GLenum type, GLsizei stride,
const GLvoid *ptr )
{
GET_CONTEXT;
(*CC->API.VertexPointer)(CC, size, type, stride, ptr);
}
void APIENTRY glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
{
GET_CONTEXT;
(*CC->API.Viewport)( CC, x, y, width, height );
}
/**
** Extensions
**
** Some of these are incorporated into the 1.1 API. They also remain as
** extensions for backward compatibility. May be removed in the future.
**/
/* GL_EXT_blend_minmax */
void APIENTRY glBlendEquationEXT( GLenum mode )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.BlendEquation)(CC, mode);
}
/* GL_EXT_blend_color */
void APIENTRY glBlendColorEXT( GLclampf red, GLclampf green,
GLclampf blue, GLclampf alpha )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.BlendColor)(CC, red, green, blue, alpha);
}
/* GL_EXT_vertex_array */
void APIENTRY glVertexPointerEXT( GLint size, GLenum type, GLsizei stride,
GLsizei count, const GLvoid *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.VertexPointer)(CC, size, type, stride, ptr);
}
void APIENTRY glNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count,
const GLvoid *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.NormalPointer)(CC, type, stride, ptr);
}
void APIENTRY glColorPointerEXT( GLint size, GLenum type, GLsizei stride,
GLsizei count, const GLvoid *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ColorPointer)(CC, size, type, stride, ptr);
}
void APIENTRY glIndexPointerEXT( GLenum type, GLsizei stride,
GLsizei count, const GLvoid *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.IndexPointer)(CC, type, stride, ptr);
}
void APIENTRY glTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride,
GLsizei count, const GLvoid *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.TexCoordPointer)(CC, size, type, stride, ptr);
}
void APIENTRY glEdgeFlagPointerEXT( GLsizei stride, GLsizei count,
const GLboolean *ptr )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.EdgeFlagPointer)(CC, stride, ptr);
}
void APIENTRY glGetPointervEXT( GLenum pname, GLvoid **params )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.GetPointerv)(CC, pname, params);
}
void APIENTRY glArrayElementEXT( GLint i )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ArrayElement)(CC, i);
}
void APIENTRY glDrawArraysEXT( GLenum mode, GLint first, GLsizei count )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.DrawArrays)(CC, mode, first, count);
}
/* GL_EXT_texture_object */
GLboolean glAreTexturesResidentEXT( GLsizei n, const GLuint *textures,
GLboolean *residences )
{
return glAreTexturesResident( n, textures, residences );
}
void APIENTRY glBindTextureEXT( GLenum target, GLuint texture )
{
glBindTexture( target, texture );
}
void APIENTRY glDeleteTexturesEXT( GLsizei n, const GLuint *textures)
{
glDeleteTextures( n, textures );
}
void APIENTRY glGenTexturesEXT( GLsizei n, GLuint *textures )
{
glGenTextures( n, textures );
}
GLboolean glIsTextureEXT( GLuint texture )
{
return glIsTexture( texture );
}
void APIENTRY glPrioritizeTexturesEXT( GLsizei n, const GLuint *textures,
const GLclampf *priorities )
{
glPrioritizeTextures( n, textures, priorities );
}
/* GL_EXT_texture3D */
void APIENTRY glCopyTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset,
GLint yoffset, GLint zoffset,
GLint x, GLint y, GLsizei width,
GLsizei height )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.CopyTexSubImage3DEXT)( CC, target, level, xoffset, yoffset,
zoffset, x, y, width, height );
}
void APIENTRY glTexImage3DEXT( GLenum target, GLint level, GLenum internalformat,
GLsizei width, GLsizei height, GLsizei depth,
GLint border, GLenum format, GLenum type,
const GLvoid *pixels )
{
struct gl_image *teximage;
GLenum destType;
GET_CONTEXT;
CHECK_CONTEXT;
if (type==GL_UNSIGNED_BYTE) {
destType = GL_UNSIGNED_BYTE;
}
else if (type==GL_BITMAP) {
destType = GL_BITMAP;
}
else {
destType = GL_FLOAT;
}
teximage = gl_unpack_image3D( CC, width, height, depth, format, type,
destType, pixels, GL_FALSE );
(*CC->API.TexImage3DEXT)( CC, target, level, internalformat,
width, height, depth, border, format, type,
teximage );
}
void APIENTRY glTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset,
GLint yoffset, GLint zoffset, GLsizei width,
GLsizei height, GLsizei depth, GLenum format,
GLenum type, const GLvoid *pixels )
{
struct gl_image *image;
GET_CONTEXT;
CHECK_CONTEXT;
image = gl_unpack_texsubimage3D( CC, width, height, depth, format, type,
pixels );
(*CC->API.TexSubImage3DEXT)( CC, target, level, xoffset, yoffset, zoffset,
width, height, depth, format, type, image );
}
#ifdef GL_MESA_window_pos
/*
* Mesa implementation of glWindowPos*MESA()
*/
void APIENTRY glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.WindowPos4fMESA)( CC, x, y, z, w );
}
#else
/* Implementation in winpos.c is used */
#endif
void APIENTRY glWindowPos2iMESA( GLint x, GLint y )
{
glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
}
void APIENTRY glWindowPos2sMESA( GLshort x, GLshort y )
{
glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
}
void APIENTRY glWindowPos2fMESA( GLfloat x, GLfloat y )
{
glWindowPos4fMESA( x, y, 0.0F, 1.0F );
}
void APIENTRY glWindowPos2dMESA( GLdouble x, GLdouble y )
{
glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
}
void APIENTRY glWindowPos2ivMESA( const GLint *p )
{
glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], 0.0F, 1.0F );
}
void APIENTRY glWindowPos2svMESA( const GLshort *p )
{
glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], 0.0F, 1.0F );
}
void APIENTRY glWindowPos2fvMESA( const GLfloat *p )
{
glWindowPos4fMESA( p[0], p[1], 0.0F, 1.0F );
}
void APIENTRY glWindowPos2dvMESA( const GLdouble *p )
{
glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], 0.0F, 1.0F );
}
void APIENTRY glWindowPos3iMESA( GLint x, GLint y, GLint z )
{
glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
}
void APIENTRY glWindowPos3sMESA( GLshort x, GLshort y, GLshort z )
{
glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
}
void APIENTRY glWindowPos3fMESA( GLfloat x, GLfloat y, GLfloat z )
{
glWindowPos4fMESA( x, y, z, 1.0F );
}
void APIENTRY glWindowPos3dMESA( GLdouble x, GLdouble y, GLdouble z )
{
glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
}
void APIENTRY glWindowPos3ivMESA( const GLint *p )
{
glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], (GLfloat) p[2], 1.0F );
}
void APIENTRY glWindowPos3svMESA( const GLshort *p )
{
glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], (GLfloat) p[2], 1.0F );
}
void APIENTRY glWindowPos3fvMESA( const GLfloat *p )
{
glWindowPos4fMESA( p[0], p[1], p[2], 1.0F );
}
void APIENTRY glWindowPos3dvMESA( const GLdouble *p )
{
glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1], (GLfloat) p[2], 1.0F );
}
void APIENTRY glWindowPos4iMESA( GLint x, GLint y, GLint z, GLint w )
{
glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
}
void APIENTRY glWindowPos4sMESA( GLshort x, GLshort y, GLshort z, GLshort w )
{
glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
}
void APIENTRY glWindowPos4dMESA( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
{
glWindowPos4fMESA( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
}
void APIENTRY glWindowPos4ivMESA( const GLint *p )
{
glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1],
(GLfloat) p[2], (GLfloat) p[3] );
}
void APIENTRY glWindowPos4svMESA( const GLshort *p )
{
glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1],
(GLfloat) p[2], (GLfloat) p[3] );
}
void APIENTRY glWindowPos4fvMESA( const GLfloat *p )
{
glWindowPos4fMESA( p[0], p[1], p[2], p[3] );
}
void APIENTRY glWindowPos4dvMESA( const GLdouble *p )
{
glWindowPos4fMESA( (GLfloat) p[0], (GLfloat) p[1],
(GLfloat) p[2], (GLfloat) p[3] );
}
/* GL_MESA_resize_buffers */
/*
* Called by user application when window has been resized.
*/
void APIENTRY glResizeBuffersMESA( void )
{
GET_CONTEXT;
CHECK_CONTEXT;
(*CC->API.ResizeBuffersMESA)( CC );
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.