glparam.h

涉及windows游戏编程中的一些源码

/********************************************************************************
                    glparam.h (C) 2002 By Adam "Grizzly" Medveczky

             gl commands' parameters' displayer for Microsoft Visual C++ 6.0


            Usage: **** ADD TO THE PROJECT!!!! **** it's not important to #include,
            ^^^^^  but you *MUST* add it with Project->Add To Project->Files !!!

                   Type a GL/GLU/gl extension function and the parameters will show up!
            Only tested on MSVC++ 6.0, but maybe it works on other versions, too...
            Feel free to give it to anybody, but this comment must be remained.

                                                Contact me at [e-mail]
*********************************************************************************/


#ifndef __GLPARAM_H_
#define __GLPARAM_H_

#include <gl/gl.h>
#include <gl/glu.h>

#ifdef this_is_needed_so_dont_modify_it

// gl.h -->

void glAccum (GLenum op, GLfloat value){}
void glAlphaFunc (GLenum func, GLclampf ref){}
GLboolean glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences){ return 0; }
void glArrayElement (GLint i){}
void glBegin (GLenum mode){}
void glBindTexture (GLenum target, GLuint texture){}
void glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap){}
void glBlendFunc (GLenum sfactor, GLenum dfactor){}
void glCallList (GLuint list){}
void glCallLists (GLsizei n, GLenum type, const GLvoid *lists){}
void glClear (GLbitfield mask){}
void glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha){}
void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha){}
void glClearDepth (GLclampd depth){}
void glClearIndex (GLfloat c){}
void glClearStencil (GLint s){}
void glClipPlane (GLenum plane, const GLdouble *equation){}
void glColor3b (GLbyte red, GLbyte green, GLbyte blue){}
void glColor3bv (const GLbyte *v){}
void glColor3d (GLdouble red, GLdouble green, GLdouble blue){}
void glColor3dv (const GLdouble *v){}
void glColor3f (GLfloat red, GLfloat green, GLfloat blue){}
void glColor3fv (const GLfloat *v){}
void glColor3i (GLint red, GLint green, GLint blue){}
void glColor3iv (const GLint *v){}
void glColor3s (GLshort red, GLshort green, GLshort blue){}
void glColor3sv (const GLshort *v){}
void glColor3ub (GLubyte red, GLubyte green, GLubyte blue){}
void glColor3ubv (const GLubyte *v){}
void glColor3ui (GLuint red, GLuint green, GLuint blue){}
void glColor3uiv (const GLuint *v){}
void glColor3us (GLushort red, GLushort green, GLushort blue){}
void glColor3usv (const GLushort *v){}
void glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha){}
void glColor4bv (const GLbyte *v){}
void glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha){}
void glColor4dv (const GLdouble *v){}
void glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha){}
void glColor4fv (const GLfloat *v){}
void glColor4i (GLint red, GLint green, GLint blue, GLint alpha){}
void glColor4iv (const GLint *v){}
void glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha){}
void glColor4sv (const GLshort *v){}
void glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha){}
void glColor4ubv (const GLubyte *v){}
void glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha){}
void glColor4uiv (const GLuint *v){}
void glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha){}
void glColor4usv (const GLushort *v){}
void glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha){}
void glColorMaterial (GLenum face, GLenum mode){}
void glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer){}
void glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type){}
void glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border){}
void glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border){}
void glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width){}
void glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height){}
void glCullFace (GLenum mode){}
void glDeleteLists (GLuint list, GLsizei range){}
void glDeleteTextures (GLsizei n, const GLuint *textures){}
void glDepthFunc (GLenum func){}
void glDepthMask (GLboolean flag){}
void glDepthRange (GLclampd zNear, GLclampd zFar){}
void glDisable (GLenum cap){}
void glDisableClientState (GLenum array){}
void glDrawArrays (GLenum mode, GLint first, GLsizei count){}
void glDrawBuffer (GLenum mode){}
void glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices){}
void glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels){}
void glEdgeFlag (GLboolean flag){}
void glEdgeFlagPointer (GLsizei stride, const GLvoid *pointer){}
void glEdgeFlagv (const GLboolean *flag){}
void glEnable (GLenum cap){}
void glEnableClientState (GLenum array){}
void glEnd (void){}
void glEndList (void){}
void glEvalCoord1d (GLdouble u){}
void glEvalCoord1dv (const GLdouble *u){}
void glEvalCoord1f (GLfloat u){}
void glEvalCoord1fv (const GLfloat *u){}
void glEvalCoord2d (GLdouble u, GLdouble v){}
void glEvalCoord2dv (const GLdouble *u){}
void glEvalCoord2f (GLfloat u, GLfloat v){}
void glEvalCoord2fv (const GLfloat *u){}
void glEvalMesh1 (GLenum mode, GLint i1, GLint i2){}
void glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2){}
void glEvalPoint1 (GLint i){}
void glEvalPoint2 (GLint i, GLint j){}
void glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer){}
void glFinish (void){}
void glFlush (void){}
void glFogf (GLenum pname, GLfloat param){}
void glFogfv (GLenum pname, const GLfloat *params){}
void glFogi (GLenum pname, GLint param){}
void glFogiv (GLenum pname, const GLint *params){}
void glFrontFace (GLenum mode){}
void glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar){}
GLuint glGenLists (GLsizei range){ return 0; }
void glGenTextures (GLsizei n, GLuint *textures){}
void glGetBooleanv (GLenum pname, GLboolean *params){}
void glGetClipPlane (GLenum plane, GLdouble *equation){}
void glGetDoublev (GLenum pname, GLdouble *params){}
GLenum glGetError (void){ return 0; }
void glGetFloatv (GLenum pname, GLfloat *params){}
void glGetIntegerv (GLenum pname, GLint *params){}
void glGetLightfv (GLenum light, GLenum pname, GLfloat *params){}
void glGetLightiv (GLenum light, GLenum pname, GLint *params){}
void glGetMapdv (GLenum target, GLenum query, GLdouble *v){}
void glGetMapfv (GLenum target, GLenum query, GLfloat *v){}
void glGetMapiv (GLenum target, GLenum query, GLint *v){}
void glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params){}
void glGetMaterialiv (GLenum face, GLenum pname, GLint *params){}
void glGetPixelMapfv (GLenum map, GLfloat *values){}
void glGetPixelMapuiv (GLenum map, GLuint *values){}
void glGetPixelMapusv (GLenum map, GLushort *values){}
void glGetPointerv (GLenum pname, GLvoid* *params){}
void glGetPolygonStipple (GLubyte *mask){}
const GLubyte * glGetString (GLenum name){ return 0; }
void glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params){}
void glGetTexEnviv (GLenum target, GLenum pname, GLint *params){}
void glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params){}
void glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params){}
void glGetTexGeniv (GLenum coord, GLenum pname, GLint *params){}
void glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels){}
void glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params){}
void glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params){}
void glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params){}
void glGetTexParameteriv (GLenum target, GLenum pname, GLint *params){}
void glHint (GLenum target, GLenum mode){}
void glIndexMask (GLuint mask){}
void glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer){}
void glIndexd (GLdouble c){}
void glIndexdv (const GLdouble *c){}
void glIndexf (GLfloat c){}
void glIndexfv (const GLfloat *c){}
void glIndexi (GLint c){}
void glIndexiv (const GLint *c){}
void glIndexs (GLshort c){}
void glIndexsv (const GLshort *c){}
void glIndexub (GLubyte c){}
void glIndexubv (const GLubyte *c){}
void glInitNames (void){}
void glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer){}
GLboolean glIsEnabled (GLenum cap){ return 0; }
GLboolean glIsList (GLuint list){ return 0; }
GLboolean glIsTexture (GLuint texture){ return 0; }
void glLightModelf (GLenum pname, GLfloat param){}
void glLightModelfv (GLenum pname, const GLfloat *params){}
void glLightModeli (GLenum pname, GLint param){}
void glLightModeliv (GLenum pname, const GLint *params){}
void glLightf (GLenum light, GLenum pname, GLfloat param){}
void glLightfv (GLenum light, GLenum pname, const GLfloat *params){}
void glLighti (GLenum light, GLenum pname, GLint param){}
void glLightiv (GLenum light, GLenum pname, const GLint *params){}
void glLineStipple (GLint factor, GLushort pattern){}
void glLineWidth (GLfloat width){}
void glListBase (GLuint base){}
void glLoadIdentity (void){}
void glLoadMatrixd (const GLdouble *m){}
void glLoadMatrixf (const GLfloat *m){}
void glLoadName (GLuint name){}
void glLogicOp (GLenum opcode){}
void glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points){}
void glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points){}
void glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points){}
void glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points){}
void glMapGrid1d (GLint un, GLdouble u1, GLdouble u2){}
void glMapGrid1f (GLint un, GLfloat u1, GLfloat u2){}
void glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2){}
void glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2){}
void glMaterialf (GLenum face, GLenum pname, GLfloat param){}
void glMaterialfv (GLenum face, GLenum pname, const GLfloat *params){}
void glMateriali (GLenum face, GLenum pname, GLint param){}
void glMaterialiv (GLenum face, GLenum pname, const GLint *params){}
void glMatrixMode (GLenum mode){}
void glMultMatrixd (const GLdouble *m){}
void glMultMatrixf (const GLfloat *m){}
void glNewList (GLuint list, GLenum mode){}
void glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz){}
void glNormal3bv (const GLbyte *v){}
void glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz){}
void glNormal3dv (const GLdouble *v){}
void glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz){}
void glNormal3fv (const GLfloat *v){}
void glNormal3i (GLint nx, GLint ny, GLint nz){}
void glNormal3iv (const GLint *v){}
void glNormal3s (GLshort nx, GLshort ny, GLshort nz){}
void glNormal3sv (const GLshort *v){}
void glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer){}
void glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar){}
void glPassThrough (GLfloat token){}
void glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values){}
void glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values){}
void glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values){}
void glPixelStoref (GLenum pname, GLfloat param){}
void glPixelStorei (GLenum pname, GLint param){}
void glPixelTransferf (GLenum pname, GLfloat param){}
void glPixelTransferi (GLenum pname, GLint param){}
void glPixelZoom (GLfloat xfactor, GLfloat yfactor){}
void glPointSize (GLfloat size){}
void glPolygonMode (GLenum face, GLenum mode){}
void glPolygonOffset (GLfloat factor, GLfloat units){}
void glPolygonStipple (const GLubyte *mask){}
void glPopAttrib (void){}
void glPopClientAttrib (void){}
void glPopMatrix (void){}
void glPopName (void){}