1537 lines
40 KiB
C
1537 lines
40 KiB
C
/*
|
|
** Copyright 1995-2095, 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.
|
|
*/
|
|
|
|
/* GENERATED FILE: DO NOT EDIT */
|
|
|
|
#include "glslib.h"
|
|
|
|
void glNewList(GLuint list, GLenum mode) {
|
|
fprintf(stderr, "stub_glNewList\n");
|
|
}
|
|
|
|
void glEndList(void) {
|
|
fprintf(stderr, "stub_glEndList\n");
|
|
}
|
|
|
|
void glCallList(GLuint list) {
|
|
fprintf(stderr, "stub_glCallList\n");
|
|
}
|
|
|
|
void glCallLists(GLsizei n, GLenum type, const GLvoid *lists) {
|
|
fprintf(stderr, "stub_glCallLists\n");
|
|
}
|
|
|
|
void glDeleteLists(GLuint list, GLsizei range) {
|
|
fprintf(stderr, "stub_glDeleteLists\n");
|
|
}
|
|
|
|
GLuint glGenLists(GLsizei range) {
|
|
fprintf(stderr, "stub_glGenLists\n");
|
|
return 0;
|
|
}
|
|
|
|
void glListBase(GLuint base) {
|
|
fprintf(stderr, "stub_glListBase\n");
|
|
}
|
|
|
|
void glBegin(GLenum mode) {
|
|
fprintf(stderr, "stub_glBegin\n");
|
|
}
|
|
|
|
void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) {
|
|
fprintf(stderr, "stub_glBitmap\n");
|
|
}
|
|
|
|
void glColor3b(GLbyte red, GLbyte green, GLbyte blue) {
|
|
fprintf(stderr, "stub_glColor3b\n");
|
|
}
|
|
|
|
void glColor3bv(const GLbyte *v) {
|
|
fprintf(stderr, "stub_glColor3bv\n");
|
|
}
|
|
|
|
void glColor3d(GLdouble red, GLdouble green, GLdouble blue) {
|
|
fprintf(stderr, "stub_glColor3d\n");
|
|
}
|
|
|
|
void glColor3dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glColor3dv\n");
|
|
}
|
|
|
|
void glColor3f(GLfloat red, GLfloat green, GLfloat blue) {
|
|
fprintf(stderr, "stub_glColor3f\n");
|
|
}
|
|
|
|
void glColor3fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glColor3fv\n");
|
|
}
|
|
|
|
void glColor3i(GLint red, GLint green, GLint blue) {
|
|
fprintf(stderr, "stub_glColor3i\n");
|
|
}
|
|
|
|
void glColor3iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glColor3iv\n");
|
|
}
|
|
|
|
void glColor3s(GLshort red, GLshort green, GLshort blue) {
|
|
fprintf(stderr, "stub_glColor3s\n");
|
|
}
|
|
|
|
void glColor3sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glColor3sv\n");
|
|
}
|
|
|
|
void glColor3ub(GLubyte red, GLubyte green, GLubyte blue) {
|
|
fprintf(stderr, "stub_glColor3ub\n");
|
|
}
|
|
|
|
void glColor3ubv(const GLubyte *v) {
|
|
fprintf(stderr, "stub_glColor3ubv\n");
|
|
}
|
|
|
|
void glColor3ui(GLuint red, GLuint green, GLuint blue) {
|
|
fprintf(stderr, "stub_glColor3ui\n");
|
|
}
|
|
|
|
void glColor3uiv(const GLuint *v) {
|
|
fprintf(stderr, "stub_glColor3uiv\n");
|
|
}
|
|
|
|
void glColor3us(GLushort red, GLushort green, GLushort blue) {
|
|
fprintf(stderr, "stub_glColor3us\n");
|
|
}
|
|
|
|
void glColor3usv(const GLushort *v) {
|
|
fprintf(stderr, "stub_glColor3usv\n");
|
|
}
|
|
|
|
void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) {
|
|
fprintf(stderr, "stub_glColor4b\n");
|
|
}
|
|
|
|
void glColor4bv(const GLbyte *v) {
|
|
fprintf(stderr, "stub_glColor4bv\n");
|
|
}
|
|
|
|
void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) {
|
|
fprintf(stderr, "stub_glColor4d\n");
|
|
}
|
|
|
|
void glColor4dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glColor4dv\n");
|
|
}
|
|
|
|
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
|
|
fprintf(stderr, "stub_glColor4f\n");
|
|
}
|
|
|
|
void glColor4fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glColor4fv\n");
|
|
}
|
|
|
|
void glColor4i(GLint red, GLint green, GLint blue, GLint alpha) {
|
|
fprintf(stderr, "stub_glColor4i\n");
|
|
}
|
|
|
|
void glColor4iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glColor4iv\n");
|
|
}
|
|
|
|
void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) {
|
|
fprintf(stderr, "stub_glColor4s\n");
|
|
}
|
|
|
|
void glColor4sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glColor4sv\n");
|
|
}
|
|
|
|
void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
|
|
fprintf(stderr, "stub_glColor4ub\n");
|
|
}
|
|
|
|
void glColor4ubv(const GLubyte *v) {
|
|
fprintf(stderr, "stub_glColor4ubv\n");
|
|
}
|
|
|
|
void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) {
|
|
fprintf(stderr, "stub_glColor4ui\n");
|
|
}
|
|
|
|
void glColor4uiv(const GLuint *v) {
|
|
fprintf(stderr, "stub_glColor4uiv\n");
|
|
}
|
|
|
|
void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) {
|
|
fprintf(stderr, "stub_glColor4us\n");
|
|
}
|
|
|
|
void glColor4usv(const GLushort *v) {
|
|
fprintf(stderr, "stub_glColor4usv\n");
|
|
}
|
|
|
|
void glEdgeFlag(GLboolean flag) {
|
|
fprintf(stderr, "stub_glEdgeFlag\n");
|
|
}
|
|
|
|
void glEdgeFlagv(const GLboolean *flag) {
|
|
fprintf(stderr, "stub_glEdgeFlagv\n");
|
|
}
|
|
|
|
void glEnd(void) {
|
|
fprintf(stderr, "stub_glEnd\n");
|
|
}
|
|
|
|
void glIndexd(GLdouble c) {
|
|
fprintf(stderr, "stub_glIndexd\n");
|
|
}
|
|
|
|
void glIndexdv(const GLdouble *c) {
|
|
fprintf(stderr, "stub_glIndexdv\n");
|
|
}
|
|
|
|
void glIndexf(GLfloat c) {
|
|
fprintf(stderr, "stub_glIndexf\n");
|
|
}
|
|
|
|
void glIndexfv(const GLfloat *c) {
|
|
fprintf(stderr, "stub_glIndexfv\n");
|
|
}
|
|
|
|
void glIndexi(GLint c) {
|
|
fprintf(stderr, "stub_glIndexi\n");
|
|
}
|
|
|
|
void glIndexiv(const GLint *c) {
|
|
fprintf(stderr, "stub_glIndexiv\n");
|
|
}
|
|
|
|
void glIndexs(GLshort c) {
|
|
fprintf(stderr, "stub_glIndexs\n");
|
|
}
|
|
|
|
void glIndexsv(const GLshort *c) {
|
|
fprintf(stderr, "stub_glIndexsv\n");
|
|
}
|
|
|
|
void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) {
|
|
fprintf(stderr, "stub_glNormal3b\n");
|
|
}
|
|
|
|
void glNormal3bv(const GLbyte *v) {
|
|
fprintf(stderr, "stub_glNormal3bv\n");
|
|
}
|
|
|
|
void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) {
|
|
fprintf(stderr, "stub_glNormal3d\n");
|
|
}
|
|
|
|
void glNormal3dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glNormal3dv\n");
|
|
}
|
|
|
|
void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
|
|
fprintf(stderr, "stub_glNormal3f\n");
|
|
}
|
|
|
|
void glNormal3fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glNormal3fv\n");
|
|
}
|
|
|
|
void glNormal3i(GLint nx, GLint ny, GLint nz) {
|
|
fprintf(stderr, "stub_glNormal3i\n");
|
|
}
|
|
|
|
void glNormal3iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glNormal3iv\n");
|
|
}
|
|
|
|
void glNormal3s(GLshort nx, GLshort ny, GLshort nz) {
|
|
fprintf(stderr, "stub_glNormal3s\n");
|
|
}
|
|
|
|
void glNormal3sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glNormal3sv\n");
|
|
}
|
|
|
|
void glRasterPos2d(GLdouble x, GLdouble y) {
|
|
fprintf(stderr, "stub_glRasterPos2d\n");
|
|
}
|
|
|
|
void glRasterPos2dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glRasterPos2dv\n");
|
|
}
|
|
|
|
void glRasterPos2f(GLfloat x, GLfloat y) {
|
|
fprintf(stderr, "stub_glRasterPos2f\n");
|
|
}
|
|
|
|
void glRasterPos2fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glRasterPos2fv\n");
|
|
}
|
|
|
|
void glRasterPos2i(GLint x, GLint y) {
|
|
fprintf(stderr, "stub_glRasterPos2i\n");
|
|
}
|
|
|
|
void glRasterPos2iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glRasterPos2iv\n");
|
|
}
|
|
|
|
void glRasterPos2s(GLshort x, GLshort y) {
|
|
fprintf(stderr, "stub_glRasterPos2s\n");
|
|
}
|
|
|
|
void glRasterPos2sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glRasterPos2sv\n");
|
|
}
|
|
|
|
void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z) {
|
|
fprintf(stderr, "stub_glRasterPos3d\n");
|
|
}
|
|
|
|
void glRasterPos3dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glRasterPos3dv\n");
|
|
}
|
|
|
|
void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) {
|
|
fprintf(stderr, "stub_glRasterPos3f\n");
|
|
}
|
|
|
|
void glRasterPos3fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glRasterPos3fv\n");
|
|
}
|
|
|
|
void glRasterPos3i(GLint x, GLint y, GLint z) {
|
|
fprintf(stderr, "stub_glRasterPos3i\n");
|
|
}
|
|
|
|
void glRasterPos3iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glRasterPos3iv\n");
|
|
}
|
|
|
|
void glRasterPos3s(GLshort x, GLshort y, GLshort z) {
|
|
fprintf(stderr, "stub_glRasterPos3s\n");
|
|
}
|
|
|
|
void glRasterPos3sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glRasterPos3sv\n");
|
|
}
|
|
|
|
void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
|
|
fprintf(stderr, "stub_glRasterPos4d\n");
|
|
}
|
|
|
|
void glRasterPos4dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glRasterPos4dv\n");
|
|
}
|
|
|
|
void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
|
|
fprintf(stderr, "stub_glRasterPos4f\n");
|
|
}
|
|
|
|
void glRasterPos4fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glRasterPos4fv\n");
|
|
}
|
|
|
|
void glRasterPos4i(GLint x, GLint y, GLint z, GLint w) {
|
|
fprintf(stderr, "stub_glRasterPos4i\n");
|
|
}
|
|
|
|
void glRasterPos4iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glRasterPos4iv\n");
|
|
}
|
|
|
|
void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) {
|
|
fprintf(stderr, "stub_glRasterPos4s\n");
|
|
}
|
|
|
|
void glRasterPos4sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glRasterPos4sv\n");
|
|
}
|
|
|
|
void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) {
|
|
fprintf(stderr, "stub_glRectd\n");
|
|
}
|
|
|
|
void glRectdv(const GLdouble *v1, const GLdouble *v2) {
|
|
fprintf(stderr, "stub_glRectdv\n");
|
|
}
|
|
|
|
void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) {
|
|
fprintf(stderr, "stub_glRectf\n");
|
|
}
|
|
|
|
void glRectfv(const GLfloat *v1, const GLfloat *v2) {
|
|
fprintf(stderr, "stub_glRectfv\n");
|
|
}
|
|
|
|
void glRecti(GLint x1, GLint y1, GLint x2, GLint y2) {
|
|
fprintf(stderr, "stub_glRecti\n");
|
|
}
|
|
|
|
void glRectiv(const GLint *v1, const GLint *v2) {
|
|
fprintf(stderr, "stub_glRectiv\n");
|
|
}
|
|
|
|
void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) {
|
|
fprintf(stderr, "stub_glRects\n");
|
|
}
|
|
|
|
void glRectsv(const GLshort *v1, const GLshort *v2) {
|
|
fprintf(stderr, "stub_glRectsv\n");
|
|
}
|
|
|
|
void glTexCoord1d(GLdouble s) {
|
|
fprintf(stderr, "stub_glTexCoord1d\n");
|
|
}
|
|
|
|
void glTexCoord1dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glTexCoord1dv\n");
|
|
}
|
|
|
|
void glTexCoord1f(GLfloat s) {
|
|
fprintf(stderr, "stub_glTexCoord1f\n");
|
|
}
|
|
|
|
void glTexCoord1fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glTexCoord1fv\n");
|
|
}
|
|
|
|
void glTexCoord1i(GLint s) {
|
|
fprintf(stderr, "stub_glTexCoord1i\n");
|
|
}
|
|
|
|
void glTexCoord1iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glTexCoord1iv\n");
|
|
}
|
|
|
|
void glTexCoord1s(GLshort s) {
|
|
fprintf(stderr, "stub_glTexCoord1s\n");
|
|
}
|
|
|
|
void glTexCoord1sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glTexCoord1sv\n");
|
|
}
|
|
|
|
void glTexCoord2d(GLdouble s, GLdouble t) {
|
|
fprintf(stderr, "stub_glTexCoord2d\n");
|
|
}
|
|
|
|
void glTexCoord2dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glTexCoord2dv\n");
|
|
}
|
|
|
|
void glTexCoord2f(GLfloat s, GLfloat t) {
|
|
fprintf(stderr, "stub_glTexCoord2f\n");
|
|
}
|
|
|
|
void glTexCoord2fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glTexCoord2fv\n");
|
|
}
|
|
|
|
void glTexCoord2i(GLint s, GLint t) {
|
|
fprintf(stderr, "stub_glTexCoord2i\n");
|
|
}
|
|
|
|
void glTexCoord2iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glTexCoord2iv\n");
|
|
}
|
|
|
|
void glTexCoord2s(GLshort s, GLshort t) {
|
|
fprintf(stderr, "stub_glTexCoord2s\n");
|
|
}
|
|
|
|
void glTexCoord2sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glTexCoord2sv\n");
|
|
}
|
|
|
|
void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) {
|
|
fprintf(stderr, "stub_glTexCoord3d\n");
|
|
}
|
|
|
|
void glTexCoord3dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glTexCoord3dv\n");
|
|
}
|
|
|
|
void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {
|
|
fprintf(stderr, "stub_glTexCoord3f\n");
|
|
}
|
|
|
|
void glTexCoord3fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glTexCoord3fv\n");
|
|
}
|
|
|
|
void glTexCoord3i(GLint s, GLint t, GLint r) {
|
|
fprintf(stderr, "stub_glTexCoord3i\n");
|
|
}
|
|
|
|
void glTexCoord3iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glTexCoord3iv\n");
|
|
}
|
|
|
|
void glTexCoord3s(GLshort s, GLshort t, GLshort r) {
|
|
fprintf(stderr, "stub_glTexCoord3s\n");
|
|
}
|
|
|
|
void glTexCoord3sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glTexCoord3sv\n");
|
|
}
|
|
|
|
void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
|
|
fprintf(stderr, "stub_glTexCoord4d\n");
|
|
}
|
|
|
|
void glTexCoord4dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glTexCoord4dv\n");
|
|
}
|
|
|
|
void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
|
|
fprintf(stderr, "stub_glTexCoord4f\n");
|
|
}
|
|
|
|
void glTexCoord4fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glTexCoord4fv\n");
|
|
}
|
|
|
|
void glTexCoord4i(GLint s, GLint t, GLint r, GLint q) {
|
|
fprintf(stderr, "stub_glTexCoord4i\n");
|
|
}
|
|
|
|
void glTexCoord4iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glTexCoord4iv\n");
|
|
}
|
|
|
|
void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) {
|
|
fprintf(stderr, "stub_glTexCoord4s\n");
|
|
}
|
|
|
|
void glTexCoord4sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glTexCoord4sv\n");
|
|
}
|
|
|
|
void glVertex2d(GLdouble x, GLdouble y) {
|
|
fprintf(stderr, "stub_glVertex2d\n");
|
|
}
|
|
|
|
void glVertex2dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glVertex2dv\n");
|
|
}
|
|
|
|
void glVertex2f(GLfloat x, GLfloat y) {
|
|
fprintf(stderr, "stub_glVertex2f\n");
|
|
}
|
|
|
|
void glVertex2fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glVertex2fv\n");
|
|
}
|
|
|
|
void glVertex2i(GLint x, GLint y) {
|
|
fprintf(stderr, "stub_glVertex2i\n");
|
|
}
|
|
|
|
void glVertex2iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glVertex2iv\n");
|
|
}
|
|
|
|
void glVertex2s(GLshort x, GLshort y) {
|
|
fprintf(stderr, "stub_glVertex2s\n");
|
|
}
|
|
|
|
void glVertex2sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glVertex2sv\n");
|
|
}
|
|
|
|
void glVertex3d(GLdouble x, GLdouble y, GLdouble z) {
|
|
fprintf(stderr, "stub_glVertex3d\n");
|
|
}
|
|
|
|
void glVertex3dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glVertex3dv\n");
|
|
}
|
|
|
|
void glVertex3f(GLfloat x, GLfloat y, GLfloat z) {
|
|
fprintf(stderr, "stub_glVertex3f\n");
|
|
}
|
|
|
|
void glVertex3fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glVertex3fv\n");
|
|
}
|
|
|
|
void glVertex3i(GLint x, GLint y, GLint z) {
|
|
fprintf(stderr, "stub_glVertex3i\n");
|
|
}
|
|
|
|
void glVertex3iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glVertex3iv\n");
|
|
}
|
|
|
|
void glVertex3s(GLshort x, GLshort y, GLshort z) {
|
|
fprintf(stderr, "stub_glVertex3s\n");
|
|
}
|
|
|
|
void glVertex3sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glVertex3sv\n");
|
|
}
|
|
|
|
void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
|
|
fprintf(stderr, "stub_glVertex4d\n");
|
|
}
|
|
|
|
void glVertex4dv(const GLdouble *v) {
|
|
fprintf(stderr, "stub_glVertex4dv\n");
|
|
}
|
|
|
|
void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
|
|
fprintf(stderr, "stub_glVertex4f\n");
|
|
}
|
|
|
|
void glVertex4fv(const GLfloat *v) {
|
|
fprintf(stderr, "stub_glVertex4fv\n");
|
|
}
|
|
|
|
void glVertex4i(GLint x, GLint y, GLint z, GLint w) {
|
|
fprintf(stderr, "stub_glVertex4i\n");
|
|
}
|
|
|
|
void glVertex4iv(const GLint *v) {
|
|
fprintf(stderr, "stub_glVertex4iv\n");
|
|
}
|
|
|
|
void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) {
|
|
fprintf(stderr, "stub_glVertex4s\n");
|
|
}
|
|
|
|
void glVertex4sv(const GLshort *v) {
|
|
fprintf(stderr, "stub_glVertex4sv\n");
|
|
}
|
|
|
|
void glClipPlane(GLenum plane, const GLdouble *equation) {
|
|
fprintf(stderr, "stub_glClipPlane\n");
|
|
}
|
|
|
|
void glColorMaterial(GLenum face, GLenum mode) {
|
|
fprintf(stderr, "stub_glColorMaterial\n");
|
|
}
|
|
|
|
void glCullFace(GLenum mode) {
|
|
fprintf(stderr, "stub_glCullFace\n");
|
|
}
|
|
|
|
void glFogf(GLenum pname, GLfloat param) {
|
|
fprintf(stderr, "stub_glFogf\n");
|
|
}
|
|
|
|
void glFogfv(GLenum pname, const GLfloat *params) {
|
|
fprintf(stderr, "stub_glFogfv\n");
|
|
}
|
|
|
|
void glFogi(GLenum pname, GLint param) {
|
|
fprintf(stderr, "stub_glFogi\n");
|
|
}
|
|
|
|
void glFogiv(GLenum pname, const GLint *params) {
|
|
fprintf(stderr, "stub_glFogiv\n");
|
|
}
|
|
|
|
void glFrontFace(GLenum mode) {
|
|
fprintf(stderr, "stub_glFrontFace\n");
|
|
}
|
|
|
|
void glHint(GLenum target, GLenum mode) {
|
|
fprintf(stderr, "stub_glHint\n");
|
|
}
|
|
|
|
void glLightf(GLenum light, GLenum pname, GLfloat param) {
|
|
fprintf(stderr, "stub_glLightf\n");
|
|
}
|
|
|
|
void glLightfv(GLenum light, GLenum pname, const GLfloat *params) {
|
|
fprintf(stderr, "stub_glLightfv\n");
|
|
}
|
|
|
|
void glLighti(GLenum light, GLenum pname, GLint param) {
|
|
fprintf(stderr, "stub_glLighti\n");
|
|
}
|
|
|
|
void glLightiv(GLenum light, GLenum pname, const GLint *params) {
|
|
fprintf(stderr, "stub_glLightiv\n");
|
|
}
|
|
|
|
void glLightModelf(GLenum pname, GLfloat param) {
|
|
fprintf(stderr, "stub_glLightModelf\n");
|
|
}
|
|
|
|
void glLightModelfv(GLenum pname, const GLfloat *params) {
|
|
fprintf(stderr, "stub_glLightModelfv\n");
|
|
}
|
|
|
|
void glLightModeli(GLenum pname, GLint param) {
|
|
fprintf(stderr, "stub_glLightModeli\n");
|
|
}
|
|
|
|
void glLightModeliv(GLenum pname, const GLint *params) {
|
|
fprintf(stderr, "stub_glLightModeliv\n");
|
|
}
|
|
|
|
void glLineStipple(GLint factor, GLushort pattern) {
|
|
fprintf(stderr, "stub_glLineStipple\n");
|
|
}
|
|
|
|
void glLineWidth(GLfloat width) {
|
|
fprintf(stderr, "stub_glLineWidth\n");
|
|
}
|
|
|
|
void glMaterialf(GLenum face, GLenum pname, GLfloat param) {
|
|
fprintf(stderr, "stub_glMaterialf\n");
|
|
}
|
|
|
|
void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
|
|
fprintf(stderr, "stub_glMaterialfv\n");
|
|
}
|
|
|
|
void glMateriali(GLenum face, GLenum pname, GLint param) {
|
|
fprintf(stderr, "stub_glMateriali\n");
|
|
}
|
|
|
|
void glMaterialiv(GLenum face, GLenum pname, const GLint *params) {
|
|
fprintf(stderr, "stub_glMaterialiv\n");
|
|
}
|
|
|
|
void glPointSize(GLfloat size) {
|
|
fprintf(stderr, "stub_glPointSize\n");
|
|
}
|
|
|
|
void glPolygonMode(GLenum face, GLenum mode) {
|
|
fprintf(stderr, "stub_glPolygonMode\n");
|
|
}
|
|
|
|
void glPolygonStipple(const GLubyte *mask) {
|
|
fprintf(stderr, "stub_glPolygonStipple\n");
|
|
}
|
|
|
|
void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
|
|
fprintf(stderr, "stub_glScissor\n");
|
|
}
|
|
|
|
void glShadeModel(GLenum mode) {
|
|
fprintf(stderr, "stub_glShadeModel\n");
|
|
}
|
|
|
|
void glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
|
|
fprintf(stderr, "stub_glTexParameterf\n");
|
|
}
|
|
|
|
void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) {
|
|
fprintf(stderr, "stub_glTexParameterfv\n");
|
|
}
|
|
|
|
void glTexParameteri(GLenum target, GLenum pname, GLint param) {
|
|
fprintf(stderr, "stub_glTexParameteri\n");
|
|
}
|
|
|
|
void glTexParameteriv(GLenum target, GLenum pname, const GLint *params) {
|
|
fprintf(stderr, "stub_glTexParameteriv\n");
|
|
}
|
|
|
|
void glTexImage1D(GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glTexImage1D\n");
|
|
}
|
|
|
|
void glTexImage2D(GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glTexImage2D\n");
|
|
}
|
|
|
|
void glTexEnvf(GLenum target, GLenum pname, GLfloat param) {
|
|
fprintf(stderr, "stub_glTexEnvf\n");
|
|
}
|
|
|
|
void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {
|
|
fprintf(stderr, "stub_glTexEnvfv\n");
|
|
}
|
|
|
|
void glTexEnvi(GLenum target, GLenum pname, GLint param) {
|
|
fprintf(stderr, "stub_glTexEnvi\n");
|
|
}
|
|
|
|
void glTexEnviv(GLenum target, GLenum pname, const GLint *params) {
|
|
fprintf(stderr, "stub_glTexEnviv\n");
|
|
}
|
|
|
|
void glTexGend(GLenum coord, GLenum pname, GLdouble param) {
|
|
fprintf(stderr, "stub_glTexGend\n");
|
|
}
|
|
|
|
void glTexGendv(GLenum coord, GLenum pname, const GLdouble *params) {
|
|
fprintf(stderr, "stub_glTexGendv\n");
|
|
}
|
|
|
|
void glTexGenf(GLenum coord, GLenum pname, GLfloat param) {
|
|
fprintf(stderr, "stub_glTexGenf\n");
|
|
}
|
|
|
|
void glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) {
|
|
fprintf(stderr, "stub_glTexGenfv\n");
|
|
}
|
|
|
|
void glTexGeni(GLenum coord, GLenum pname, GLint param) {
|
|
fprintf(stderr, "stub_glTexGeni\n");
|
|
}
|
|
|
|
void glTexGeniv(GLenum coord, GLenum pname, const GLint *params) {
|
|
fprintf(stderr, "stub_glTexGeniv\n");
|
|
}
|
|
|
|
void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) {
|
|
fprintf(stderr, "stub_glFeedbackBuffer\n");
|
|
}
|
|
|
|
void glSelectBuffer(GLsizei size, GLuint *buffer) {
|
|
fprintf(stderr, "stub_glSelectBuffer\n");
|
|
}
|
|
|
|
GLint glRenderMode(GLenum mode) {
|
|
fprintf(stderr, "stub_glRenderMode\n");
|
|
return 0;
|
|
}
|
|
|
|
void glInitNames(void) {
|
|
fprintf(stderr, "stub_glInitNames\n");
|
|
}
|
|
|
|
void glLoadName(GLuint name) {
|
|
fprintf(stderr, "stub_glLoadName\n");
|
|
}
|
|
|
|
void glPassThrough(GLfloat token) {
|
|
fprintf(stderr, "stub_glPassThrough\n");
|
|
}
|
|
|
|
void glPopName(void) {
|
|
fprintf(stderr, "stub_glPopName\n");
|
|
}
|
|
|
|
void glPushName(GLuint name) {
|
|
fprintf(stderr, "stub_glPushName\n");
|
|
}
|
|
|
|
void glDrawBuffer(GLenum mode) {
|
|
fprintf(stderr, "stub_glDrawBuffer\n");
|
|
}
|
|
|
|
void glClear(GLbitfield mask) {
|
|
fprintf(stderr, "stub_glClear\n");
|
|
}
|
|
|
|
void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
|
|
fprintf(stderr, "stub_glClearAccum\n");
|
|
}
|
|
|
|
void glClearIndex(GLfloat c) {
|
|
fprintf(stderr, "stub_glClearIndex\n");
|
|
}
|
|
|
|
void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
|
|
fprintf(stderr, "stub_glClearColor\n");
|
|
}
|
|
|
|
void glClearStencil(GLint s) {
|
|
fprintf(stderr, "stub_glClearStencil\n");
|
|
}
|
|
|
|
void glClearDepth(GLclampd depth) {
|
|
fprintf(stderr, "stub_glClearDepth\n");
|
|
}
|
|
|
|
void glStencilMask(GLuint mask) {
|
|
fprintf(stderr, "stub_glStencilMask\n");
|
|
}
|
|
|
|
void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
|
|
fprintf(stderr, "stub_glColorMask\n");
|
|
}
|
|
|
|
void glDepthMask(GLboolean flag) {
|
|
fprintf(stderr, "stub_glDepthMask\n");
|
|
}
|
|
|
|
void glIndexMask(GLuint mask) {
|
|
fprintf(stderr, "stub_glIndexMask\n");
|
|
}
|
|
|
|
void glAccum(GLenum op, GLfloat value) {
|
|
fprintf(stderr, "stub_glAccum\n");
|
|
}
|
|
|
|
void glDisable(GLenum cap) {
|
|
fprintf(stderr, "stub_glDisable\n");
|
|
}
|
|
|
|
void glEnable(GLenum cap) {
|
|
fprintf(stderr, "stub_glEnable\n");
|
|
}
|
|
|
|
void glFinish(void) {
|
|
fprintf(stderr, "stub_glFinish\n");
|
|
}
|
|
|
|
void glFlush(void) {
|
|
fprintf(stderr, "stub_glFlush\n");
|
|
}
|
|
|
|
void glPopAttrib(void) {
|
|
fprintf(stderr, "stub_glPopAttrib\n");
|
|
}
|
|
|
|
void glPushAttrib(GLbitfield mask) {
|
|
fprintf(stderr, "stub_glPushAttrib\n");
|
|
}
|
|
|
|
void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) {
|
|
fprintf(stderr, "stub_glMap1d\n");
|
|
}
|
|
|
|
void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) {
|
|
fprintf(stderr, "stub_glMap1f\n");
|
|
}
|
|
|
|
void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) {
|
|
fprintf(stderr, "stub_glMap2d\n");
|
|
}
|
|
|
|
void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) {
|
|
fprintf(stderr, "stub_glMap2f\n");
|
|
}
|
|
|
|
void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) {
|
|
fprintf(stderr, "stub_glMapGrid1d\n");
|
|
}
|
|
|
|
void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) {
|
|
fprintf(stderr, "stub_glMapGrid1f\n");
|
|
}
|
|
|
|
void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) {
|
|
fprintf(stderr, "stub_glMapGrid2d\n");
|
|
}
|
|
|
|
void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) {
|
|
fprintf(stderr, "stub_glMapGrid2f\n");
|
|
}
|
|
|
|
void glEvalCoord1d(GLdouble u) {
|
|
fprintf(stderr, "stub_glEvalCoord1d\n");
|
|
}
|
|
|
|
void glEvalCoord1dv(const GLdouble *u) {
|
|
fprintf(stderr, "stub_glEvalCoord1dv\n");
|
|
}
|
|
|
|
void glEvalCoord1f(GLfloat u) {
|
|
fprintf(stderr, "stub_glEvalCoord1f\n");
|
|
}
|
|
|
|
void glEvalCoord1fv(const GLfloat *u) {
|
|
fprintf(stderr, "stub_glEvalCoord1fv\n");
|
|
}
|
|
|
|
void glEvalCoord2d(GLdouble u, GLdouble v) {
|
|
fprintf(stderr, "stub_glEvalCoord2d\n");
|
|
}
|
|
|
|
void glEvalCoord2dv(const GLdouble *u) {
|
|
fprintf(stderr, "stub_glEvalCoord2dv\n");
|
|
}
|
|
|
|
void glEvalCoord2f(GLfloat u, GLfloat v) {
|
|
fprintf(stderr, "stub_glEvalCoord2f\n");
|
|
}
|
|
|
|
void glEvalCoord2fv(const GLfloat *u) {
|
|
fprintf(stderr, "stub_glEvalCoord2fv\n");
|
|
}
|
|
|
|
void glEvalMesh1(GLenum mode, GLint i1, GLint i2) {
|
|
fprintf(stderr, "stub_glEvalMesh1\n");
|
|
}
|
|
|
|
void glEvalPoint1(GLint i) {
|
|
fprintf(stderr, "stub_glEvalPoint1\n");
|
|
}
|
|
|
|
void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) {
|
|
fprintf(stderr, "stub_glEvalMesh2\n");
|
|
}
|
|
|
|
void glEvalPoint2(GLint i, GLint j) {
|
|
fprintf(stderr, "stub_glEvalPoint2\n");
|
|
}
|
|
|
|
void glAlphaFunc(GLenum func, GLclampf ref) {
|
|
fprintf(stderr, "stub_glAlphaFunc\n");
|
|
}
|
|
|
|
void glBlendFunc(GLenum sfactor, GLenum dfactor) {
|
|
fprintf(stderr, "stub_glBlendFunc\n");
|
|
}
|
|
|
|
void glLogicOp(GLenum opcode) {
|
|
fprintf(stderr, "stub_glLogicOp\n");
|
|
}
|
|
|
|
void glStencilFunc(GLenum func, GLint ref, GLuint mask) {
|
|
fprintf(stderr, "stub_glStencilFunc\n");
|
|
}
|
|
|
|
void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
|
|
fprintf(stderr, "stub_glStencilOp\n");
|
|
}
|
|
|
|
void glDepthFunc(GLenum func) {
|
|
fprintf(stderr, "stub_glDepthFunc\n");
|
|
}
|
|
|
|
void glPixelZoom(GLfloat xfactor, GLfloat yfactor) {
|
|
fprintf(stderr, "stub_glPixelZoom\n");
|
|
}
|
|
|
|
void glPixelTransferf(GLenum pname, GLfloat param) {
|
|
fprintf(stderr, "stub_glPixelTransferf\n");
|
|
}
|
|
|
|
void glPixelTransferi(GLenum pname, GLint param) {
|
|
fprintf(stderr, "stub_glPixelTransferi\n");
|
|
}
|
|
|
|
void glPixelStoref(GLenum pname, GLfloat param) {
|
|
fprintf(stderr, "stub_glPixelStoref\n");
|
|
}
|
|
|
|
void glPixelStorei(GLenum pname, GLint param) {
|
|
fprintf(stderr, "stub_glPixelStorei\n");
|
|
}
|
|
|
|
void glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values) {
|
|
fprintf(stderr, "stub_glPixelMapfv\n");
|
|
}
|
|
|
|
void glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values) {
|
|
fprintf(stderr, "stub_glPixelMapuiv\n");
|
|
}
|
|
|
|
void glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values) {
|
|
fprintf(stderr, "stub_glPixelMapusv\n");
|
|
}
|
|
|
|
void glReadBuffer(GLenum mode) {
|
|
fprintf(stderr, "stub_glReadBuffer\n");
|
|
}
|
|
|
|
void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) {
|
|
fprintf(stderr, "stub_glCopyPixels\n");
|
|
}
|
|
|
|
void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glReadPixels\n");
|
|
}
|
|
|
|
void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glDrawPixels\n");
|
|
}
|
|
|
|
void glGetBooleanv(GLenum pname, GLboolean *params) {
|
|
fprintf(stderr, "stub_glGetBooleanv\n");
|
|
}
|
|
|
|
void glGetClipPlane(GLenum plane, GLdouble *equation) {
|
|
fprintf(stderr, "stub_glGetClipPlane\n");
|
|
}
|
|
|
|
void glGetDoublev(GLenum pname, GLdouble *params) {
|
|
fprintf(stderr, "stub_glGetDoublev\n");
|
|
}
|
|
|
|
GLenum glGetError(void) {
|
|
fprintf(stderr, "stub_glGetError\n");
|
|
return 0;
|
|
}
|
|
|
|
void glGetFloatv(GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetFloatv\n");
|
|
}
|
|
|
|
void glGetIntegerv(GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetIntegerv\n");
|
|
}
|
|
|
|
void glGetLightfv(GLenum light, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetLightfv\n");
|
|
}
|
|
|
|
void glGetLightiv(GLenum light, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetLightiv\n");
|
|
}
|
|
|
|
void glGetMapdv(GLenum target, GLenum query, GLdouble *v) {
|
|
fprintf(stderr, "stub_glGetMapdv\n");
|
|
}
|
|
|
|
void glGetMapfv(GLenum target, GLenum query, GLfloat *v) {
|
|
fprintf(stderr, "stub_glGetMapfv\n");
|
|
}
|
|
|
|
void glGetMapiv(GLenum target, GLenum query, GLint *v) {
|
|
fprintf(stderr, "stub_glGetMapiv\n");
|
|
}
|
|
|
|
void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetMaterialfv\n");
|
|
}
|
|
|
|
void glGetMaterialiv(GLenum face, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetMaterialiv\n");
|
|
}
|
|
|
|
void glGetPixelMapfv(GLenum map, GLfloat *values) {
|
|
fprintf(stderr, "stub_glGetPixelMapfv\n");
|
|
}
|
|
|
|
void glGetPixelMapuiv(GLenum map, GLuint *values) {
|
|
fprintf(stderr, "stub_glGetPixelMapuiv\n");
|
|
}
|
|
|
|
void glGetPixelMapusv(GLenum map, GLushort *values) {
|
|
fprintf(stderr, "stub_glGetPixelMapusv\n");
|
|
}
|
|
|
|
void glGetPolygonStipple(GLubyte *mask) {
|
|
fprintf(stderr, "stub_glGetPolygonStipple\n");
|
|
}
|
|
|
|
const GLubyte * glGetString(GLenum name) {
|
|
fprintf(stderr, "stub_glGetString\n");
|
|
return 0;
|
|
}
|
|
|
|
void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetTexEnvfv\n");
|
|
}
|
|
|
|
void glGetTexEnviv(GLenum target, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetTexEnviv\n");
|
|
}
|
|
|
|
void glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) {
|
|
fprintf(stderr, "stub_glGetTexGendv\n");
|
|
}
|
|
|
|
void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetTexGenfv\n");
|
|
}
|
|
|
|
void glGetTexGeniv(GLenum coord, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetTexGeniv\n");
|
|
}
|
|
|
|
void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glGetTexImage\n");
|
|
}
|
|
|
|
void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetTexParameterfv\n");
|
|
}
|
|
|
|
void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetTexParameteriv\n");
|
|
}
|
|
|
|
void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetTexLevelParameterfv\n");
|
|
}
|
|
|
|
void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetTexLevelParameteriv\n");
|
|
}
|
|
|
|
GLboolean glIsEnabled(GLenum cap) {
|
|
fprintf(stderr, "stub_glIsEnabled\n");
|
|
return 0;
|
|
}
|
|
|
|
GLboolean glIsList(GLuint list) {
|
|
fprintf(stderr, "stub_glIsList\n");
|
|
return 0;
|
|
}
|
|
|
|
void glDepthRange(GLclampd zNear, GLclampd zFar) {
|
|
fprintf(stderr, "stub_glDepthRange\n");
|
|
}
|
|
|
|
void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {
|
|
fprintf(stderr, "stub_glFrustum\n");
|
|
}
|
|
|
|
void glLoadIdentity(void) {
|
|
fprintf(stderr, "stub_glLoadIdentity\n");
|
|
}
|
|
|
|
void glLoadMatrixf(const GLfloat *m) {
|
|
fprintf(stderr, "stub_glLoadMatrixf\n");
|
|
}
|
|
|
|
void glLoadMatrixd(const GLdouble *m) {
|
|
fprintf(stderr, "stub_glLoadMatrixd\n");
|
|
}
|
|
|
|
void glMatrixMode(GLenum mode) {
|
|
fprintf(stderr, "stub_glMatrixMode\n");
|
|
}
|
|
|
|
void glMultMatrixf(const GLfloat *m) {
|
|
fprintf(stderr, "stub_glMultMatrixf\n");
|
|
}
|
|
|
|
void glMultMatrixd(const GLdouble *m) {
|
|
fprintf(stderr, "stub_glMultMatrixd\n");
|
|
}
|
|
|
|
void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {
|
|
fprintf(stderr, "stub_glOrtho\n");
|
|
}
|
|
|
|
void glPopMatrix(void) {
|
|
fprintf(stderr, "stub_glPopMatrix\n");
|
|
}
|
|
|
|
void glPushMatrix(void) {
|
|
fprintf(stderr, "stub_glPushMatrix\n");
|
|
}
|
|
|
|
void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) {
|
|
fprintf(stderr, "stub_glRotated\n");
|
|
}
|
|
|
|
void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
|
|
fprintf(stderr, "stub_glRotatef\n");
|
|
}
|
|
|
|
void glScaled(GLdouble x, GLdouble y, GLdouble z) {
|
|
fprintf(stderr, "stub_glScaled\n");
|
|
}
|
|
|
|
void glScalef(GLfloat x, GLfloat y, GLfloat z) {
|
|
fprintf(stderr, "stub_glScalef\n");
|
|
}
|
|
|
|
void glTranslated(GLdouble x, GLdouble y, GLdouble z) {
|
|
fprintf(stderr, "stub_glTranslated\n");
|
|
}
|
|
|
|
void glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
|
|
fprintf(stderr, "stub_glTranslatef\n");
|
|
}
|
|
|
|
void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
|
|
fprintf(stderr, "stub_glViewport\n");
|
|
}
|
|
|
|
void glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
|
|
fprintf(stderr, "stub_glBlendColorEXT\n");
|
|
}
|
|
|
|
void glBlendEquationEXT(GLenum mode) {
|
|
fprintf(stderr, "stub_glBlendEquationEXT\n");
|
|
}
|
|
|
|
void glPolygonOffsetEXT(GLfloat factor, GLfloat bias) {
|
|
fprintf(stderr, "stub_glPolygonOffsetEXT\n");
|
|
}
|
|
|
|
void glTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glTexSubImage1DEXT\n");
|
|
}
|
|
|
|
void glTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glTexSubImage2DEXT\n");
|
|
}
|
|
|
|
void glSampleMaskSGIS(GLclampf value, GLboolean invert) {
|
|
fprintf(stderr, "stub_glSampleMaskSGIS\n");
|
|
}
|
|
|
|
void glSamplePatternSGIS(GLenum pattern) {
|
|
fprintf(stderr, "stub_glSamplePatternSGIS\n");
|
|
}
|
|
|
|
void glTagSampleBufferSGIX(void) {
|
|
fprintf(stderr, "stub_glTagSampleBufferSGIX\n");
|
|
}
|
|
|
|
void glConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image) {
|
|
fprintf(stderr, "stub_glConvolutionFilter1DEXT\n");
|
|
}
|
|
|
|
void glConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image) {
|
|
fprintf(stderr, "stub_glConvolutionFilter2DEXT\n");
|
|
}
|
|
|
|
void glConvolutionParameterfEXT(GLenum target, GLenum pname, GLfloat params) {
|
|
fprintf(stderr, "stub_glConvolutionParameterfEXT\n");
|
|
}
|
|
|
|
void glConvolutionParameterfvEXT(GLenum target, GLenum pname, const GLfloat *params) {
|
|
fprintf(stderr, "stub_glConvolutionParameterfvEXT\n");
|
|
}
|
|
|
|
void glConvolutionParameteriEXT(GLenum target, GLenum pname, GLint params) {
|
|
fprintf(stderr, "stub_glConvolutionParameteriEXT\n");
|
|
}
|
|
|
|
void glConvolutionParameterivEXT(GLenum target, GLenum pname, const GLint *params) {
|
|
fprintf(stderr, "stub_glConvolutionParameterivEXT\n");
|
|
}
|
|
|
|
void glCopyConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {
|
|
fprintf(stderr, "stub_glCopyConvolutionFilter1DEXT\n");
|
|
}
|
|
|
|
void glCopyConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) {
|
|
fprintf(stderr, "stub_glCopyConvolutionFilter2DEXT\n");
|
|
}
|
|
|
|
void glGetConvolutionFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid *image) {
|
|
fprintf(stderr, "stub_glGetConvolutionFilterEXT\n");
|
|
}
|
|
|
|
void glGetConvolutionParameterfvEXT(GLenum target, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetConvolutionParameterfvEXT\n");
|
|
}
|
|
|
|
void glGetConvolutionParameterivEXT(GLenum target, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetConvolutionParameterivEXT\n");
|
|
}
|
|
|
|
void glGetSeparableFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span) {
|
|
fprintf(stderr, "stub_glGetSeparableFilterEXT\n");
|
|
}
|
|
|
|
void glSeparableFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column) {
|
|
fprintf(stderr, "stub_glSeparableFilter2DEXT\n");
|
|
}
|
|
|
|
void glGetHistogramEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) {
|
|
fprintf(stderr, "stub_glGetHistogramEXT\n");
|
|
}
|
|
|
|
void glGetHistogramParameterfvEXT(GLenum target, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetHistogramParameterfvEXT\n");
|
|
}
|
|
|
|
void glGetHistogramParameterivEXT(GLenum target, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetHistogramParameterivEXT\n");
|
|
}
|
|
|
|
void glGetMinmaxEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) {
|
|
fprintf(stderr, "stub_glGetMinmaxEXT\n");
|
|
}
|
|
|
|
void glGetMinmaxParameterfvEXT(GLenum target, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetMinmaxParameterfvEXT\n");
|
|
}
|
|
|
|
void glGetMinmaxParameterivEXT(GLenum target, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetMinmaxParameterivEXT\n");
|
|
}
|
|
|
|
void glHistogramEXT(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) {
|
|
fprintf(stderr, "stub_glHistogramEXT\n");
|
|
}
|
|
|
|
void glMinmaxEXT(GLenum target, GLenum internalformat, GLboolean sink) {
|
|
fprintf(stderr, "stub_glMinmaxEXT\n");
|
|
}
|
|
|
|
void glResetHistogramEXT(GLenum target) {
|
|
fprintf(stderr, "stub_glResetHistogramEXT\n");
|
|
}
|
|
|
|
void glResetMinmaxEXT(GLenum target) {
|
|
fprintf(stderr, "stub_glResetMinmaxEXT\n");
|
|
}
|
|
|
|
void glTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glTexImage3DEXT\n");
|
|
}
|
|
|
|
void glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glTexSubImage3DEXT\n");
|
|
}
|
|
|
|
void glDetailTexFuncSGIS(GLenum target, GLsizei n, const GLfloat *points) {
|
|
fprintf(stderr, "stub_glDetailTexFuncSGIS\n");
|
|
}
|
|
|
|
void glGetDetailTexFuncSGIS(GLenum target, GLfloat *points) {
|
|
fprintf(stderr, "stub_glGetDetailTexFuncSGIS\n");
|
|
}
|
|
|
|
void glSharpenTexFuncSGIS(GLenum target, GLsizei n, const GLfloat *points) {
|
|
fprintf(stderr, "stub_glSharpenTexFuncSGIS\n");
|
|
}
|
|
|
|
void glGetSharpenTexFuncSGIS(GLenum target, GLfloat *points) {
|
|
fprintf(stderr, "stub_glGetSharpenTexFuncSGIS\n");
|
|
}
|
|
|
|
void glArrayElementEXT(GLint i) {
|
|
fprintf(stderr, "stub_glArrayElementEXT\n");
|
|
}
|
|
|
|
void glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) {
|
|
fprintf(stderr, "stub_glColorPointerEXT\n");
|
|
}
|
|
|
|
void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count) {
|
|
fprintf(stderr, "stub_glDrawArraysEXT\n");
|
|
}
|
|
|
|
void glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer) {
|
|
fprintf(stderr, "stub_glEdgeFlagPointerEXT\n");
|
|
}
|
|
|
|
void glGetPointervEXT(GLenum pname, GLvoid* *params) {
|
|
fprintf(stderr, "stub_glGetPointervEXT\n");
|
|
}
|
|
|
|
void glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) {
|
|
fprintf(stderr, "stub_glIndexPointerEXT\n");
|
|
}
|
|
|
|
void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) {
|
|
fprintf(stderr, "stub_glNormalPointerEXT\n");
|
|
}
|
|
|
|
void glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) {
|
|
fprintf(stderr, "stub_glTexCoordPointerEXT\n");
|
|
}
|
|
|
|
void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) {
|
|
fprintf(stderr, "stub_glVertexPointerEXT\n");
|
|
}
|
|
|
|
GLboolean glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences) {
|
|
fprintf(stderr, "stub_glAreTexturesResidentEXT\n");
|
|
return 0;
|
|
}
|
|
|
|
void glBindTextureEXT(GLenum target, GLuint texture) {
|
|
fprintf(stderr, "stub_glBindTextureEXT\n");
|
|
}
|
|
|
|
void glDeleteTexturesEXT(GLsizei n, const GLuint *textures) {
|
|
fprintf(stderr, "stub_glDeleteTexturesEXT\n");
|
|
}
|
|
|
|
void glGenTexturesEXT(GLsizei n, GLuint *textures) {
|
|
fprintf(stderr, "stub_glGenTexturesEXT\n");
|
|
}
|
|
|
|
GLboolean glIsTextureEXT(GLuint texture) {
|
|
fprintf(stderr, "stub_glIsTextureEXT\n");
|
|
return 0;
|
|
}
|
|
|
|
void glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities) {
|
|
fprintf(stderr, "stub_glPrioritizeTexturesEXT\n");
|
|
}
|
|
|
|
void glColorTableSGI(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) {
|
|
fprintf(stderr, "stub_glColorTableSGI\n");
|
|
}
|
|
|
|
void glColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat *params) {
|
|
fprintf(stderr, "stub_glColorTableParameterfvSGI\n");
|
|
}
|
|
|
|
void glColorTableParameterivSGI(GLenum target, GLenum pname, const GLint *params) {
|
|
fprintf(stderr, "stub_glColorTableParameterivSGI\n");
|
|
}
|
|
|
|
void glCopyColorTableSGI(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {
|
|
fprintf(stderr, "stub_glCopyColorTableSGI\n");
|
|
}
|
|
|
|
void glGetColorTableSGI(GLenum target, GLenum format, GLenum type, GLvoid *table) {
|
|
fprintf(stderr, "stub_glGetColorTableSGI\n");
|
|
}
|
|
|
|
void glGetColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetColorTableParameterfvSGI\n");
|
|
}
|
|
|
|
void glGetColorTableParameterivSGI(GLenum target, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetColorTableParameterivSGI\n");
|
|
}
|
|
|
|
void glGetTexColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat *params) {
|
|
fprintf(stderr, "stub_glGetTexColorTableParameterfvSGI\n");
|
|
}
|
|
|
|
void glGetTexColorTableParameterivSGI(GLenum target, GLenum pname, GLint *params) {
|
|
fprintf(stderr, "stub_glGetTexColorTableParameterivSGI\n");
|
|
}
|
|
|
|
void glTexColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat *params) {
|
|
fprintf(stderr, "stub_glTexColorTableParameterfvSGI\n");
|
|
}
|
|
|
|
void glTexColorTableParameterivSGI(GLenum target, GLenum pname, const GLint *params) {
|
|
fprintf(stderr, "stub_glTexColorTableParameterivSGI\n");
|
|
}
|
|
|
|
void glCopyTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {
|
|
fprintf(stderr, "stub_glCopyTexImage1DEXT\n");
|
|
}
|
|
|
|
void glCopyTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
|
|
fprintf(stderr, "stub_glCopyTexImage2DEXT\n");
|
|
}
|
|
|
|
void glCopyTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {
|
|
fprintf(stderr, "stub_glCopyTexSubImage1DEXT\n");
|
|
}
|
|
|
|
void glCopyTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
|
|
fprintf(stderr, "stub_glCopyTexSubImage2DEXT\n");
|
|
}
|
|
|
|
void glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
|
|
fprintf(stderr, "stub_glCopyTexSubImage3DEXT\n");
|
|
}
|
|
|
|
void glTexImage4DSGIS(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glTexImage4DSGIS\n");
|
|
}
|
|
|
|
void glTexSubImage4DSGIS(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels) {
|
|
fprintf(stderr, "stub_glTexSubImage4DSGIS\n");
|
|
}
|
|
|
|
void glPixelTexGenSGIX(GLenum mode) {
|
|
fprintf(stderr, "stub_glPixelTexGenSGIX\n");
|
|
}
|