qgl_win_gl_int.inc

delphi编的不错的贪吃蛇

  qglPrioritizeTextures: procedure(n: TGLsizei; textures: PGLuint; priorities: PGLclampf); stdcall;
  qglPushAttrib: procedure(mask: TGLbitfield); stdcall;
  qglPushClientAttrib: procedure(mask: TGLbitfield); stdcall;
  qglPushMatrix: procedure; stdcall;
  qglPushName: procedure(name: TGLuint); stdcall;
  qglRasterPos2d: procedure(x, y: TGLdouble); stdcall;
  qglRasterPos2dv: procedure(v: PGLdouble); stdcall;
  qglRasterPos2f: procedure(x, y: TGLfloat); stdcall;
  qglRasterPos2fv: procedure(v: PGLfloat); stdcall;
  qglRasterPos2i: procedure(x, y: TGLint); stdcall;
  qglRasterPos2iv: procedure(v: PGLint); stdcall;
  qglRasterPos2s: procedure(x, y: TGLshort); stdcall;
  qglRasterPos2sv: procedure(v: PGLshort); stdcall;
  qglRasterPos3d: procedure(x, y, z: TGLdouble); stdcall;
  qglRasterPos3dv: procedure(v: PGLdouble); stdcall;
  qglRasterPos3f: procedure(x, y, z: TGLfloat); stdcall;
  qglRasterPos3fv: procedure(v: PGLfloat); stdcall;
  qglRasterPos3i: procedure(x, y, z: TGLint); stdcall;
  qglRasterPos3iv: procedure(v: PGLint); stdcall;
  qglRasterPos3s: procedure(x, y, z: TGLshort); stdcall;
  qglRasterPos3sv: procedure(v: PGLshort); stdcall;
  qglRasterPos4d: procedure(x, y, z, w: TGLdouble); stdcall;
  qglRasterPos4dv: procedure(v: PGLdouble); stdcall;
  qglRasterPos4f: procedure(x, y, z, w: TGLfloat); stdcall;
  qglRasterPos4fv: procedure(v: PGLfloat); stdcall;
  qglRasterPos4i: procedure(x, y, z, w: TGLint); stdcall;
  qglRasterPos4iv: procedure(v: PGLint); stdcall;
  qglRasterPos4s: procedure(x, y, z, w: TGLshort); stdcall;
  qglRasterPos4sv: procedure(v: PGLshort); stdcall;
  qglReadBuffer: procedure(mode: TGLenum); stdcall;
  qglReadPixels: procedure(x, y: TGLint; width, height: TGLsizei; format, atype: TGLenum; pixels: Pointer); stdcall;
  qglRectd: procedure(x1, y1, x2, y2: TGLdouble); stdcall;
  qglRectdv: procedure(v1: PGLdouble; v2: PGLdouble); stdcall;
  qglRectf: procedure(x1, y1, x2, y2: TGLfloat); stdcall;
  qglRectfv: procedure(v1: PGLfloat; v2: PGLfloat); stdcall;
  qglRecti: procedure(x1, y1, x2, y2: TGLint); stdcall;
  qglRectiv: procedure(v1: PGLint; v2: PGLint); stdcall;
  qglRects: procedure(x1, y1, x2, y2: TGLshort); stdcall;
  qglRectsv: procedure(v1: PGLshort; v2: PGLshort); stdcall;
  qglRenderMode: function(mode: TGLint): TGLint; stdcall;
  qglRotated: procedure(angle, x, y, z: TGLdouble); stdcall;
  qglRotatef: procedure(angle, x, y, z: TGLfloat); stdcall;
  qglScaled: procedure(x, y, z: TGLdouble); stdcall;
  qglScalef: procedure(x, y, z: TGLfloat); stdcall;
  qglScissor: procedure(x, y: TGLint; width, height: TGLsizei); stdcall;
  qglSelectBuffer: procedure(size: TGLsizei; buffer: PGLuint); stdcall;
  qglShadeModel: procedure(mode: TGLenum); stdcall;
  qglStencilFunc: procedure(func: TGLenum; ref: TGLint; mask: TGLuint); stdcall;
  qglStencilMask: procedure(mask: TGLuint); stdcall;
  qglStencilOp: procedure(fail, zfail, zpass: TGLenum); stdcall;
  qglTexCoord1d: procedure(s: TGLdouble); stdcall;
  qglTexCoord1dv: procedure(v: PGLdouble); stdcall;
  qglTexCoord1f: procedure(s: TGLfloat); stdcall;
  qglTexCoord1fv: procedure(v: PGLfloat); stdcall;
  qglTexCoord1i: procedure(s: TGLint); stdcall;
  qglTexCoord1iv: procedure(v: PGLint); stdcall;
  qglTexCoord1s: procedure(s: TGLshort); stdcall;
  qglTexCoord1sv: procedure(v: PGLshort); stdcall;
  qglTexCoord2d: procedure(s, t: TGLdouble); stdcall;
  qglTexCoord2dv: procedure(v: PGLdouble); stdcall;
  qglTexCoord2f: procedure(s, t: TGLfloat); stdcall;
  qglTexCoord2fv: procedure(v: PGLfloat); stdcall;
  qglTexCoord2i: procedure(s, t: TGLint); stdcall;
  qglTexCoord2iv: procedure(v: PGLint); stdcall;
  qglTexCoord2s: procedure(s, t: TGLshort); stdcall;
  qglTexCoord2sv: procedure(v: PGLshort); stdcall;
  qglTexCoord3d: procedure(s, t, r: TGLdouble); stdcall;
  qglTexCoord3dv: procedure(v: PGLdouble); stdcall;
  qglTexCoord3f: procedure(s, t, r: TGLfloat); stdcall;
  qglTexCoord3fv: procedure(v: PGLfloat); stdcall;
  qglTexCoord3i: procedure(s, t, r: TGLint); stdcall;
  qglTexCoord3iv: procedure(v: PGLint); stdcall;
  qglTexCoord3s: procedure(s, t, r: TGLshort); stdcall;
  qglTexCoord3sv: procedure(v: PGLshort); stdcall;
  qglTexCoord4d: procedure(s, t, r, q: TGLdouble); stdcall;
  qglTexCoord4dv: procedure(v: PGLdouble); stdcall;
  qglTexCoord4f: procedure(s, t, r, q: TGLfloat); stdcall;
  qglTexCoord4fv: procedure(v: PGLfloat); stdcall;
  qglTexCoord4i: procedure(s, t, r, q: TGLint); stdcall;
  qglTexCoord4iv: procedure(v: PGLint); stdcall;
  qglTexCoord4s: procedure(s, t, r, q: TGLshort); stdcall;
  qglTexCoord4sv: procedure(v: PGLshort); stdcall;
  qglTexCoordPointer: procedure(size: TGLint; atype: TGLenum; stride: TGLsizei; pointer: Pointer); stdcall;
  qglTexEnvf: procedure(target: TGLenum; pname: TGLenum; param: TGLfloat); stdcall;
  qglTexEnvfv: procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); stdcall;
  qglTexEnvi: procedure(target: TGLenum; pname: TGLenum; param: TGLint); stdcall;
  qglTexEnviv: procedure(target: TGLenum; pname: TGLenum; params: PGLint); stdcall;
  qglTexGend: procedure(coord: TGLenum; pname: TGLenum; param: TGLdouble); stdcall;
  qglTexGendv: procedure(coord: TGLenum; pname: TGLenum; params: PGLdouble); stdcall;
  qglTexGenf: procedure(coord: TGLenum; pname: TGLenum; param: TGLfloat); stdcall;
  qglTexGenfv: procedure(coord: TGLenum; pname: TGLenum; params: PGLfloat); stdcall;
  qglTexGeni: procedure(coord: TGLenum; pname: TGLenum; param: TGLint); stdcall;
  qglTexGeniv: procedure(coord: TGLenum; pname: TGLenum; params: PGLint); stdcall;
  qglTexImage1D: procedure(target: TGLenum; level, internalformat: TGLint; width: TGLsizei; border: TGLint; format, atype: TGLenum; pixels: Pointer); stdcall;
  qglTexImage2D: procedure(target: TGLenum; level, internalformat: TGLint; width, height: TGLsizei; border: TGLint; format, atype: TGLenum; pixels: Pointer); stdcall;
  qglTexParameterf: procedure(target: TGLenum; pname: TGLenum; param: TGLfloat); stdcall;
  qglTexParameterfv: procedure(target: TGLenum; pname: TGLenum; params: PGLfloat); stdcall;
  qglTexParameteri: procedure(target: TGLenum; pname: TGLenum; param: TGLint); stdcall;
  qglTexParameteriv: procedure(target: TGLenum; pname: TGLenum; params: PGLint); stdcall;
  qglTexSubImage1D: procedure(target: TGLenum; level, xoffset: TGLint; width: TGLsizei; format, atype: TGLenum; pixels: Pointer); stdcall;
  qglTexSubImage2D: procedure(target: TGLenum; level, xoffset, yoffset: TGLint; width, height: TGLsizei; format, atype: TGLenum; pixels: Pointer); stdcall;
  qglTranslated: procedure(x, y, z: TGLdouble); stdcall;
  qglTranslatef: procedure(x, y, z: TGLfloat); stdcall;
  qglVertex2d: procedure(x, y: TGLdouble); stdcall;
  qglVertex2dv: procedure(v: PGLdouble); stdcall;
  qglVertex2f: procedure(x, y: TGLfloat); stdcall;
  qglVertex2fv: procedure(v: PGLfloat); stdcall;
  qglVertex2i: procedure(x, y: TGLint); stdcall;
  qglVertex2iv: procedure(v: PGLint); stdcall;
  qglVertex2s: procedure(x, y: TGLshort); stdcall;
  qglVertex2sv: procedure(v: PGLshort); stdcall;
  qglVertex3d: procedure(x, y, z: TGLdouble); stdcall;
  qglVertex3dv: procedure(v: PGLdouble); stdcall;
  qglVertex3f: procedure(x, y, z: TGLfloat); stdcall;
  qglVertex3fv: procedure(v: PGLfloat); stdcall;
  qglVertex3i: procedure(x, y, z: TGLint); stdcall;
  qglVertex3iv: procedure(v: PGLint); stdcall;
  qglVertex3s: procedure(x, y, z: TGLshort); stdcall;
  qglVertex3sv: procedure(v: PGLshort); stdcall;
  qglVertex4d: procedure(x, y, z, w: TGLdouble); stdcall;
  qglVertex4dv: procedure(v: PGLdouble); stdcall;
  qglVertex4f: procedure(x, y, z, w: TGLfloat); stdcall;
  qglVertex4fv: procedure(v: PGLfloat); stdcall;
  qglVertex4i: procedure(x, y, z, w: TGLint); stdcall;
  qglVertex4iv: procedure(v: PGLint); stdcall;
  qglVertex4s: procedure(x, y, z, w: TGLshort); stdcall;
  qglVertex4sv: procedure(v: PGLshort); stdcall;
  qglVertexPointer: procedure(size: TGLint; atype: TGLenum; stride: TGLsizei; pointer: Pointer); stdcall;
  qglViewport: procedure(x, y: TGLint; width, height: TGLsizei); stdcall;


var
{int   ( WINAPI * qwglChoosePixelFormat )(HDC, PIXELFORMATDESCRIPTOR *);
int   ( WINAPI * qwglDescribePixelFormat) (HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);
int   ( WINAPI * qwglGetPixelFormat)(HDC);
BOOL  ( WINAPI * qwglSetPixelFormat)(HDC, int, PIXELFORMATDESCRIPTOR *);
BOOL  ( WINAPI * qwglSwapBuffers)(HDC);}
qwglChoosePixelFormat : function (DC: HDC; p2: PPixelFormatDescriptor): Integer; stdcall;
qwglDescribePixelFormat : function (DC: HDC; p2: Integer; p3: UINT; var p4: TPixelFormatDescriptor): BOOL; stdcall;
qwglGetPixelFormat : function (DC: HDC): Integer; stdcall;
qwglSetPixelFormat : function (DC: HDC; PixelFormat: Integer; FormatDef: PPixelFormatDescriptor): BOOL; stdcall;
qwglSwapBuffers : function (DC: HDC): BOOL; stdcall;

{BOOL  ( WINAPI * qwglCopyContext)(HGLRC, HGLRC, UINT);
HGLRC ( WINAPI * qwglCreateContext)(HDC);
HGLRC ( WINAPI * qwglCreateLayerContext)(HDC, int);
BOOL  ( WINAPI * qwglDeleteContext)(HGLRC);
HGLRC ( WINAPI * qwglGetCurrentContext)(VOID);
HDC   ( WINAPI * qwglGetCurrentDC)(VOID);
PROC  ( WINAPI * qwglGetProcAddress)(LPCSTR);
BOOL  ( WINAPI * qwglMakeCurrent)(HDC, HGLRC);
BOOL  ( WINAPI * qwglShareLists)(HGLRC, HGLRC);}
qwglCopyContext: function (p1: HGLRC; p2: HGLRC; p3: Cardinal): BOOL; stdcall;
qwglCreateContext: function (DC: HDC): HGLRC; stdcall;
qwglCreateLayerContext: function (p1: HDC; p2: Integer): HGLRC; stdcall;
qwglDeleteContext: function (p1: HGLRC): BOOL; stdcall;
qwglGetCurrentContext: function : HGLRC; stdcall;
qwglGetCurrentDC: function : HDC; stdcall;
qwglGetProcAddress: function (ProcName: PChar): Pointer; stdcall;
qwglMakeCurrent: function (DC: HDC; p2: HGLRC): BOOL; stdcall;
qwglShareLists: function(p1, p2: HGLRC): BOOL; stdcall;

//BOOL  ( WINAPI * qwglUseFontBitmaps)(HDC, DWORD, DWORD, DWORD);
qwglUseFontBitmaps: function (DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;

//BOOL  ( WINAPI * qwglUseFontOutlines)(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT);
qwglUseFontOutlines: function (p1: HDC; p2, p3, p4: DWORD; p5, p6: Single;
                               p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;

//BOOL ( WINAPI * qwglDescribeLayerPlane)(HDC, int, int, UINT, LPLAYERPLANEDESCRIPTOR);
qwglDescribeLayerPlane: function (p1: HDC; p2, p3: Integer; p4: Cardinal; var p5: TLayerPlaneDescriptor): BOOL; stdcall;

//int  ( WINAPI * qwglSetLayerPaletteEntries)(HDC, int, int, int, COLORREF *);
qwglSetLayerPaletteEntries: function (p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;

//int  ( WINAPI * qwglGetLayerPaletteEntries)(HDC, int, int, int, COLORREF *);
qwglGetLayerPaletteEntries: function (p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;

//BOOL ( WINAPI * qwglRealizeLayerPalette)(HDC, int, BOOL);
qwglRealizeLayerPalette: function (p1: HDC; p2: Integer; p3: BOOL): BOOL; stdcall;

//BOOL ( WINAPI * qwglSwapLayerBuffers)(HDC, UINT);
qwglSwapLayerBuffers: function (p1: HDC; p2: Cardinal): BOOL; stdcall;

{void ( APIENTRY * qglLockArraysEXT)( int, int);
void ( APIENTRY * qglUnlockArraysEXT) ( void );}
qglLockArraysEXT: procedure (first: TGLint; count: TGLsizei); stdcall;
qglUnlockArraysEXT: procedure; stdcall;

//BOOL ( WINAPI * qwglSwapIntervalEXT)( int interval );
qwglSwapIntervalEXT: function (interval: TGLint): Integer; stdcall;

qwglGetDeviceGammaRampEXT: function( a, b, c, d, e: PByte):BOOL; stdcall;
qwglSetDeviceGammaRampEXT: function( a, b, c: PByte): BOOL; stdcall;
//Y:...???

//void ( APIENTRY * qglPointParameterfEXT)( TGLenum param, TGLfloat value );
qglPointParameterfEXT: procedure (pname: TGLenum; param: TGLfloat); stdcall;

//void ( APIENTRY * qglPointParameterfvEXT)( TGLenum param, TGLfloat *value );
qglPointParameterfvEXT: procedure (pname: TGLenum; params: PGLfloat); stdcall;

//void ( APIENTRY * qglColorTableEXT)( int, int, int, int, int, void * );
qglColorTableEXT: procedure (target, internalformat: TGLenum; width: TGLsizei;
                             format, atype: TGLenum; table: Pointer); stdcall;

qglSelectTextureSGIS: procedure(a: TGLenum ); stdcall;
qglMTexCoord2fSGIS: procedure(a: TGLenum; b: TGLfloat; c: TGLfloat); stdcall;

qglActiveTextureARB: procedure( a: TGLenum ); stdcall;
qglClientActiveTextureARB: procedure ( a: TGLenum ); stdcall;