glparam.h

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

    GLboolean           textureCoords){}

void gluQuadricOrientation (
    GLUquadric          *quadObject, 
    GLenum              orientation){}

void gluQuadricDrawStyle (
    GLUquadric          *quadObject, 
    GLenum              drawStyle){}

void gluCylinder (
    GLUquadric          *qobj, 
    GLdouble            baseRadius, 
    GLdouble            topRadius, 
    GLdouble            height, 
    GLint               slices, 
    GLint               stacks){}

void gluDisk (
    GLUquadric          *qobj, 
    GLdouble            innerRadius, 
    GLdouble            outerRadius, 
    GLint               slices, 
    GLint               loops){}

void gluPartialDisk (
    GLUquadric          *qobj, 
    GLdouble            innerRadius, 
    GLdouble            outerRadius, 
    GLint               slices, 
    GLint               loops, 
    GLdouble            startAngle, 
    GLdouble            sweepAngle){}

void gluSphere (
    GLUquadric          *qobj, 
    GLdouble            radius, 
    GLint               slices, 
    GLint               stacks){}

void gluQuadricCallback (
    GLUquadric          *qobj, 
    GLenum              which, 
    void                (CALLBACK* fn)()){}

GLUtesselator*  gluNewTess(          
    void ){ return 0; }

void  gluDeleteTess(       
    GLUtesselator       *tess ){}

void  gluTessBeginPolygon( 
    GLUtesselator       *tess,
    void                *polygon_data ){}

void  gluTessBeginContour( 
    GLUtesselator       *tess ){}

void  gluTessVertex(       
    GLUtesselator       *tess,
    GLdouble            coords[3], 
    void                *data ){}

void  gluTessEndContour(   
    GLUtesselator       *tess ){}

void  gluTessEndPolygon(   
    GLUtesselator       *tess ){}

void  gluTessProperty(     
    GLUtesselator       *tess,
    GLenum              which, 
    GLdouble            value ){}

void  gluTessNormal(       
    GLUtesselator       *tess, 
    GLdouble            x,
    GLdouble            y, 
    GLdouble            z ){}

void  gluTessCallback(     
    GLUtesselator       *tess,
    GLenum              which, 
    void                (CALLBACK *fn)()){}

void  gluGetTessProperty(  
    GLUtesselator       *tess,
    GLenum              which, 
    GLdouble            *value ){}

GLUnurbs* gluNewNurbsRenderer (void){ return 0; }

void gluDeleteNurbsRenderer (
    GLUnurbs            *nobj){}

void gluBeginSurface (
    GLUnurbs            *nobj){}

void gluBeginCurve (
    GLUnurbs            *nobj){}

void gluEndCurve (
    GLUnurbs            *nobj){}

void gluEndSurface (
    GLUnurbs            *nobj){}

void gluBeginTrim (
    GLUnurbs            *nobj){}

void gluEndTrim (
    GLUnurbs            *nobj){}

void gluPwlCurve (
    GLUnurbs            *nobj, 
    GLint               count, 
    GLfloat             *array, 
    GLint               stride, 
    GLenum              type){}

void gluNurbsCurve (
    GLUnurbs            *nobj, 
    GLint               nknots, 
    GLfloat             *knot, 
    GLint               stride, 
    GLfloat             *ctlarray, 
    GLint               order, 
    GLenum              type){}

void 
gluNurbsSurface(     
    GLUnurbs            *nobj, 
    GLint               sknot_count, 
    float               *sknot, 
    GLint               tknot_count, 
    GLfloat             *tknot, 
    GLint               s_stride, 
    GLint               t_stride, 
    GLfloat             *ctlarray, 
    GLint               sorder, 
    GLint               torder, 
    GLenum              type){}

void 
gluLoadSamplingMatrices (
    GLUnurbs            *nobj, 
    const GLfloat       modelMatrix[16], 
    const GLfloat       projMatrix[16], 
    const GLint         viewport[4] ){}

void 
gluNurbsProperty (
    GLUnurbs            *nobj, 
    GLenum              property, 
    GLfloat             value ){}

void 
gluGetNurbsProperty (
    GLUnurbs            *nobj, 
    GLenum              property, 
    GLfloat             *value ){}

void 
gluNurbsCallback (
    GLUnurbs            *nobj, 
    GLenum              which, 
    void                (CALLBACK* fn)() ){}

void   gluBeginPolygon( GLUtesselator *tess ){}

void   gluNextContour(  GLUtesselator *tess, 
                                 GLenum        type ){}

void   gluEndPolygon(   GLUtesselator *tess ){}


// <-- glu.h

// extensions with postfix -->

void glActiveTextureARB(GLenum texture ) {}
void glClientActiveTextureARB(GLenum texture ) {}
void glMultiTexCoord1dARB(GLenum target, GLdouble s ) {}
void glMultiTexCoord1dvARB(GLenum target, const GLdouble *v ) {}
void glMultiTexCoord1fARB(GLenum target, GLfloat s ) {}
void glMultiTexCoord1fvARB(GLenum target, const GLfloat *v ) {}
void glMultiTexCoord1iARB(GLenum target, GLint s ) {}
void glMultiTexCoord1ivARB(GLenum target, const GLint *v ) {}
void glMultiTexCoord1sARB(GLenum target, GLshort s ) {}
void glMultiTexCoord1svARB(GLenum target, const GLshort *v ) {}
void glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t ) {}
void glMultiTexCoord2dvARB(GLenum target, const GLdouble *v ) {}
void glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t ) {}
void glMultiTexCoord2fvARB(GLenum target, const GLfloat *v ) {}
void glMultiTexCoord2iARB(GLenum target, GLint s, GLint t ) {}
void glMultiTexCoord2ivARB(GLenum target, const GLint *v ) {}
void glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t ) {}
void glMultiTexCoord2svARB(GLenum target, const GLshort *v ) {}
void glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r ) {}
void glMultiTexCoord3dvARB(GLenum target, const GLdouble *v ) {}
void glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r ) {}
void glMultiTexCoord3fvARB(GLenum target, const GLfloat *v ) {}
void glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r ) {}
void glMultiTexCoord3ivARB(GLenum target, const GLint *v ) {}
void glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r ) {}
void glMultiTexCoord3svARB(GLenum target, const GLshort *v ) {}
void glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) {}
void glMultiTexCoord4dvARB(GLenum target, const GLdouble *v ) {}
void glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) {}
void glMultiTexCoord4fvARB(GLenum target, const GLfloat *v ) {}
void glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q ) {}
void glMultiTexCoord4ivARB(GLenum target, const GLint *v ) {}
void glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) {}
void glMultiTexCoord4svARB(GLenum target, const GLshort *v ) {}
void glLoadTransposeMatrixdARB(const GLdouble m[16] ) {}
void glLoadTransposeMatrixfARB(const GLfloat m[16] ) {}
void glMultTransposeMatrixdARB(const GLdouble m[16] ) {}
void glMultTransposeMatrixfARB(const GLfloat m[16] ) {}
void glCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data ) {}
void glCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data ) {}
void glCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data ) {}
void glCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data ) {}
void glCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data ) {}
void glCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data ) {}
void glGetCompressedTexImageARB(GLenum target, GLint lod, GLvoid *img ) {}
void glLockArraysEXT(GLint first, GLsizei count) {}
void glUnlockArraysEXT() {}
void glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue) {}
void glSecondaryColor3bvEXT(const GLbyte *v) {}
void glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue) {}
void glSecondaryColor3dvEXT(const GLdouble *v) {}
void glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue) {}
void glSecondaryColor3fvEXT(const GLfloat *v) {}
void glSecondaryColor3iEXT(GLint red, GLint green, GLint blue) {}