qgl_h.pas

雷神之锤2(Quake2)Delphi源码

{----------------------------------------------------------------------------}
{                                                                            }
{ File(s): qgl_h.pas                                                         }
{                                                                            }
{ Initial conversion by : Lars Middendorf ([e-mail])                      }
{ Initial conversion on : 07-Jan-2002                                        }
{                                                                            }
{ This File contains part of convertion of Quake2 source to ObjectPascal.    }
{ More information about this project can be found at:                       }
{ http://www.sulaco.co.za/quake2/                                            }
{                                                                            }
{ Copyright (C) 1997-2001 Id Software, Inc.                                  }
{                                                                            }
{ This program is free software; you can redistribute it and/or              }
{ modify it under the terms of the GNU General Public License                }
{ as published by the Free Software Foundation; either version 2             }
{ of the License, or (at your option) any later version.                     }
{                                                                            }
{ This program is distributed in the hope that it will be useful,            }
{ but WITHOUT ANY WARRANTY; without even the implied warranty of             }
{ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                       }
{                                                                            }
{ See the GNU General Public License for more details.                       }
{                                                                            }
{----------------------------------------------------------------------------}
{ Updated on :                                                               }
{ Updated by :                                                               }
{                                                                            }
{----------------------------------------------------------------------------}
{ * Still dependent (to compile correctly) on:                               }
{ none                                                                       }
{----------------------------------------------------------------------------}
{ * TODO:                                                                    }
{ none                                                                       }
{----------------------------------------------------------------------------}

unit qgl_h;

interface

{$ifndef __QGL_H__}
{$define __QGL_H__}

uses
{$ifdef WIN32}
windows,
{$endif}
sysutils,gl,q_shared;


type
pcolorref=^colorref;

var
QGL_Init:function(const dllname:pchar):qboolean;
QGL_Shutdown:procedure;



qglaccum:procedure(op:glenum;value:glfloat);stdcall;
qglalphafunc:procedure(func:glenum;ref:glclampf);stdcall;
qglaretexturesresident:function(n:glsizei;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:glsizei;height:glsizei;xorig:glfloat;yorig:glfloat;xmove:glfloat;ymove:glfloat;bitmap:pglubyte);stdcall;
qglblendfunc:procedure(sfactor:glenum;dfactor:glenum);stdcall;
qglcalllist:procedure(list:gluint);stdcall;
qglcalllists:procedure(n:glsizei;_type:glenum;const lists:pointer);stdcall;
qglclear:procedure(mask:glbitfield);stdcall;
qglclearaccum:procedure(red:glfloat;green:glfloat;blue:glfloat;alpha:glfloat);stdcall;
qglclearcolor:procedure(red:glclampf;green:glclampf;blue:glclampf;alpha:glclampf);stdcall;
qglcleardepth:procedure(depth:glclampd);stdcall;
qglclearindex:procedure(c:glfloat);stdcall;
qglclearstencil:procedure(s:glint);stdcall;
qglclipplane:procedure(plane:glenum;equation:pgldouble);stdcall;
qglcolor3b:procedure(red:glbyte;green:glbyte;blue:glbyte);stdcall;
qglcolor3bv:procedure(v:pglbyte);stdcall;
qglcolor3d:procedure(red:gldouble;green:gldouble;blue:gldouble);stdcall;
qglcolor3dv:procedure(v:pgldouble);stdcall;
qglcolor3f:procedure(red:glfloat;green:glfloat;blue:glfloat);stdcall;
qglcolor3fv:procedure(v:pglfloat);stdcall;
qglcolor3i:procedure(red:glint;green:glint;blue:glint);stdcall;
qglcolor3iv:procedure(v:pglint);stdcall;
qglcolor3s:procedure(red:glshort;green:glshort;blue:glshort);stdcall;
qglcolor3sv:procedure(v:pglshort);stdcall;
qglcolor3ub:procedure(red:glubyte;green:glubyte;blue:glubyte);stdcall;
qglcolor3ubv:procedure(v:pglubyte);stdcall;
qglcolor3ui:procedure(red:gluint;green:gluint;blue:gluint);stdcall;
qglcolor3uiv:procedure(v:pgluint);stdcall;
qglcolor3us:procedure(red:glushort;green:glushort;blue:glushort);stdcall;
qglcolor3usv:procedure(v:pglushort);stdcall;
qglcolor4b:procedure(red:glbyte;green:glbyte;blue:glbyte;alpha:glbyte);stdcall;
qglcolor4bv:procedure(v:pglbyte);stdcall;
qglcolor4d:procedure(red:gldouble;green:gldouble;blue:gldouble;alpha:gldouble);stdcall;
qglcolor4dv:procedure(v:pgldouble);stdcall;
qglcolor4f:procedure(red:glfloat;green:glfloat;blue:glfloat;alpha:glfloat);stdcall;
qglcolor4fv:procedure(v:pglfloat);stdcall;
qglcolor4i:procedure(red:glint;green:glint;blue:glint;alpha:glint);stdcall;
qglcolor4iv:procedure(v:pglint);stdcall;
qglcolor4s:procedure(red:glshort;green:glshort;blue:glshort;alpha:glshort);stdcall;
qglcolor4sv:procedure(v:pglshort);stdcall;
qglcolor4ub:procedure(red:glubyte;green:glubyte;blue:glubyte;alpha:glubyte);stdcall;
qglcolor4ubv:procedure(v:pglubyte);stdcall;
qglcolor4ui:procedure(red:gluint;green:gluint;blue:gluint;alpha:gluint);stdcall;
qglcolor4uiv:procedure(v:pgluint);stdcall;
qglcolor4us:procedure(red:glushort;green:glushort;blue:glushort;alpha:glushort);stdcall;
qglcolor4usv:procedure(v:pglushort);stdcall;
qglcolormask:procedure(red:glboolean;green:glboolean;blue:glboolean;alpha:glboolean);stdcall;
qglcolormaterial:procedure(face:glenum;mode:glenum);stdcall;
qglcolorpointer:procedure(size:glint;_type:glenum;stride:glsizei;const p:pointer);stdcall;
qglcopypixels:procedure(x:glint;y:glint;width:glsizei;height:glsizei;_type:glenum);stdcall;
qglcopyteximage1d:procedure(target:glenum;level:glint;internalformat:glenum;x:glint;y:glint;width:glsizei;border:glint);stdcall;
qglcopyteximage2d:procedure(target:glenum;level:glint;internalformat:glenum;x:glint;y:glint;width:glsizei;height:glsizei;border:glint);stdcall;
qglcopytexsubimage1d:procedure(target:glenum;level:glint;xoffset:glint;x:glint;y:glint;width:glsizei);stdcall;
qglcopytexsubimage2d:procedure(target:glenum;level:glint;xoffset:glint;yoffset:glint;x:glint;y:glint;width:glsizei;height:glsizei);stdcall;
qglcullface:procedure(mode:glenum);stdcall;
qgldeletelists:procedure(list:gluint;range:glsizei);stdcall;
qgldeletetextures:procedure(n:glsizei;textures:pgluint);stdcall;
qgldepthfunc:procedure(func:glenum);stdcall;
qgldepthmask:procedure(flag:glboolean);stdcall;
qgldepthrange:procedure(znear:glclampd;zfar:glclampd);stdcall;
qgldisable:procedure(cap:glenum);stdcall;
qgldisableclientstate:procedure(_array:glenum);stdcall;
qgldrawarrays:procedure(mode:glenum;first:glint;count:glsizei);stdcall;
qgldrawbuffer:procedure(mode:glenum);stdcall;
qgldrawelements:procedure(mode:glenum;count:glsizei;_type:glenum;const indices:pointer);stdcall;
qgldrawpixels:procedure(width:glsizei;height:glsizei;format:glenum;_type:glenum;const pixels:pointer);stdcall;
qgledgeflag:procedure(flag:glboolean);stdcall;
qgledgeflagpointer:procedure(stride:glsizei;const p:pointer);stdcall;
qgledgeflagv:procedure(flag:pglboolean);stdcall;
qglenable:procedure(cap:glenum);stdcall;
qglenableclientstate:procedure(_array:glenum);stdcall;
qglend:procedure;stdcall;
qglendlist:procedure;stdcall;
qglevalcoord1d:procedure(u:gldouble);stdcall;
qglevalcoord1dv:procedure(u:pgldouble);stdcall;
qglevalcoord1f:procedure(u:glfloat);stdcall;
qglevalcoord1fv:procedure(u:pglfloat);stdcall;
qglevalcoord2d:procedure(u:gldouble;v:gldouble);stdcall;
qglevalcoord2dv:procedure(u:pgldouble);stdcall;
qglevalcoord2f:procedure(u:glfloat;v:glfloat);stdcall;
qglevalcoord2fv:procedure(u:pglfloat);stdcall;
qglevalmesh1:procedure(mode:glenum;i1:glint;i2:glint);stdcall;
qglevalmesh2:procedure(mode:glenum;i1:glint;i2:glint;j1:glint;j2:glint);stdcall;
qglevalpoint1:procedure(i:glint);stdcall;
qglevalpoint2:procedure(i:glint;j:glint);stdcall;
qglfeedbackbuffer:procedure(size:glsizei;_type:glenum;buffer:pglfloat);stdcall;
qglfinish:procedure;stdcall;
qglflush:procedure;stdcall;
qglfogf:procedure(pname:glenum;param:glfloat);stdcall;
qglfogfv:procedure(pname:glenum;params:pglfloat);stdcall;
qglfogi:procedure(pname:glenum;param:glint);stdcall;
qglfogiv:procedure(pname:glenum;params:pglint);stdcall;
qglfrontface:procedure(mode:glenum);stdcall;
qglfrustum:procedure(left:gldouble;right:gldouble;bottom:gldouble;top:gldouble;znear:gldouble;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:glenum;pname:glenum;params:pglfloat);stdcall;
qglgetlightiv:procedure(light:glenum;pname:glenum;params:pglint);stdcall;
qglgetmapdv:procedure(target:glenum;query:glenum;v:pgldouble);stdcall;
qglgetmapfv:procedure(target:glenum;query:glenum;v:pglfloat);stdcall;
qglgetmapiv:procedure(target:glenum;query:glenum;v:pglint);stdcall;
qglgetmaterialfv:procedure(face:glenum;pname:glenum;params:pglfloat);stdcall;
qglgetmaterialiv:procedure(face:glenum;pname:glenum;params:pglint);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:glenum;pname:glenum;params:pglfloat);stdcall;
qglgettexenviv:procedure(target:glenum;pname:glenum;params:pglint);stdcall;
qglgettexgendv:procedure(coord:glenum;pname:glenum;params:pgldouble);stdcall;
qglgettexgenfv:procedure(coord:glenum;pname:glenum;params:pglfloat);stdcall;
qglgettexgeniv:procedure(coord:glenum;pname:glenum;params:pglint);stdcall;
qglgetteximage:procedure(target:glenum;level:glint;format:glenum;_type:glenum;pixels:pointer);stdcall;
qglgettexlevelparameterfv:procedure(target:glenum;level:glint;pname:glenum;params:pglfloat);stdcall;
qglgettexlevelparameteriv:procedure(target:glenum;level:glint;pname:glenum;params:pglint);stdcall;
qglgettexparameterfv:procedure(target:glenum;pname:glenum;params:pglfloat);stdcall;
qglgettexparameteriv:procedure(target:glenum;pname:glenum;params:pglint);stdcall;
qglhint:procedure(target:glenum;mode:glenum);stdcall;
qglindexmask:procedure(mask:gluint);stdcall;
qglindexpointer:procedure(_type:glenum;stride:glsizei;p:pointer);stdcall;
qglindexd:procedure(c:gldouble);stdcall;
qglindexdv:procedure(c:pgldouble);stdcall;
qglindexf:procedure(c:glfloat);stdcall;
qglindexfv:procedure(c:pglfloat);stdcall;
qglindexi:procedure(c:glint);stdcall;
qglindexiv:procedure(c:pglint);stdcall;
qglindexs:procedure(c:glshort);stdcall;
qglindexsv:procedure(c:pglshort);stdcall;
qglindexub:procedure(c:glubyte);stdcall;
qglindexubv:procedure(c:pglubyte);stdcall;
qglinitnames:procedure;stdcall;
qglinterleavedarrays:procedure(format:glenum;stride:glsizei;p: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;params:pglfloat);stdcall;
qgllightmodeli:procedure(pname:glenum;param:glint);stdcall;
qgllightmodeliv:procedure(pname:glenum;params:pglint);stdcall;
qgllightf:procedure(light:glenum;pname:glenum;param:glfloat);stdcall;
qgllightfv:procedure(light:glenum;pname:glenum;params:pglfloat);stdcall;
qgllighti:procedure(light:glenum;pname:glenum;param:glint);stdcall;
qgllightiv:procedure(light:glenum;pname:glenum;params:pglint);stdcall;
qgllinestipple:procedure(factor:glint;pattern:glushort);stdcall;
qgllinewidth:procedure(width:glfloat);stdcall;
qgllistbase:procedure(base:gluint);stdcall;
qglloadidentity:procedure;stdcall;
qglloadmatrixd:procedure(m:pgldouble);stdcall;
qglloadmatrixf:procedure(m:pglfloat);stdcall;
qglloadname:procedure(name:gluint);stdcall;
qgllogicop:procedure(opcode:glenum);stdcall;
qglmap1d:procedure(target:glenum;u1:gldouble;u2:gldouble;stride:glint;order:glint;points:pgldouble);stdcall;
qglmap1f:procedure(target:glenum;u1:glfloat;u2:glfloat;stride:glint;order:glint;points:pglfloat);stdcall;
qglmap2d:procedure(target:glenum;u1:gldouble;u2:gldouble;ustride:glint;uorder:glint;v1:gldouble;v2:gldouble;vstride:glint;vorder:glint;points:pgldouble);stdcall;
qglmap2f:procedure(target:glenum;u1:glfloat;u2:glfloat;ustride:glint;uorder:glint;v1:glfloat;v2:glfloat;vstride:glint;vorder:glint;points:pglfloat);stdcall;
qglmapgrid1d:procedure(un:glint;u1:gldouble;u2:gldouble);stdcall;
qglmapgrid1f:procedure(un:glint;u1:glfloat;u2:glfloat);stdcall;
qglmapgrid2d:procedure(un:glint;u1:gldouble;u2:gldouble;vn:glint;v1:gldouble;v2:gldouble);stdcall;
qglmapgrid2f:procedure(un:glint;u1:glfloat;u2:glfloat;vn:glint;v1:glfloat;v2:glfloat);stdcall;
qglmaterialf:procedure(face:glenum;pname:glenum;param:glfloat);stdcall;