gl.pas

一款RPG游戏的引擎可以自己制作一款RPG游戏的引擎可以自己制作

  glGetTexLevelParameterfv: procedure(target: GLenum; level: GLint; pname: GLenum; params: Pointer); stdcall;
  glGetTexLevelParameteriv: procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); stdcall;
  glGetTexParameterfv: procedure(target, pname: GLenum; params: PGLfloat); stdcall;
  glGetTexParameteriv: procedure(target, pname: GLenum; params: PGLint); stdcall;
  glHint: procedure(target, mode: GLenum); stdcall;
  glIndexMask: procedure(mask: GLuint); stdcall;
  glIndexPointer: procedure(atype: GLenum; stride: GLsizei; const pointer: Pointer); stdcall;
  glIndexd: procedure(c: GLdouble); stdcall;
  glIndexdv: procedure(const c: PGLdouble); stdcall;
  glIndexf: procedure(c: GLfloat); stdcall;
  glIndexfv: procedure(const c: PGLfloat); stdcall;
  glIndexi: procedure(c: GLint); stdcall;
  glIndexiv: procedure(const c: PGLint); stdcall;
  glIndexs: procedure(c: GLshort); stdcall;
  glIndexsv: procedure(const c: PGLshort); stdcall;
  glIndexub: procedure(c: GLubyte); stdcall;
  glIndexubv: procedure(const c: PGLubyte); stdcall;
  glInitNames: procedure; stdcall;
  glInterleavedArrays: procedure(format: GLenum; stride: GLsizei; const pointer: Pointer); stdcall;
  glIsEnabled: function(cap: GLenum): GLboolean; stdcall;
  glIsList: function(list: GLuint): GLboolean; stdcall;
  glIsTexture: function(texture: GLuint): GLboolean; stdcall;
  glLightModelf: procedure(pname: GLenum; param: GLfloat); stdcall;
  glLightModelfv: procedure(pname: GLenum; const params: PGLfloat); stdcall;
  glLightModeli: procedure(pname: GLenum; param: GLint); stdcall;
  glLightModeliv: procedure(pname: GLenum; const params: PGLint); stdcall;
  glLightf: procedure(light, pname: GLenum; param: GLfloat); stdcall;
  glLightfv: procedure(light, pname: GLenum; const params: PGLfloat); stdcall;
  glLighti: procedure(light, pname: GLenum; param: GLint); stdcall;
  glLightiv: procedure(light, pname: GLenum; const params: GLint); stdcall;
  glLineStipple: procedure(factor: GLint; pattern: GLushort); stdcall;
  glLineWidth: procedure(width: GLfloat); stdcall;
  glListBase: procedure(base: GLuint); stdcall;
  glLoadIdentity: procedure; stdcall;
  glLoadMatrixd: procedure(const m: PGLdouble); stdcall;
  glLoadMatrixf: procedure(const m: PGLfloat); stdcall;
  glLoadName: procedure(name: GLuint); stdcall;
  glLogicOp: procedure(opcode: GLenum); stdcall;
  glMap1d: procedure(target: GLenum; u1, u2: GLdouble; stride, order: GLint; const points: PGLdouble); stdcall;
  glMap1f: procedure(target: GLenum; u1, u2: GLfloat; stride, order: GLint; const points: PGLfloat); stdcall;
  glMap2d: procedure(target: GLenum; u1, u2: GLdouble; ustride, uorder: GLint; v1, v2: GLdouble; vstride, vorder: GLint; const points: PGLdouble); stdcall;
  glMap2f: procedure(target: GLenum; u1, u2: GLfloat; ustride, uorder: GLint; v1, v2: GLfloat; vstride, vorder: GLint; const points: PGLfloat); stdcall;
  glMapGrid1d: procedure(un: GLint; u1, u2: GLdouble); stdcall;
  glMapGrid1f: procedure(un: GLint; u1, u2: GLfloat); stdcall;
  glMapGrid2d: procedure(un: GLint; u1, u2: GLdouble; vn: GLint; v1, v2: GLdouble); stdcall;
  glMapGrid2f: procedure(un: GLint; u1, u2: GLfloat; vn: GLint; v1, v2: GLfloat); stdcall;
  glMaterialf: procedure(face, pname: GLenum; param: GLfloat); stdcall;
  glMaterialfv: procedure(face, pname: GLenum; const params: PGLfloat); stdcall;
  glMateriali: procedure(face, pname: GLenum; param: GLint); stdcall;
  glMaterialiv: procedure(face, pname: GLenum; const params: PGLint); stdcall;
  glMatrixMode: procedure(mode: GLenum); stdcall;
  glMultMatrixd: procedure(const m: PGLdouble); stdcall;
  glMultMatrixf: procedure(const m: PGLfloat); stdcall;
  glNewList: procedure(list: GLuint; mode: GLenum); stdcall;
  glNormal3b: procedure(nx, ny, nz: GLbyte); stdcall;
  glNormal3bv: procedure(const v: PGLbyte); stdcall;
  glNormal3d: procedure(nx, ny, nz: GLdouble); stdcall;
  glNormal3dv: procedure(const v: PGLdouble); stdcall;
  glNormal3f: procedure(nx, ny, nz: GLfloat); stdcall;
  glNormal3fv: procedure(const v: PGLfloat); stdcall;
  glNormal3i: procedure(nx, ny, nz: GLint); stdcall;
  glNormal3iv: procedure(const v: PGLint); stdcall;
  glNormal3s: procedure(nx, ny, nz: GLshort); stdcall;
  glNormal3sv: procedure(const v: PGLshort); stdcall;
  glNormalPointer: procedure(atype: GLenum; stride: GLsizei; const pointer: Pointer); stdcall;
  glOrtho: procedure(left, right, bottom, top, zNear, zFar: GLdouble); stdcall;
  glPassThrough: procedure(token: GLfloat); stdcall;
  glPixelMapfv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLfloat); stdcall;
  glPixelMapuiv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLuint); stdcall;
  glPixelMapusv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLushort); stdcall;
  glPixelStoref: procedure(pname: GLenum; param: GLfloat); stdcall;
  glPixelStorei: procedure(pname: GLenum; param: GLint); stdcall;
  glPixelTransferf: procedure(pname: GLenum; param: GLfloat); stdcall;
  glPixelTransferi: procedure(pname: GLenum; param: GLint); stdcall;
  glPixelZoom: procedure(xfactor, yfactor: GLfloat); stdcall;
  glPointSize: procedure(size: GLfloat); stdcall;
  glPolygonMode: procedure(face, mode: GLenum); stdcall;
  glPolygonOffset: procedure(factor, units: GLfloat); stdcall;
  glPolygonStipple: procedure(const mask: PGLubyte); stdcall;
  glPopAttrib: procedure; stdcall;
  glPopClientAttrib: procedure; stdcall;
  glPopMatrix: procedure; stdcall;
  glPopName: procedure; stdcall;
  glPrioritizeTextures: procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); stdcall;
  glPushAttrib: procedure(mask: GLbitfield); stdcall;
  glPushClientAttrib: procedure(mask: GLbitfield); stdcall;
  glPushMatrix: procedure; stdcall;
  glPushName: procedure(name: GLuint); stdcall;
  glRasterPos2d: procedure(x, y: GLdouble); stdcall;
  glRasterPos2dv: procedure(const v: PGLdouble); stdcall;
  glRasterPos2f: procedure(x, y: GLfloat); stdcall;
  glRasterPos2fv: procedure(const v: PGLfloat); stdcall;
  glRasterPos2i: procedure(x, y: GLint); stdcall;
  glRasterPos2iv: procedure(const v: PGLint); stdcall;
  glRasterPos2s: procedure(x, y: GLshort); stdcall;
  glRasterPos2sv: procedure(const v: PGLshort); stdcall;
  glRasterPos3d: procedure(x, y, z: GLdouble); stdcall;
  glRasterPos3dv: procedure(const v: PGLdouble); stdcall;
  glRasterPos3f: procedure(x, y, z: GLfloat); stdcall;
  glRasterPos3fv: procedure(const v: PGLfloat); stdcall;
  glRasterPos3i: procedure(x, y, z: GLint); stdcall;
  glRasterPos3iv: procedure(const v: PGLint); stdcall;
  glRasterPos3s: procedure(x, y, z: GLshort); stdcall;
  glRasterPos3sv: procedure(const v: PGLshort); stdcall;
  glRasterPos4d: procedure(x, y, z, w: GLdouble); stdcall;
  glRasterPos4dv: procedure(const v: PGLdouble); stdcall;
  glRasterPos4f: procedure(x, y, z, w: GLfloat); stdcall;
  glRasterPos4fv: procedure(const v: PGLfloat); stdcall;
  glRasterPos4i: procedure(x, y, z, w: GLint); stdcall;
  glRasterPos4iv: procedure(const v: PGLint); stdcall;
  glRasterPos4s: procedure(x, y, z, w: GLshort); stdcall;
  glRasterPos4sv: procedure(const v: PGLshort); stdcall;
  glReadBuffer: procedure(mode: GLenum); stdcall;
  glReadPixels: procedure(x, y: GLint; width, height: GLsizei; format, atype: GLenum; pixels: Pointer); stdcall;
  glRectd: procedure(x1, y1, x2, y2: GLdouble); stdcall;
  glRectdv: procedure(const v1: PGLdouble; const v2: PGLdouble); stdcall;
  glRectf: procedure(x1, y1, x2, y2: GLfloat); stdcall;
  glRectfv: procedure(const v1: PGLfloat; const v2: PGLfloat); stdcall;
  glRecti: procedure(x1, y1, x2, y2: GLint); stdcall;
  glRectiv: procedure(const v1: PGLint; const v2: PGLint); stdcall;
  glRects: procedure(x1, y1, x2, y2: GLshort); stdcall;
  glRectsv: procedure(const v1: PGLshort; const v2: PGLshort); stdcall;
  glRenderMode: function(mode: GLint): GLint; stdcall;
  glRotated: procedure(angle, x, y, z: GLdouble); stdcall;
  glRotatef: procedure(angle, x, y, z: GLfloat); stdcall;
  glScaled: procedure(x, y, z: GLdouble); stdcall;
  glScalef: procedure(x, y, z: GLfloat); stdcall;
  glScissor: procedure(x, y: GLint; width, height: GLsizei); stdcall;
  glSelectBuffer: procedure(size: GLsizei; buffer: PGLuint); stdcall;
  glShadeModel: procedure(mode: GLenum); stdcall;
  glStencilFunc: procedure(func: GLenum; ref: GLint; mask: GLuint); stdcall;
  glStencilMask: procedure(mask: GLuint); stdcall;
  glStencilOp: procedure(fail, zfail, zpass: GLenum); stdcall;
  glTexCoord1d: procedure(s: GLdouble); stdcall;
  glTexCoord1dv: procedure(const v: PGLdouble); stdcall;
  glTexCoord1f: procedure(s: GLfloat); stdcall;
  glTexCoord1fv: procedure(const v: PGLfloat); stdcall;
  glTexCoord1i: procedure(s: GLint); stdcall;
  glTexCoord1iv: procedure(const v: PGLint); stdcall;
  glTexCoord1s: procedure(s: GLshort); stdcall;
  glTexCoord1sv: procedure(const v: PGLshort); stdcall;
  glTexCoord2d: procedure(s, t: GLdouble); stdcall;
  glTexCoord2dv: procedure(const v: PGLdouble); stdcall;
  glTexCoord2f: procedure(s, t: GLfloat); stdcall;
  glTexCoord2fv: procedure(const v: PGLfloat); stdcall;
  glTexCoord2i: procedure(s, t: GLint); stdcall;
  glTexCoord2iv: procedure(const v: PGLint); stdcall;
  glTexCoord2s: procedure(s, t: GLshort); stdcall;
  glTexCoord2sv: procedure(const v: PGLshort); stdcall;
  glTexCoord3d: procedure(s, t, r: GLdouble); stdcall;
  glTexCoord3dv: procedure(const v: PGLdouble); stdcall;
  glTexCoord3f: procedure(s, t, r: GLfloat); stdcall;
  glTexCoord3fv: procedure(const v: PGLfloat); stdcall;
  glTexCoord3i: procedure(s, t, r: GLint); stdcall;
  glTexCoord3iv: procedure(const v: PGLint); stdcall;
  glTexCoord3s: procedure(s, t, r: GLshort); stdcall;
  glTexCoord3sv: procedure(const v: PGLshort); stdcall;
  glTexCoord4d: procedure(s, t, r, q: GLdouble); stdcall;
  glTexCoord4dv: procedure(const v: PGLdouble); stdcall;
  glTexCoord4f: procedure(s, t, r, q: GLfloat); stdcall;
  glTexCoord4fv: procedure(const v: PGLfloat); stdcall;
  glTexCoord4i: procedure(s, t, r, q: GLint); stdcall;
  glTexCoord4iv: procedure(const v: PGLint); stdcall;
  glTexCoord4s: procedure(s, t, r, q: GLshort); stdcall;
  glTexCoord4sv: procedure(const v: PGLshort); stdcall;
  glTexCoordPointer: procedure(size: GLint; atype: GLenum; stride: GLsizei; const pointer: Pointer); stdcall;
  glTexEnvf: procedure(target: GLenum; pname: GLenum; param: GLfloat); stdcall;
  glTexEnvfv: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); stdcall;
  glTexEnvi: procedure(target: GLenum; pname: GLenum; param: GLint); stdcall;
  glTexEnviv: procedure(target: GLenum; pname: GLenum; const params: PGLint); stdcall;
  glTexGend: procedure(coord: GLenum; pname: GLenum; param: GLdouble); stdcall;
  glTexGendv: procedure(coord: GLenum; pname: GLenum; const params: PGLdouble); stdcall;
  glTexGenf: procedure(coord: GLenum; pname: GLenum; param: GLfloat); stdcall;
  glTexGenfv: procedure(coord: GLenum; pname: GLenum; const params: PGLfloat); stdcall;
  glTexGeni: procedure(coord: GLenum; pname: GLenum; param: GLint); stdcall;
  glTexGeniv: procedure(coord: GLenum; pname: GLenum; const params: PGLint); stdcall;
  glTexImage1D: procedure(target: GLenum; level, internalformat: GLint; width: GLsizei; border: GLint; format, atype: GLenum; const pixels: Pointer); stdcall;
  glTexImage2D: procedure(target: GLenum; level, internalformat: GLint; width, height: GLsizei; border: GLint; format, atype: GLenum; const pixels: Pointer); stdcall;
  glTexParameterf: procedure(target: GLenum; pname: GLenum; param: GLfloat); stdcall;
  glTexParameterfv: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); stdcall;
  glTexParameteri: procedure(target: GLenum; pname: GLenum; param: GLint); stdcall;
  glTexParameteriv: procedure(target: GLenum; pname: GLenum; const params: PGLint); stdcall;
  glTexSubImage1D: procedure(target: GLenum; level, xoffset: GLint; width: GLsizei; format, atype: GLenum; const pixels: Pointer); stdcall;
  glTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset: GLint; width, height: GLsizei; format, atype: GLenum; const pixels: Pointer); stdcall;
  glTranslated: procedure(x, y, z: GLdouble); stdcall;
  glTranslatef: procedure(x, y, z: GLfloat); stdcall;
  glVertex2d: procedure(x, y: GLdouble); stdcall;
  glVertex2dv: procedure(const v: PGLdouble); stdcall;
  glVertex2f: procedure(x, y: GLfloat); stdcall;
  glVertex2fv: procedure(const v: PGLfloat); stdcall;
  glVertex2i: procedure(x, y: GLint); stdcall;
  glVertex2iv: procedure(const v: PGLint); stdcall;
  glVertex2s: procedure(x, y: GLshort); stdcall;
  glVertex2sv: procedure(const v: PGLshort); stdcall;
  glVertex3d: procedure(x, y, z: GLdouble); stdcall;
  glVertex3dv: procedure(const v: PGLdouble); stdcall;
  glVertex3f: procedure(x, y, z: GLfloat); stdcall;
  glVertex3fv: procedure(const v: PGLfloat); stdcall;
  glVertex3i: procedure(x, y, z: GLint); stdcall;
  glVertex3iv: procedure(const v: PGLint); stdcall;
  glVertex3s: procedure(x, y, z: GLshort); stdcall;
  glVertex3sv: procedure(const v: PGLshort); stdcall;
  glVertex4d: procedure(x, y, z, w: GLdouble); stdcall;
  glVertex4dv: procedure(const v: PGLdouble); stdcall;
  glVertex4f: procedure(x, y, z, w: GLfloat); stdcall;
  glVertex4fv: procedure(const v: PGLfloat); stdcall;
  glVertex4i: procedure(x, y, z, w: GLint); stdcall;
  glVertex4iv: procedure(const v: PGLint); stdcall;
  glVertex4s: procedure(x, y, z, w: GLshort); stdcall;
  glVertex4sv: procedure(const v: PGLshort); stdcall;
  glVertexPointer: procedure(size: GLint; atype: GLenum; stride: GLsizei; const pointer: Pointer); stdcall;
  glViewport: procedure(x, y: GLint; width, height: GLsizei); stdcall;
  ChoosePixelFormat: function(DC: HDC; p2: PPixelFormatDescriptor): Integer; stdcall;

type
  // EXT_vertex_array
  PFNGLARRAYELEMENTEXTPROC = procedure(i: GLint);
  PFNGLDRAWARRAYSEXTPROC = procedure(mode: GLenum; first: GLint; count: GLsizei);
  PFNGLVERTEXPOINTEREXTPROC = procedure(size: GLint; atype: GLenum;
                                        stride, count: GLsizei; const pointer: Pointer);
  PFNGLNORMALPOINTEREXTPROC = procedure(atype: GLenum; stride, count: GLsizei;
                                        const pointer: Pointer);
  PFNGLCOLORPOINTEREXTPROC = procedure(size: GLint; atype: GLenum; stride, count: GLsizei;
                                       const pointer: Pointer);
  PFNGLINDEXPOINTEREXTPROC = procedure(atype: GLenum; stride, count: GLsizei;
                                       const pointer: Pointer);
  PFNGLTEXCOORDPOINTEREXTPROC = procedure(size: GLint; atype: GLenum;
                                          stride, count: GLsizei; const pointer: Pointer);
  PFNGLEDGEFLAGPOINTEREXTPROC = procedure(stride, count: GLsizei;
                                          const pointer: PGLboolean);
  PFNGLGETPOINTERVEXTPROC = procedure(pname: GLenum; params: Pointer);
  PFNGLARRAYELEMENTARRAYEXTPROC = procedure(mode: GLenum; count: GLsizei;
                                            const pi: Pointer);

  // WIN_swap_hint
  PFNGLADDSWAPHINTRECTWINPROC = procedure(x, y: GLint; width, height: GLsizei);

  // EXT_paletted_texture
  PFNGLCOLORTABLEEXTPROC = procedure(target, internalFormat: GLenum; width: GLsizei;
                                     format, atype: GLenum; const data: Pointer);
  PFNGLCOLORSUBTABLEEXTPROC = procedure(target: GLenum; start, count: GLsizei;
                                        format, atype: GLenum; const data: Pointer);
  PFNGLGETCOLORTABLEEXTPROC = procedure(target, format, atype: GLenum; data: Pointer);
  PFNGLGETCOLORTABLEPARAMETERIVEXTPROC = procedure(target, pname: GLenum; params: PGLint);
  PFNGLGETCOLORTABLEPARAMETERFVEXTPROC = procedure(target, pname: GLenum; params: PGLfloat);

procedure LoadOpenGL(const dll: String);
procedure FreeOpenGL;

implementation

var
  hDLL: THandle;

procedure FreeOpenGL;
begin

  @glAccum := nil;
  @glAlphaFunc := nil;
  @glAreTexturesResident := nil;
  @glArrayElement := nil;
  @glBegin := nil;
  @glBindTexture := nil;
  @glBitmap := nil;
  @glBlendFunc := nil;
  @glCallList := nil;
  @glCallLists := nil;
  @glClear := nil;
  @glClearAccum := nil;
  @glClearColor := nil;
  @glClearDepth := nil;
  @glClearIndex := nil;
  @glClearStencil := nil;
  @glClipPlane := nil;
  @glColor3b := nil;
  @glColor3bv := nil;
  @glColor3d := nil;
  @glColor3dv := nil;
  @glColor3f := nil;
  @glColor3fv := nil;
  @glColor3i := nil;
  @glColor3iv := nil;
  @glColor3s := nil;
  @glColor3sv := nil;
  @glColor3ub := nil;
  @glColor3ubv := nil;
  @glColor3ui := nil;
  @glColor3uiv := nil;
  @glColor3us := nil;
  @glColor3usv := nil;
  @glColor4b := nil;
  @glColor4bv := nil;
  @glColor4d := nil;
  @glColor4dv := nil;
  @glColor4f := nil;
  @glColor4fv := nil;
  @glColor4i := nil;
  @glColor4iv := nil;
  @glColor4s := nil;
  @glColor4sv := nil;
  @glColor4ub := nil;
  @glColor4ubv := nil;
  @glColor4ui := nil;
  @glColor4uiv := nil;
  @glColor4us := nil;
  @glColor4usv := nil;
  @glColorMask := nil;
  @glColorMaterial := nil;
  @glColorPointer := nil;
  @glCopyPixels := nil;
  @glCopyTexImage1D := nil;
  @