qgl_win_gl_int.inc

雷神之锤2(Quake2)Delphi源码

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


var
{int   ( WINAPI * qwglChoosePixelFormat )(HDC, CONST PIXELFORMATDESCRIPTOR *);
int   ( WINAPI * qwglDescribePixelFormat) (HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);
int   ( WINAPI * qwglGetPixelFormat)(HDC);
BOOL  ( WINAPI * qwglSetPixelFormat)(HDC, int, CONST 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, CONST 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: GLint; count: GLsizei); stdcall;
qglUnlockArraysEXT: procedure; stdcall;

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

{BOOL ( WINAPI * qwglGetDeviceGammaRampEXT)( unsigned char *, unsigned char *, unsigned char * );
BOOL ( WINAPI * qwglSetDeviceGammaRampEXT)( const unsigned char *, const unsigned char *, const unsigned char * );}
//Y:...???

//void ( APIENTRY * qglPointParameterfEXT)( GLenum param, GLfloat value );
qglPointParameterfEXT: procedure (pname: GLenum; param: GLfloat); stdcall;

//void ( APIENTRY * qglPointParameterfvEXT)( GLenum param, const GLfloat *value );
qglPointParameterfvEXT: procedure (pname: GLenum; const params: PGLfloat); stdcall;

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

{void ( APIENTRY * qglSelectTextureSGIS)( GLenum );
void ( APIENTRY * qglMTexCoord2fSGIS)( GLenum, GLfloat, GLfloat );}
//Y:...???