qgl_h.pas

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

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


(*
type
  pcolorref=^colorref;

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

  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:TGLsizei;height:TGLsizei;xorig:TGLfloat;yorig:TGLfloat;xmove:TGLfloat;ymove:TGLfloat;bitmap:PGLubyte);stdcall;
  qglblendfunc:procedure(sfactor:TGLenum;dfactor:TGLenum);stdcall;
  qglcalllist:procedure(list:TGLuint);stdcall;
  qglcalllists:procedure(n:TGLsizei;_type:TGLenum;const lists:pointer);stdcall;
  qglclear:procedure(mask:TGLbitfield);stdcall;
  qglclearaccum:procedure(red:TGLfloat;green:TGLfloat;blue:TGLfloat;alpha:TGLfloat);stdcall;
  qglclearcolor:procedure(red:TGLclampf;green:TGLclampf;blue:TGLclampf;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:TGLbyte;green:TGLbyte;blue:TGLbyte);stdcall;
  qglcolor3bv:procedure(v:PGLbyte);stdcall;
  qglcolor3d:procedure(red:TGLdouble;green:TGLdouble;blue:TGLdouble);stdcall;
  qglcolor3dv:procedure(v:PGLdouble);stdcall;
  qglcolor3f:procedure(red:TGLfloat;green:TGLfloat;blue:TGLfloat);stdcall;
  qglcolor3fv:procedure(v:PGLfloat);stdcall;
  qglcolor3i:procedure(red:TGLint;green:TGLint;blue:TGLint);stdcall;
  qglcolor3iv:procedure(v:PGLint);stdcall;
  qglcolor3s:procedure(red:TGLshort;green:TGLshort;blue:TGLshort);stdcall;
  qglcolor3sv:procedure(v:PGLshort);stdcall;
  qglcolor3ub:procedure(red:TGLubyte;green:TGLubyte;blue:TGLubyte);stdcall;
  qglcolor3ubv:procedure(v:PGLubyte);stdcall;
  qglcolor3ui:procedure(red:TGLuint;green:TGLuint;blue:TGLuint);stdcall;
  qglcolor3uiv:procedure(v:PGLuint);stdcall;
  qglcolor3us:procedure(red:TGLushort;green:TGLushort;blue:TGLushort);stdcall;
  qglcolor3usv:procedure(v:PGLushort);stdcall;
  qglcolor4b:procedure(red:TGLbyte;green:TGLbyte;blue:TGLbyte;alpha:TGLbyte);stdcall;
  qglcolor4bv:procedure(v:PGLbyte);stdcall;
  qglcolor4d:procedure(red:TGLdouble;green:TGLdouble;blue:TGLdouble;alpha:TGLdouble);stdcall;
  qglcolor4dv:procedure(v:PGLdouble);stdcall;
  qglcolor4f:procedure(red:TGLfloat;green:TGLfloat;blue:TGLfloat;alpha:TGLfloat);stdcall;
  qglcolor4fv:procedure(v:PGLfloat);stdcall;
  qglcolor4i:procedure(red:TGLint;green:TGLint;blue:TGLint;alpha:TGLint);stdcall;
  qglcolor4iv:procedure(v:PGLint);stdcall;
  qglcolor4s:procedure(red:TGLshort;green:TGLshort;blue:TGLshort;alpha:TGLshort);stdcall;
  qglcolor4sv:procedure(v:PGLshort);stdcall;
  qglcolor4ub:procedure(red:TGLubyte;green:TGLubyte;blue:TGLubyte;alpha:TGLubyte);stdcall;
  qglcolor4ubv:procedure(v:PGLubyte);stdcall;
  qglcolor4ui:procedure(red:TGLuint;green:TGLuint;blue:TGLuint;alpha:TGLuint);stdcall;
  qglcolor4uiv:procedure(v:PGLuint);stdcall;
  qglcolor4us:procedure(red:TGLushort;green:TGLushort;blue:TGLushort;alpha:TGLushort);stdcall;
  qglcolor4usv:procedure(v:PGLushort);stdcall;
  qglcolormask:procedure(red:TGLboolean;green:TGLboolean;blue:TGLboolean;alpha:TGLboolean);stdcall;
  qglcolormaterial:procedure(face:TGLenum;mode:TGLenum);stdcall;
  qglcolorpointer:procedure(size:TGLint;_type:TGLenum;stride:TGLsizei;const p:pointer);stdcall;
  qglcopypixels:procedure(x:TGLint;y:TGLint;width:TGLsizei;height:TGLsizei;_type:TGLenum);stdcall;
  qglcopyteximage1d:procedure(target:TGLenum;level:TGLint;internalformat:TGLenum;x:TGLint;y:TGLint;width:TGLsizei;border:TGLint);stdcall;
  qglcopyteximage2d:procedure(target:TGLenum;level:TGLint;internalformat:TGLenum;x:TGLint;y:TGLint;width:TGLsizei;height:TGLsizei;border:TGLint);stdcall;
  qglcopytexsubimage1d:procedure(target:TGLenum;level:TGLint;xoffset:TGLint;x:TGLint;y:TGLint;width:TGLsizei);stdcall;
  qglcopytexsubimage2d:procedure(target:TGLenum;level:TGLint;xoffset:TGLint;yoffset:TGLint;x:TGLint;y:TGLint;width:TGLsizei;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:TGLclampd;zfar:TGLclampd);stdcall;
  qgldisable:procedure(cap:TGLenum);stdcall;
  qgldisableclientstate:procedure(_array:TGLenum);stdcall;
  qgldrawarrays:procedure(mode:TGLenum;first:TGLint;count:TGLsizei);stdcall;
  qgldrawbuffer:procedure(mode:TGLenum);stdcall;
  qgldrawelements:procedure(mode:TGLenum;count:TGLsizei;_type:TGLenum;const indices:pointer);stdcall;
  qgldrawpixels:procedure(width:TGLsizei;height:TGLsizei;format:TGLenum;_type:TGLenum;const pixels:pointer);stdcall;
  qgledgeflag:procedure(flag:TGLboolean);stdcall;
  qgledgeflagpointer:procedure(stride:TGLsizei;const p:pointer);stdcall;
  qgledgeflagv:procedure(flag:PGLboolean);stdcall;
  qglenable:procedure(cap:TGLenum);stdcall;
  qglenableclientstate:procedure(_array: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:TGLdouble;v:TGLdouble);stdcall;
  qglevalcoord2dv:procedure(u:PGLdouble);stdcall;
  qglevalcoord2f:procedure(u:TGLfloat;v:TGLfloat);stdcall;
  qglevalcoord2fv:procedure(u:PGLfloat);stdcall;
  qglevalmesh1:procedure(mode:TGLenum;i1:TGLint;i2:TGLint);stdcall;
  qglevalmesh2:procedure(mode:TGLenum;i1:TGLint;i2:TGLint;j1:TGLint;j2:TGLint);stdcall;
  qglevalpoint1:procedure(i:TGLint);stdcall;
  qglevalpoint2:procedure(i:TGLint;j:TGLint);stdcall;
  qglfeedbackbuffer:procedure(size:TGLsizei;_type: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:TGLdouble;right:TGLdouble;bottom:TGLdouble;top:TGLdouble;znear:TGLdouble;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:TGLenum;pname:TGLenum;params:PGLfloat);stdcall;
  qglgetlightiv:procedure(light:TGLenum;pname:TGLenum;params:PGLint);stdcall;
  qglgetmapdv:procedure(target:TGLenum;query:TGLenum;v:PGLdouble);stdcall;
  qglgetmapfv:procedure(target:TGLenum;query:TGLenum;v:PGLfloat);stdcall;
  qglgetmapiv:procedure(target:TGLenum;query:TGLenum;v:PGLint);stdcall;
  qglgetmaterialfv:procedure(face:TGLenum;pname:TGLenum;params:PGLfloat);stdcall;
  qglgetmaterialiv:procedure(face:TGLenum;pname:TGLenum;params:PGLint);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:TGLenum;pname:TGLenum;params:PGLfloat);stdcall;
  qglgettexenviv:procedure(target:TGLenum;pname:TGLenum;params:PGLint);stdcall;
  qglgettexgendv:procedure(coord:TGLenum;pname:TGLenum;params:PGLdouble);stdcall;
  qglgettexgenfv:procedure(coord:TGLenum;pname:TGLenum;params:PGLfloat);stdcall;
  qglgettexgeniv:procedure(coord:TGLenum;pname:TGLenum;params:PGLint);stdcall;
  qglgetteximage:procedure(target:TGLenum;level:TGLint;format:TGLenum;_type:TGLenum;pixels:pointer);stdcall;
  qglgettexlevelparameterfv:procedure(target:TGLenum;level:TGLint;pname:TGLenum;params:PGLfloat);stdcall;
  qglgettexlevelparameteriv:procedure(target:TGLenum;level:TGLint;pname:TGLenum;params:PGLint);stdcall;
  qglgettexparameterfv:procedure(target:TGLenum;pname:TGLenum;params:PGLfloat);stdcall;
  qglgettexparameteriv:procedure(target:TGLenum;pname:TGLenum;params:PGLint);stdcall;
  qglhint:procedure(target:TGLenum;mode:TGLenum);stdcall;
  qglindexmask:procedure(mask:TGLuint);stdcall;
  qglindexpointer:procedure(_type:TGLenum;stride:TGLsizei;p: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;p: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:TGLenum;pname:TGLenum;param:TGLfloat);stdcall;
  qgllightfv:procedure(light:TGLenum;pname:TGLenum;params:PGLfloat);stdcall;
  qgllighti:procedure(light:TGLenum;pname:TGLenum;param:TGLint);stdcall;
  qgllightiv:procedure(light:TGLenum;pname:TGLenum;params:PGLint);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:TGLdouble;u2:TGLdouble;stride:TGLint;order:TGLint;points:PGLdouble);stdcall;
  qglmap1f:procedure(target:TGLenum;u1:TGLfloat;u2:TGLfloat;stride:TGLint;order:TGLint;points:PGLfloat);stdcall;
  qglmap2d:procedure(target:TGLenum;u1:TGLdouble;u2:TGLdouble;ustride:TGLint;uorder:TGLint;v1:TGLdouble;v2:TGLdouble;vstride:TGLint;vorder:TGLint;points:PGLdouble);stdcall;
  qglmap2f:procedure(target:TGLenum;u1:TGLfloat;u2:TGLfloat;ustride:TGLint;uorder:TGLint;v1:TGLfloat;v2:TGLfloat;vstride:TGLint;vorder:TGLint;points:PGLfloat);stdcall;
  qglmapgrid1d:procedure(un:TGLint;u1:TGLdouble;u2:TGLdouble);stdcall;
  qglmapgrid1f:procedure(un:TGLint;u1:TGLfloat;u2:TGLfloat);stdcall;
  qglmapgrid2d:procedure(un:TGLint;u1:TGLdouble;u2:TGLdouble;vn:TGLint;v1:TGLdouble;v2:TGLdouble);stdcall;
  qglmapgrid2f:procedure(un:TGLint;u1:TGLfloat;u2:TGLfloat;vn:TGLint;v1:TGLfloat;v2:TGLfloat);stdcall;
  qglmaterialf:procedure(face:TGLenum;pname:TGLenum;param:TGLfloat);stdcall;
  qglmaterialfv:procedure(face:TGLenum;pname:TGLenum;params:PGLfloat);stdcall;