qgl_win_gl_int.inc

雷神之锤2(Quake2)Delphi源码

// This text from GL.pas - 336 glProcedures
//   - line 4-339:    glXxx --> qglXxx
//   - line 345-...:  qwgl proc

var
  //336 qgl OpenGL procedures - It's ONLY for INTERFACE unit-section
  qglAccum: procedure(op: GLenum; value: GLfloat); stdcall;
  qglAlphaFunc: procedure(func: GLenum; ref: GLclampf); stdcall;
  qglAreTexturesResident: function (n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; stdcall;
  qglArrayElement: procedure(i: GLint); stdcall;
  qglBegin: procedure(mode: GLenum); stdcall;
  qglBindTexture: procedure(target: GLenum; texture: GLuint); stdcall;
  qglBitmap: procedure (width, height: GLsizei; xorig, yorig: GLfloat; xmove, ymove: GLfloat; const bitmap: PGLubyte); stdcall;
  qglBlendFunc: procedure(sfactor, dfactor: GLenum); stdcall;
  qglCallList: procedure(list: GLuint); stdcall;
  qglCallLists: procedure(n: GLsizei; atype: GLenum; const lists: Pointer); stdcall;
  qglClear: procedure(mask: GLbitfield); stdcall;
  qglClearAccum: procedure(red, green, blue, alpha: GLfloat); stdcall;
  qglClearColor: procedure(red, green, blue, alpha: GLclampf); stdcall;
  qglClearDepth: procedure(depth: GLclampd); stdcall;
  qglClearIndex: procedure(c: GLfloat); stdcall;
  qglClearStencil: procedure(s: GLint); stdcall;
  qglClipPlane: procedure(plane: GLenum; const equation: PGLdouble); stdcall;
  qglColor3b: procedure(red, green, blue: GLbyte); stdcall;
  qglColor3bv: procedure(const v: PGLbyte); stdcall;
  qglColor3d: procedure(red, green, blue: GLdouble); stdcall;
  qglColor3dv: procedure(const v: PGLdouble); stdcall;
  qglColor3f: procedure(red, green, blue: GLfloat); stdcall;
  qglColor3fv: procedure(const v: PGLfloat); stdcall;
  qglColor3i: procedure(red, green, blue: GLint); stdcall;
  qglColor3iv: procedure(const v: PGLint); stdcall;
  qglColor3s: procedure(red, green, blue: GLshort); stdcall;
  qglColor3sv: procedure(const v: PGLshort); stdcall;
  qglColor3ub: procedure(red, green, blue: GLubyte); stdcall;
  qglColor3ubv: procedure(const v: PGLubyte); stdcall;
  qglColor3ui: procedure(red, green, blue: GLuint); stdcall;
  qglColor3uiv: procedure(const v: PGLuint); stdcall;
  qglColor3us: procedure(red, green, blue: GLushort); stdcall;
  qglColor3usv: procedure(const v: PGLushort); stdcall;
  qglColor4b: procedure(red, green, blue, alpha: GLbyte); stdcall;
  qglColor4bv: procedure(const v: PGLbyte); stdcall;
  qglColor4d: procedure(red, green, blue, alpha: GLdouble); stdcall;
  qglColor4dv: procedure(const v: PGLdouble); stdcall;
  qglColor4f: procedure(red, green, blue, alpha: GLfloat); stdcall;
  qglColor4fv: procedure(const v: PGLfloat); stdcall;
  qglColor4i: procedure(red, green, blue, alpha: GLint); stdcall;
  qglColor4iv: procedure(const v: PGLint); stdcall;
  qglColor4s: procedure(red, green, blue, alpha: GLshort); stdcall;
  qglColor4sv: procedure(const v: PGLshort); stdcall;
  qglColor4ub: procedure(red, green, blue, alpha: GLubyte); stdcall;
  qglColor4ubv: procedure(const v: PGLubyte); stdcall;
  qglColor4ui: procedure(red, green, blue, alpha: GLuint); stdcall;
  qglColor4uiv: procedure(const v: PGLuint); stdcall;
  qglColor4us: procedure(red, green, blue, alpha: GLushort); stdcall;
  qglColor4usv: procedure(const v: PGLushort); stdcall;
  qglColorMask: procedure(red, green, blue, alpha: GLboolean); stdcall;
  qglColorMaterial: procedure(face, mode: GLenum); stdcall;
  qglColorPointer: procedure(size: GLint; atype: GLenum; stride: GLsizei; const pointer: Pointer); stdcall;
  qglCopyPixels: procedure(x, y: GLint; width, height: GLsizei; atype: GLenum); stdcall;
  qglCopyTexImage1D: procedure (target: GLenum; level: GLint; internalFormat: GLenum; x, y: GLint; width: GLsizei; border: GLint); stdcall;
  qglCopyTexImage2D: procedure(target: GLenum; level: GLint; internalFormat: GLenum; x, y: GLint; width, height: GLsizei; border: GLint); stdcall;
  qglCopyTexSubImage1D: procedure(target: GLenum; level, xoffset, x, y: GLint; width: GLsizei); stdcall;
  qglCopyTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset, x, y: GLint; width, height: GLsizei); stdcall;
  qglCullFace: procedure(mode: GLenum); stdcall;
  qglDeleteLists: procedure(list: GLuint; range: GLsizei); stdcall;
  qglDeleteTextures: procedure(n: GLsizei; const textures: PGLuint); stdcall;
  qglDepthFunc: procedure(func: GLenum); stdcall;
  qglDepthMask: procedure(flag: GLboolean); stdcall;
  qglDepthRange: procedure(zNear, zFar: GLclampd); stdcall;
  qglDisable: procedure(cap: GLenum); stdcall;
  qglDisableClientState: procedure(aarray: GLenum); stdcall;
  qglDrawArrays: procedure(mode: GLenum; first: GLint; count: GLsizei); stdcall;
  qglDrawBuffer: procedure(mode: GLenum); stdcall;
  qglDrawElements: procedure(mode: GLenum; count: GLsizei; atype: GLenum; const indices: Pointer); stdcall;
  qglDrawPixels: procedure(width, height: GLsizei; format, atype: GLenum; const pixels: Pointer); stdcall;
  qglEdgeFlag: procedure(flag: GLboolean); stdcall;
  qglEdgeFlagPointer: procedure(stride: GLsizei; const pointer: Pointer); stdcall;
  qglEdgeFlagv: procedure(const flag: PGLboolean); stdcall;
  qglEnable: procedure(cap: GLenum); stdcall;
  qglEnableClientState: procedure(aarray: GLenum); stdcall;
  qglEnd: procedure; stdcall;
  qglEndList: procedure; stdcall;
  qglEvalCoord1d: procedure(u: GLdouble); stdcall;
  qglEvalCoord1dv: procedure(const u: PGLdouble); stdcall;
  qglEvalCoord1f: procedure(u: GLfloat); stdcall;
  qglEvalCoord1fv: procedure(const u: PGLfloat); stdcall;
  qglEvalCoord2d: procedure(u, v: GLdouble); stdcall;
  qglEvalCoord2dv: procedure(const u: PGLdouble); stdcall;
  qglEvalCoord2f: procedure(u, v: GLfloat); stdcall;
  qglEvalCoord2fv: procedure(const u: PGLfloat); stdcall;
  qglEvalMesh1: procedure(mode: GLenum; i1, i2: GLint); stdcall;
  qglEvalMesh2: procedure(mode: GLenum; i1, i2, j1, j2: GLint); stdcall;
  qglEvalPoint1: procedure(i: GLint); stdcall;
  qglEvalPoint2: procedure(i, j: GLint); stdcall;
  qglFeedbackBuffer: procedure(size: GLsizei; atype: GLenum; buffer: PGLfloat); stdcall;
  qglFinish: procedure; stdcall;
  qglFlush: procedure; stdcall;
  qglFogf: procedure(pname: GLenum; param: GLfloat); stdcall;
  qglFogfv: procedure(pname: GLenum; const params: PGLfloat); stdcall;
  qglFogi: procedure(pname: GLenum; param: GLint); stdcall;
  qglFogiv: procedure(pname: GLenum; const params: PGLint); stdcall;
  qglFrontFace: procedure(mode: GLenum); stdcall;
  qglFrustum: procedure(left, right, bottom, top, zNear, zFar: GLdouble); stdcall;
  qglGenLists: function(range: GLsizei): GLuint; stdcall;
  qglGenTextures: procedure(n: GLsizei; textures: PGLuint); stdcall;
  qglGetBooleanv: procedure(pname: GLenum; params: PGLboolean); stdcall;
  qglGetClipPlane: procedure(plane: GLenum; equation: PGLdouble); stdcall;
  qglGetDoublev: procedure(pname: GLenum; params: PGLdouble); stdcall;
  qglGetError: function: GLenum; stdcall;
  qglGetFloatv: procedure(pname: GLenum; params: PGLfloat); stdcall;
  qglGetIntegerv: procedure(pname: GLenum; params: PGLint); stdcall;
  qglGetLightfv: procedure(light, pname: GLenum; params: PGLfloat); stdcall;
  qglGetLightiv: procedure(light, pname: GLenum; params: PGLint); stdcall;
  qglGetMapdv: procedure(target, query: GLenum; v: PGLdouble); stdcall;
  qglGetMapfv: procedure(target, query: GLenum; v: PGLfloat); stdcall;
  qglGetMapiv: procedure(target, query: GLenum; v: GLint); stdcall;
  qglGetMaterialfv: procedure(face, pname: GLenum; params: PGLfloat); stdcall;
  qglGetMaterialiv: procedure(face, pname: GLenum; params: GLint); stdcall;
  qglGetPixelMapfv: procedure(map: GLenum; values: PGLfloat); stdcall;
  qglGetPixelMapuiv: procedure(map: GLenum; values: PGLuint); stdcall;
  qglGetPixelMapusv: procedure(map: GLenum; values: PGLushort); stdcall;
  qglGetPointerv: procedure(pname: GLenum; params: Pointer); stdcall;
  qglGetPolygonStipple: procedure(mask: PGLubyte); stdcall;
  qglGetString: function(name: GLenum): PGLubyte; stdcall;
  qglGetTexEnvfv: procedure(target, pname: GLenum; params: PGLfloat); stdcall;
  qglGetTexEnviv: procedure(target, pname: GLenum; params: PGLint); stdcall;
  qglGetTexGendv: procedure(coord, pname: GLenum; params: PGLdouble); stdcall;
  qglGetTexGenfv: procedure(coord, pname: GLenum; params: PGLfloat); stdcall;
  qglGetTexGeniv: procedure(coord, pname: GLenum; params: PGLint); stdcall;
  qglGetTexImage: procedure(target: GLenum; level: GLint; format: GLenum; atype: GLenum; pixels: Pointer); stdcall;
  qglGetTexLevelParameterfv: procedure(target: GLenum; level: GLint; pname: GLenum; params: Pointer); stdcall;
  qglGetTexLevelParameteriv: procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); stdcall;
  qglGetTexParameterfv: procedure(target, pname: GLenum; params: PGLfloat); stdcall;
  qglGetTexParameteriv: procedure(target, pname: GLenum; params: PGLint); stdcall;
  qglHint: procedure(target, mode: GLenum); stdcall;
  qglIndexMask: procedure(mask: GLuint); stdcall;
  qglIndexPointer: procedure(atype: GLenum; stride: GLsizei; const pointer: Pointer); stdcall;
  qglIndexd: procedure(c: GLdouble); stdcall;
  qglIndexdv: procedure(const c: PGLdouble); stdcall;
  qglIndexf: procedure(c: GLfloat); stdcall;
  qglIndexfv: procedure(const c: PGLfloat); stdcall;
  qglIndexi: procedure(c: GLint); stdcall;
  qglIndexiv: procedure(const c: PGLint); stdcall;
  qglIndexs: procedure(c: GLshort); stdcall;
  qglIndexsv: procedure(const c: PGLshort); stdcall;
  qglIndexub: procedure(c: GLubyte); stdcall;
  qglIndexubv: procedure(const c: PGLubyte); stdcall;
  qglInitNames: procedure; stdcall;
  qglInterleavedArrays: procedure(format: GLenum; stride: GLsizei; const pointer: Pointer); stdcall;
  qglIsEnabled: function(cap: GLenum): GLboolean; stdcall;
  qglIsList: function(list: GLuint): GLboolean; stdcall;
  qglIsTexture: function(texture: GLuint): GLboolean; stdcall;
  qglLightModelf: procedure(pname: GLenum; param: GLfloat); stdcall;
  qglLightModelfv: procedure(pname: GLenum; const params: PGLfloat); stdcall;
  qglLightModeli: procedure(pname: GLenum; param: GLint); stdcall;
  qglLightModeliv: procedure(pname: GLenum; const params: PGLint); stdcall;
  qglLightf: procedure(light, pname: GLenum; param: GLfloat); stdcall;
  qglLightfv: procedure(light, pname: GLenum; const params: PGLfloat); stdcall;
  qglLighti: procedure(light, pname: GLenum; param: GLint); stdcall;
  qglLightiv: procedure(light, pname: GLenum; const params: GLint); stdcall;
  qglLineStipple: procedure(factor: GLint; pattern: GLushort); stdcall;
  qglLineWidth: procedure(width: GLfloat); stdcall;
  qglListBase: procedure(base: GLuint); stdcall;
  qglLoadIdentity: procedure; stdcall;
  qglLoadMatrixd: procedure(const m: PGLdouble); stdcall;
  qglLoadMatrixf: procedure(const m: PGLfloat); stdcall;
  qglLoadName: procedure(name: GLuint); stdcall;
  qglLogicOp: procedure(opcode: GLenum); stdcall;
  qglMap1d: procedure(target: GLenum; u1, u2: GLdouble; stride, order: GLint; const points: PGLdouble); stdcall;
  qglMap1f: procedure(target: GLenum; u1, u2: GLfloat; stride, order: GLint; const points: PGLfloat); stdcall;
  qglMap2d: procedure(target: GLenum; u1, u2: GLdouble; ustride, uorder: GLint; v1, v2: GLdouble; vstride, vorder: GLint; const points: PGLdouble); stdcall;
  qglMap2f: procedure(target: GLenum; u1, u2: GLfloat; ustride, uorder: GLint; v1, v2: GLfloat; vstride, vorder: GLint; const points: PGLfloat); stdcall;
  qglMapGrid1d: procedure(un: GLint; u1, u2: GLdouble); stdcall;
  qglMapGrid1f: procedure(un: GLint; u1, u2: GLfloat); stdcall;
  qglMapGrid2d: procedure(un: GLint; u1, u2: GLdouble; vn: GLint; v1, v2: GLdouble); stdcall;
  qglMapGrid2f: procedure(un: GLint; u1, u2: GLfloat; vn: GLint; v1, v2: GLfloat); stdcall;
  qglMaterialf: procedure(face, pname: GLenum; param: GLfloat); stdcall;
  qglMaterialfv: procedure(face, pname: GLenum; const params: PGLfloat); stdcall;
  qglMateriali: procedure(face, pname: GLenum; param: GLint); stdcall;
  qglMaterialiv: procedure(face, pname: GLenum; const params: PGLint); stdcall;
  qglMatrixMode: procedure(mode: GLenum); stdcall;
  qglMultMatrixd: procedure(const m: PGLdouble); stdcall;
  qglMultMatrixf: procedure(const m: PGLfloat); stdcall;
  qglNewList: procedure(list: GLuint; mode: GLenum); stdcall;
  qglNormal3b: procedure(nx, ny, nz: GLbyte); stdcall;
  qglNormal3bv: procedure(const v: PGLbyte); stdcall;
  qglNormal3d: procedure(nx, ny, nz: GLdouble); stdcall;
  qglNormal3dv: procedure(const v: PGLdouble); stdcall;
  qglNormal3f: procedure(nx, ny, nz: GLfloat); stdcall;
  qglNormal3fv: procedure(const v: PGLfloat); stdcall;
  qglNormal3i: procedure(nx, ny, nz: GLint); stdcall;
  qglNormal3iv: procedure(const v: PGLint); stdcall;
  qglNormal3s: procedure(nx, ny, nz: GLshort); stdcall;
  qglNormal3sv: procedure(const v: PGLshort); stdcall;
  qglNormalPointer: procedure(atype: GLenum; stride: GLsizei; const pointer: Pointer); stdcall;
  qglOrtho: procedure(left, right, bottom, top, zNear, zFar: GLdouble); stdcall;
  qglPassThrough: procedure(token: GLfloat); stdcall;
  qglPixelMapfv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLfloat); stdcall;
  qglPixelMapuiv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLuint); stdcall;
  qglPixelMapusv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLushort); stdcall;
  qglPixelStoref: procedure(pname: GLenum; param: GLfloat); stdcall;
  qglPixelStorei: procedure(pname: GLenum; param: GLint); stdcall;
  qglPixelTransferf: procedure(pname: GLenum; param: GLfloat); stdcall;
  qglPixelTransferi: procedure(pname: GLenum; param: GLint); stdcall;
  qglPixelZoom: procedure(xfactor, yfactor: GLfloat); stdcall;
  qglPointSize: procedure(size: GLfloat); stdcall;
  qglPolygonMode: procedure(face, mode: GLenum); stdcall;
  qglPolygonOffset: procedure(factor, units: GLfloat); stdcall;
  qglPolygonStipple: procedure(const mask: PGLubyte); stdcall;
  qglPopAttrib: procedure; stdcall;
  qglPopClientAttrib: procedure; stdcall;
  qglPopMatrix: procedure; stdcall;