qgl_win_gl_int.inc

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