* exception patch from Ales Katona

git-svn-id: trunk@463 -

packages/extra/opengl/gl.pp

@@ -1891,354 +1891,370 @@ begin
 end;
 
 procedure LoadOpenGL(const dll: String);
+var
+  MethodName: string = '';
+
+  function GetGLProcAddress(Lib: PtrInt; ProcName: PChar): Pointer;
+  begin
+    MethodName:=ProcName;
+    Result:=GetProcAddress(Lib, ProcName);
+  end;
+
 begin
 
   FreeOpenGL;
 
   LibGL := LoadLibrary(PChar(dll));
   if LibGL = 0 then raise Exception.Create('Could not load OpenGL from ' + dll);
-
-  @glAccum := GetProcAddress(LibGL, 'glAccum');
-  @glAlphaFunc := GetProcAddress(LibGL, 'glAlphaFunc');
-  @glAreTexturesResident := GetProcAddress(LibGL, 'glAreTexturesResident');
-  @glArrayElement := GetProcAddress(LibGL, 'glArrayElement');
-  @glBegin := GetProcAddress(LibGL, 'glBegin');
-  @glBindTexture := GetProcAddress(LibGL, 'glBindTexture');
-  @glBitmap := GetProcAddress(LibGL, 'glBitmap');
-  @glBlendFunc := GetProcAddress(LibGL, 'glBlendFunc');
-  @glCallList := GetProcAddress(LibGL, 'glCallList');
-  @glCallLists := GetProcAddress(LibGL, 'glCallLists');
-  @glClear := GetProcAddress(LibGL, 'glClear');
-  @glClearAccum := GetProcAddress(LibGL, 'glClearAccum');
-  @glClearColor := GetProcAddress(LibGL, 'glClearColor');
-  @glClearDepth := GetProcAddress(LibGL, 'glClearDepth');
-  @glClearIndex := GetProcAddress(LibGL, 'glClearIndex');
-  @glClearStencil := GetProcAddress(LibGL, 'glClearStencil');
-  @glClipPlane := GetProcAddress(LibGL, 'glClipPlane');
-  @glColor3b := GetProcAddress(LibGL, 'glColor3b');
-  @glColor3bv := GetProcAddress(LibGL, 'glColor3bv');
-  @glColor3d := GetProcAddress(LibGL, 'glColor3d');
-  @glColor3dv := GetProcAddress(LibGL, 'glColor3dv');
-  @glColor3f := GetProcAddress(LibGL, 'glColor3f');
-  @glColor3fv := GetProcAddress(LibGL, 'glColor3fv');
-  @glColor3i := GetProcAddress(LibGL, 'glColor3i');
-  @glColor3iv := GetProcAddress(LibGL, 'glColor3iv');
-  @glColor3s := GetProcAddress(LibGL, 'glColor3s');
-  @glColor3sv := GetProcAddress(LibGL, 'glColor3sv');
-  @glColor3ub := GetProcAddress(LibGL, 'glColor3ub');
-  @glColor3ubv := GetProcAddress(LibGL, 'glColor3ubv');
-  @glColor3ui := GetProcAddress(LibGL, 'glColor3ui');
-  @glColor3uiv := GetProcAddress(LibGL, 'glColor3uiv');
-  @glColor3us := GetProcAddress(LibGL, 'glColor3us');
-  @glColor3usv := GetProcAddress(LibGL, 'glColor3usv');
-  @glColor4b := GetProcAddress(LibGL, 'glColor4b');
-  @glColor4bv := GetProcAddress(LibGL, 'glColor4bv');
-  @glColor4d := GetProcAddress(LibGL, 'glColor4d');
-  @glColor4dv := GetProcAddress(LibGL, 'glColor4dv');
-  @glColor4f := GetProcAddress(LibGL, 'glColor4f');
-  @glColor4fv := GetProcAddress(LibGL, 'glColor4fv');
-  @glColor4i := GetProcAddress(LibGL, 'glColor4i');
-  @glColor4iv := GetProcAddress(LibGL, 'glColor4iv');
-  @glColor4s := GetProcAddress(LibGL, 'glColor4s');
-  @glColor4sv := GetProcAddress(LibGL, 'glColor4sv');
-  @glColor4ub := GetProcAddress(LibGL, 'glColor4ub');
-  @glColor4ubv := GetProcAddress(LibGL, 'glColor4ubv');
-  @glColor4ui := GetProcAddress(LibGL, 'glColor4ui');
-  @glColor4uiv := GetProcAddress(LibGL, 'glColor4uiv');
-  @glColor4us := GetProcAddress(LibGL, 'glColor4us');
-  @glColor4usv := GetProcAddress(LibGL, 'glColor4usv');
-  @glColorMask := GetProcAddress(LibGL, 'glColorMask');
-  @glColorMaterial := GetProcAddress(LibGL, 'glColorMaterial');
-  @glColorPointer := GetProcAddress(LibGL, 'glColorPointer');
-  @glCopyPixels := GetProcAddress(LibGL, 'glCopyPixels');
-  @glCopyTexImage1D := GetProcAddress(LibGL, 'glCopyTexImage1D');
-  @glCopyTexImage2D := GetProcAddress(LibGL, 'glCopyTexImage2D');
-  @glCopyTexSubImage1D := GetProcAddress(LibGL, 'glCopyTexSubImage1D');
-  @glCopyTexSubImage2D := GetProcAddress(LibGL, 'glCopyTexSubImage2D');
-  @glCullFace := GetProcAddress(LibGL, 'glCullFace');
-  @glDeleteLists := GetProcAddress(LibGL, 'glDeleteLists');
-  @glDeleteTextures := GetProcAddress(LibGL, 'glDeleteTextures');
-  @glDepthFunc := GetProcAddress(LibGL, 'glDepthFunc');
-  @glDepthMask := GetProcAddress(LibGL, 'glDepthMask');
-  @glDepthRange := GetProcAddress(LibGL, 'glDepthRange');
-  @glDisable := GetProcAddress(LibGL, 'glDisable');
-  @glDisableClientState := GetProcAddress(LibGL, 'glDisableClientState');
-  @glDrawArrays := GetProcAddress(LibGL, 'glDrawArrays');
-  @glDrawBuffer := GetProcAddress(LibGL, 'glDrawBuffer');
-  @glDrawElements := GetProcAddress(LibGL, 'glDrawElements');
-  @glDrawPixels := GetProcAddress(LibGL, 'glDrawPixels');
-  @glEdgeFlag := GetProcAddress(LibGL, 'glEdgeFlag');
-  @glEdgeFlagPointer := GetProcAddress(LibGL, 'glEdgeFlagPointer');
-  @glEdgeFlagv := GetProcAddress(LibGL, 'glEdgeFlagv');
-  @glEnable := GetProcAddress(LibGL, 'glEnable');
-  @glEnableClientState := GetProcAddress(LibGL, 'glEnableClientState');
-  @glEnd := GetProcAddress(LibGL, 'glEnd');
-  @glEndList := GetProcAddress(LibGL, 'glEndList');
-  @glEvalCoord1d := GetProcAddress(LibGL, 'glEvalCoord1d');
-  @glEvalCoord1dv := GetProcAddress(LibGL, 'glEvalCoord1dv');
-  @glEvalCoord1f := GetProcAddress(LibGL, 'glEvalCoord1f');
-  @glEvalCoord1fv := GetProcAddress(LibGL, 'glEvalCoord1fv');
-  @glEvalCoord2d := GetProcAddress(LibGL, 'glEvalCoord2d');
-  @glEvalCoord2dv := GetProcAddress(LibGL, 'glEvalCoord2dv');
-  @glEvalCoord2f := GetProcAddress(LibGL, 'glEvalCoord2f');
-  @glEvalCoord2fv := GetProcAddress(LibGL, 'glEvalCoord2fv');
-  @glEvalMesh1 := GetProcAddress(LibGL, 'glEvalMesh1');
-  @glEvalMesh2 := GetProcAddress(LibGL, 'glEvalMesh2');
-  @glEvalPoint1 := GetProcAddress(LibGL, 'glEvalPoint1');
-  @glEvalPoint2 := GetProcAddress(LibGL, 'glEvalPoint2');
-  @glFeedbackBuffer := GetProcAddress(LibGL, 'glFeedbackBuffer');
-  @glFinish := GetProcAddress(LibGL, 'glFinish');
-  @glFlush := GetProcAddress(LibGL, 'glFlush');
-  @glFogf := GetProcAddress(LibGL, 'glFogf');
-  @glFogfv := GetProcAddress(LibGL, 'glFogfv');
-  @glFogi := GetProcAddress(LibGL, 'glFogi');
-  @glFogiv := GetProcAddress(LibGL, 'glFogiv');
-  @glFrontFace := GetProcAddress(LibGL, 'glFrontFace');
-  @glFrustum := GetProcAddress(LibGL, 'glFrustum');
-  @glGenLists := GetProcAddress(LibGL, 'glGenLists');
-  @glGenTextures := GetProcAddress(LibGL, 'glGenTextures');
-  @glGetBooleanv := GetProcAddress(LibGL, 'glGetBooleanv');
-  @glGetClipPlane := GetProcAddress(LibGL, 'glGetClipPlane');
-  @glGetDoublev := GetProcAddress(LibGL, 'glGetDoublev');
-  @glGetError := GetProcAddress(LibGL, 'glGetError');
-  @glGetFloatv := GetProcAddress(LibGL, 'glGetFloatv');
-  @glGetIntegerv := GetProcAddress(LibGL, 'glGetIntegerv');
-  @glGetLightfv := GetProcAddress(LibGL, 'glGetLightfv');
-  @glGetLightiv := GetProcAddress(LibGL, 'glGetLightiv');
-  @glGetMapdv := GetProcAddress(LibGL, 'glGetMapdv');
-  @glGetMapfv := GetProcAddress(LibGL, 'glGetMapfv');
-  @glGetMapiv := GetProcAddress(LibGL, 'glGetMapiv');
-  @glGetMaterialfv := GetProcAddress(LibGL, 'glGetMaterialfv');
-  @glGetMaterialiv := GetProcAddress(LibGL, 'glGetMaterialiv');
-  @glGetPixelMapfv := GetProcAddress(LibGL, 'glGetPixelMapfv');
-  @glGetPixelMapuiv := GetProcAddress(LibGL, 'glGetPixelMapuiv');
-  @glGetPixelMapusv := GetProcAddress(LibGL, 'glGetPixelMapusv');
-  @glGetPointerv := GetProcAddress(LibGL, 'glGetPointerv');
-  @glGetPolygonStipple := GetProcAddress(LibGL, 'glGetPolygonStipple');
-  @glGetString := GetProcAddress(LibGL, 'glGetString');
-  @glGetTexEnvfv := GetProcAddress(LibGL, 'glGetTexEnvfv');
-  @glGetTexEnviv := GetProcAddress(LibGL, 'glGetTexEnviv');
-  @glGetTexGendv := GetProcAddress(LibGL, 'glGetTexGendv');
-  @glGetTexGenfv := GetProcAddress(LibGL, 'glGetTexGenfv');
-  @glGetTexGeniv := GetProcAddress(LibGL, 'glGetTexGeniv');
-  @glGetTexImage := GetProcAddress(LibGL, 'glGetTexImage');
-  @glGetTexLevelParameterfv := GetProcAddress(LibGL, 'glGetTexLevelParameterfv');
-  @glGetTexLevelParameteriv := GetProcAddress(LibGL, 'glGetTexLevelParameteriv');
-  @glGetTexParameterfv := GetProcAddress(LibGL, 'glGetTexParameterfv');
-  @glGetTexParameteriv := GetProcAddress(LibGL, 'glGetTexParameteriv');
-  @glHint := GetProcAddress(LibGL, 'glHint');
-  @glIndexMask := GetProcAddress(LibGL, 'glIndexMask');
-  @glIndexPointer := GetProcAddress(LibGL, 'glIndexPointer');
-  @glIndexd := GetProcAddress(LibGL, 'glIndexd');
-  @glIndexdv := GetProcAddress(LibGL, 'glIndexdv');
-  @glIndexf := GetProcAddress(LibGL, 'glIndexf');
-  @glIndexfv := GetProcAddress(LibGL, 'glIndexfv');
-  @glIndexi := GetProcAddress(LibGL, 'glIndexi');
-  @glIndexiv := GetProcAddress(LibGL, 'glIndexiv');
-  @glIndexs := GetProcAddress(LibGL, 'glIndexs');
-  @glIndexsv := GetProcAddress(LibGL, 'glIndexsv');
-  @glIndexub := GetProcAddress(LibGL, 'glIndexub');
-  @glIndexubv := GetProcAddress(LibGL, 'glIndexubv');
-  @glInitNames := GetProcAddress(LibGL, 'glInitNames');
-  @glInterleavedArrays := GetProcAddress(LibGL, 'glInterleavedArrays');
-  @glIsEnabled := GetProcAddress(LibGL, 'glIsEnabled');
-  @glIsList := GetProcAddress(LibGL, 'glIsList');
-  @glIsTexture := GetProcAddress(LibGL, 'glIsTexture');
-  @glLightModelf := GetProcAddress(LibGL, 'glLightModelf');
-  @glLightModelfv := GetProcAddress(LibGL, 'glLightModelfv');
-  @glLightModeli := GetProcAddress(LibGL, 'glLightModeli');
-  @glLightModeliv := GetProcAddress(LibGL, 'glLightModeliv');
-  @glLightf := GetProcAddress(LibGL, 'glLightf');
-  @glLightfv := GetProcAddress(LibGL, 'glLightfv');
-  @glLighti := GetProcAddress(LibGL, 'glLighti');
-  @glLightiv := GetProcAddress(LibGL, 'glLightiv');
-  @glLineStipple := GetProcAddress(LibGL, 'glLineStipple');
-  @glLineWidth := GetProcAddress(LibGL, 'glLineWidth');
-  @glListBase := GetProcAddress(LibGL, 'glListBase');
-  @glLoadIdentity := GetProcAddress(LibGL, 'glLoadIdentity');
-  @glLoadMatrixd := GetProcAddress(LibGL, 'glLoadMatrixd');
-  @glLoadMatrixf := GetProcAddress(LibGL, 'glLoadMatrixf');
-  @glLoadName := GetProcAddress(LibGL, 'glLoadName');
-  @glLogicOp := GetProcAddress(LibGL, 'glLogicOp');
-  @glMap1d := GetProcAddress(LibGL, 'glMap1d');
-  @glMap1f := GetProcAddress(LibGL, 'glMap1f');
-  @glMap2d := GetProcAddress(LibGL, 'glMap2d');
-  @glMap2f := GetProcAddress(LibGL, 'glMap2f');
-  @glMapGrid1d := GetProcAddress(LibGL, 'glMapGrid1d');
-  @glMapGrid1f := GetProcAddress(LibGL, 'glMapGrid1f');
-  @glMapGrid2d := GetProcAddress(LibGL, 'glMapGrid2d');
-  @glMapGrid2f := GetProcAddress(LibGL, 'glMapGrid2f');
-  @glMaterialf := GetProcAddress(LibGL, 'glMaterialf');
-  @glMaterialfv := GetProcAddress(LibGL, 'glMaterialfv');
-  @glMateriali := GetProcAddress(LibGL, 'glMateriali');
-  @glMaterialiv := GetProcAddress(LibGL, 'glMaterialiv');
-  @glMatrixMode := GetProcAddress(LibGL, 'glMatrixMode');
-  @glMultMatrixd := GetProcAddress(LibGL, 'glMultMatrixd');
-  @glMultMatrixf := GetProcAddress(LibGL, 'glMultMatrixf');
-  @glNewList := GetProcAddress(LibGL, 'glNewList');
-  @glNormal3b := GetProcAddress(LibGL, 'glNormal3b');
-  @glNormal3bv := GetProcAddress(LibGL, 'glNormal3bv');
-  @glNormal3d := GetProcAddress(LibGL, 'glNormal3d');
-  @glNormal3dv := GetProcAddress(LibGL, 'glNormal3dv');
-  @glNormal3f := GetProcAddress(LibGL, 'glNormal3f');
-  @glNormal3fv := GetProcAddress(LibGL, 'glNormal3fv');
-  @glNormal3i := GetProcAddress(LibGL, 'glNormal3i');
-  @glNormal3iv := GetProcAddress(LibGL, 'glNormal3iv');
-  @glNormal3s := GetProcAddress(LibGL, 'glNormal3s');
-  @glNormal3sv := GetProcAddress(LibGL, 'glNormal3sv');
-  @glNormalPointer := GetProcAddress(LibGL, 'glNormalPointer');
-  @glOrtho := GetProcAddress(LibGL, 'glOrtho');
-  @glPassThrough := GetProcAddress(LibGL, 'glPassThrough');
-  @glPixelMapfv := GetProcAddress(LibGL, 'glPixelMapfv');
-  @glPixelMapuiv := GetProcAddress(LibGL, 'glPixelMapuiv');
-  @glPixelMapusv := GetProcAddress(LibGL, 'glPixelMapusv');
-  @glPixelStoref := GetProcAddress(LibGL, 'glPixelStoref');
-  @glPixelStorei := GetProcAddress(LibGL, 'glPixelStorei');
-  @glPixelTransferf := GetProcAddress(LibGL, 'glPixelTransferf');
-  @glPixelTransferi := GetProcAddress(LibGL, 'glPixelTransferi');
-  @glPixelZoom := GetProcAddress(LibGL, 'glPixelZoom');
-  @glPointSize := GetProcAddress(LibGL, 'glPointSize');
-  @glPolygonMode := GetProcAddress(LibGL, 'glPolygonMode');
-  @glPolygonOffset := GetProcAddress(LibGL, 'glPolygonOffset');
-  @glPolygonStipple := GetProcAddress(LibGL, 'glPolygonStipple');
-  @glPopAttrib := GetProcAddress(LibGL, 'glPopAttrib');
-  @glPopClientAttrib := GetProcAddress(LibGL, 'glPopClientAttrib');
-  @glPopMatrix := GetProcAddress(LibGL, 'glPopMatrix');
-  @glPopName := GetProcAddress(LibGL, 'glPopName');
-  @glPrioritizeTextures := GetProcAddress(LibGL, 'glPrioritizeTextures');
-  @glPushAttrib := GetProcAddress(LibGL, 'glPushAttrib');
-  @glPushClientAttrib := GetProcAddress(LibGL, 'glPushClientAttrib');
-  @glPushMatrix := GetProcAddress(LibGL, 'glPushMatrix');
-  @glPushName := GetProcAddress(LibGL, 'glPushName');
-  @glRasterPos2d := GetProcAddress(LibGL, 'glRasterPos2d');
-  @glRasterPos2dv := GetProcAddress(LibGL, 'glRasterPos2dv');
-  @glRasterPos2f := GetProcAddress(LibGL, 'glRasterPos2f');
-  @glRasterPos2fv := GetProcAddress(LibGL, 'glRasterPos2fv');
-  @glRasterPos2i := GetProcAddress(LibGL, 'glRasterPos2i');
-  @glRasterPos2iv := GetProcAddress(LibGL, 'glRasterPos2iv');
-  @glRasterPos2s := GetProcAddress(LibGL, 'glRasterPos2s');
-  @glRasterPos2sv := GetProcAddress(LibGL, 'glRasterPos2sv');
-  @glRasterPos3d := GetProcAddress(LibGL, 'glRasterPos3d');
-  @glRasterPos3dv := GetProcAddress(LibGL, 'glRasterPos3dv');
-  @glRasterPos3f := GetProcAddress(LibGL, 'glRasterPos3f');
-  @glRasterPos3fv := GetProcAddress(LibGL, 'glRasterPos3fv');
-  @glRasterPos3i := GetProcAddress(LibGL, 'glRasterPos3i');
-  @glRasterPos3iv := GetProcAddress(LibGL, 'glRasterPos3iv');
-  @glRasterPos3s := GetProcAddress(LibGL, 'glRasterPos3s');
-  @glRasterPos3sv := GetProcAddress(LibGL, 'glRasterPos3sv');
-  @glRasterPos4d := GetProcAddress(LibGL, 'glRasterPos4d');
-  @glRasterPos4dv := GetProcAddress(LibGL, 'glRasterPos4dv');
-  @glRasterPos4f := GetProcAddress(LibGL, 'glRasterPos4f');
-  @glRasterPos4fv := GetProcAddress(LibGL, 'glRasterPos4fv');
-  @glRasterPos4i := GetProcAddress(LibGL, 'glRasterPos4i');
-  @glRasterPos4iv := GetProcAddress(LibGL, 'glRasterPos4iv');
-  @glRasterPos4s := GetProcAddress(LibGL, 'glRasterPos4s');
-  @glRasterPos4sv := GetProcAddress(LibGL, 'glRasterPos4sv');
-  @glReadBuffer := GetProcAddress(LibGL, 'glReadBuffer');
-  @glReadPixels := GetProcAddress(LibGL, 'glReadPixels');
-  @glRectd := GetProcAddress(LibGL, 'glRectd');
-  @glRectdv := GetProcAddress(LibGL, 'glRectdv');
-  @glRectf := GetProcAddress(LibGL, 'glRectf');
-  @glRectfv := GetProcAddress(LibGL, 'glRectfv');
-  @glRecti := GetProcAddress(LibGL, 'glRecti');
-  @glRectiv := GetProcAddress(LibGL, 'glRectiv');
-  @glRects := GetProcAddress(LibGL, 'glRects');
-  @glRectsv := GetProcAddress(LibGL, 'glRectsv');
-  @glRenderMode := GetProcAddress(LibGL, 'glRenderMode');
-  @glRotated := GetProcAddress(LibGL, 'glRotated');
-  @glRotatef := GetProcAddress(LibGL, 'glRotatef');
-  @glScaled := GetProcAddress(LibGL, 'glScaled');
-  @glScalef := GetProcAddress(LibGL, 'glScalef');
-  @glScissor := GetProcAddress(LibGL, 'glScissor');
-  @glSelectBuffer := GetProcAddress(LibGL, 'glSelectBuffer');
-  @glShadeModel := GetProcAddress(LibGL, 'glShadeModel');
-  @glStencilFunc := GetProcAddress(LibGL, 'glStencilFunc');
-  @glStencilMask := GetProcAddress(LibGL, 'glStencilMask');
-  @glStencilOp := GetProcAddress(LibGL, 'glStencilOp');
-  @glTexCoord1d := GetProcAddress(LibGL, 'glTexCoord1d');
-  @glTexCoord1dv := GetProcAddress(LibGL, 'glTexCoord1dv');
-  @glTexCoord1f := GetProcAddress(LibGL, 'glTexCoord1f');
-  @glTexCoord1fv := GetProcAddress(LibGL, 'glTexCoord1fv');
-  @glTexCoord1i := GetProcAddress(LibGL, 'glTexCoord1i');
-  @glTexCoord1iv := GetProcAddress(LibGL, 'glTexCoord1iv');
-  @glTexCoord1s := GetProcAddress(LibGL, 'glTexCoord1s');
-  @glTexCoord1sv := GetProcAddress(LibGL, 'glTexCoord1sv');
-  @glTexCoord2d := GetProcAddress(LibGL, 'glTexCoord2d');
-  @glTexCoord2dv := GetProcAddress(LibGL, 'glTexCoord2dv');
-  @glTexCoord2f := GetProcAddress(LibGL, 'glTexCoord2f');
-  @glTexCoord2fv := GetProcAddress(LibGL, 'glTexCoord2fv');
-  @glTexCoord2i := GetProcAddress(LibGL, 'glTexCoord2i');
-  @glTexCoord2iv := GetProcAddress(LibGL, 'glTexCoord2iv');
-  @glTexCoord2s := GetProcAddress(LibGL, 'glTexCoord2s');
-  @glTexCoord2sv := GetProcAddress(LibGL, 'glTexCoord2sv');
-  @glTexCoord3d := GetProcAddress(LibGL, 'glTexCoord3d');
-  @glTexCoord3dv := GetProcAddress(LibGL, 'glTexCoord3dv');
-  @glTexCoord3f := GetProcAddress(LibGL, 'glTexCoord3f');
-  @glTexCoord3fv := GetProcAddress(LibGL, 'glTexCoord3fv');
-  @glTexCoord3i := GetProcAddress(LibGL, 'glTexCoord3i');
-  @glTexCoord3iv := GetProcAddress(LibGL, 'glTexCoord3iv');
-  @glTexCoord3s := GetProcAddress(LibGL, 'glTexCoord3s');
-  @glTexCoord3sv := GetProcAddress(LibGL, 'glTexCoord3sv');
-  @glTexCoord4d := GetProcAddress(LibGL, 'glTexCoord4d');
-  @glTexCoord4dv := GetProcAddress(LibGL, 'glTexCoord4dv');
-  @glTexCoord4f := GetProcAddress(LibGL, 'glTexCoord4f');
-  @glTexCoord4fv := GetProcAddress(LibGL, 'glTexCoord4fv');
-  @glTexCoord4i := GetProcAddress(LibGL, 'glTexCoord4i');
-  @glTexCoord4iv := GetProcAddress(LibGL, 'glTexCoord4iv');
-  @glTexCoord4s := GetProcAddress(LibGL, 'glTexCoord4s');
-  @glTexCoord4sv := GetProcAddress(LibGL, 'glTexCoord4sv');
-  @glTexCoordPointer := GetProcAddress(LibGL, 'glTexCoordPointer');
-  @glTexEnvf := GetProcAddress(LibGL, 'glTexEnvf');
-  @glTexEnvfv := GetProcAddress(LibGL, 'glTexEnvfv');
-  @glTexEnvi := GetProcAddress(LibGL, 'glTexEnvi');
-  @glTexEnviv := GetProcAddress(LibGL, 'glTexEnviv');
-  @glTexGend := GetProcAddress(LibGL, 'glTexGend');
-  @glTexGendv := GetProcAddress(LibGL, 'glTexGendv');
-  @glTexGenf := GetProcAddress(LibGL, 'glTexGenf');
-  @glTexGenfv := GetProcAddress(LibGL, 'glTexGenfv');
-  @glTexGeni := GetProcAddress(LibGL, 'glTexGeni');
-  @glTexGeniv := GetProcAddress(LibGL, 'glTexGeniv');
-  @glTexImage1D := GetProcAddress(LibGL, 'glTexImage1D');
-  @glTexImage2D := GetProcAddress(LibGL, 'glTexImage2D');
-  @glTexParameterf := GetProcAddress(LibGL, 'glTexParameterf');
-  @glTexParameterfv := GetProcAddress(LibGL, 'glTexParameterfv');
-  @glTexParameteri := GetProcAddress(LibGL, 'glTexParameteri');
-  @glTexParameteriv := GetProcAddress(LibGL, 'glTexParameteriv');
-  @glTexSubImage1D := GetProcAddress(LibGL, 'glTexSubImage1D');
-  @glTexSubImage2D := GetProcAddress(LibGL, 'glTexSubImage2D');
-  @glTranslated := GetProcAddress(LibGL, 'glTranslated');
-  @glTranslatef := GetProcAddress(LibGL, 'glTranslatef');
-  @glVertex2d := GetProcAddress(LibGL, 'glVertex2d');
-  @glVertex2dv := GetProcAddress(LibGL, 'glVertex2dv');
-  @glVertex2f := GetProcAddress(LibGL, 'glVertex2f');
-  @glVertex2fv := GetProcAddress(LibGL, 'glVertex2fv');
-  @glVertex2i := GetProcAddress(LibGL, 'glVertex2i');
-  @glVertex2iv := GetProcAddress(LibGL, 'glVertex2iv');
-  @glVertex2s := GetProcAddress(LibGL, 'glVertex2s');
-  @glVertex2sv := GetProcAddress(LibGL, 'glVertex2sv');
-  @glVertex3d := GetProcAddress(LibGL, 'glVertex3d');
-  @glVertex3dv := GetProcAddress(LibGL, 'glVertex3dv');
-  @glVertex3f := GetProcAddress(LibGL, 'glVertex3f');
-  @glVertex3fv := GetProcAddress(LibGL, 'glVertex3fv');
-  @glVertex3i := GetProcAddress(LibGL, 'glVertex3i');
-  @glVertex3iv := GetProcAddress(LibGL, 'glVertex3iv');
-  @glVertex3s := GetProcAddress(LibGL, 'glVertex3s');
-  @glVertex3sv := GetProcAddress(LibGL, 'glVertex3sv');
-  @glVertex4d := GetProcAddress(LibGL, 'glVertex4d');
-  @glVertex4dv := GetProcAddress(LibGL, 'glVertex4dv');
-  @glVertex4f := GetProcAddress(LibGL, 'glVertex4f');
-  @glVertex4fv := GetProcAddress(LibGL, 'glVertex4fv');
-  @glVertex4i := GetProcAddress(LibGL, 'glVertex4i');
-  @glVertex4iv := GetProcAddress(LibGL, 'glVertex4iv');
-  @glVertex4s := GetProcAddress(LibGL, 'glVertex4s');
-  @glVertex4sv := GetProcAddress(LibGL, 'glVertex4sv');
-  @glVertexPointer := GetProcAddress(LibGL, 'glVertexPointer');
-  @glViewport := GetProcAddress(LibGL, 'glViewport');
+  try
+    @glAccum := GetGLProcAddress(LibGL, 'glAccum');
+    @glAlphaFunc := GetGLProcAddress(LibGL, 'glAlphaFunc');
+    @glAreTexturesResident := GetGLProcAddress(LibGL, 'glAreTexturesResident');
+    @glArrayElement := GetGLProcAddress(LibGL, 'glArrayElement');
+    @glBegin := GetGLProcAddress(LibGL, 'glBegin');
+    @glBindTexture := GetGLProcAddress(LibGL, 'glBindTexture');
+    @glBitmap := GetGLProcAddress(LibGL, 'glBitmap');
+    @glBlendFunc := GetGLProcAddress(LibGL, 'glBlendFunc');
+    @glCallList := GetGLProcAddress(LibGL, 'glCallList');
+    @glCallLists := GetGLProcAddress(LibGL, 'glCallLists');
+    @glClear := GetGLProcAddress(LibGL, 'glClear');
+    @glClearAccum := GetGLProcAddress(LibGL, 'glClearAccum');
+    @glClearColor := GetGLProcAddress(LibGL, 'glClearColor');
+    @glClearDepth := GetGLProcAddress(LibGL, 'glClearDepth');
+    @glClearIndex := GetGLProcAddress(LibGL, 'glClearIndex');
+    @glClearStencil := GetGLProcAddress(LibGL, 'glClearStencil');
+    @glClipPlane := GetGLProcAddress(LibGL, 'glClipPlane');
+    @glColor3b := GetGLProcAddress(LibGL, 'glColor3b');
+    @glColor3bv := GetGLProcAddress(LibGL, 'glColor3bv');
+    @glColor3d := GetGLProcAddress(LibGL, 'glColor3d');
+    @glColor3dv := GetGLProcAddress(LibGL, 'glColor3dv');
+    @glColor3f := GetGLProcAddress(LibGL, 'glColor3f');
+    @glColor3fv := GetGLProcAddress(LibGL, 'glColor3fv');
+    @glColor3i := GetGLProcAddress(LibGL, 'glColor3i');
+    @glColor3iv := GetGLProcAddress(LibGL, 'glColor3iv');
+    @glColor3s := GetGLProcAddress(LibGL, 'glColor3s');
+    @glColor3sv := GetGLProcAddress(LibGL, 'glColor3sv');
+    @glColor3ub := GetGLProcAddress(LibGL, 'glColor3ub');
+    @glColor3ubv := GetGLProcAddress(LibGL, 'glColor3ubv');
+    @glColor3ui := GetGLProcAddress(LibGL, 'glColor3ui');
+    @glColor3uiv := GetGLProcAddress(LibGL, 'glColor3uiv');
+    @glColor3us := GetGLProcAddress(LibGL, 'glColor3us');
+    @glColor3usv := GetGLProcAddress(LibGL, 'glColor3usv');
+    @glColor4b := GetGLProcAddress(LibGL, 'glColor4b');
+    @glColor4bv := GetGLProcAddress(LibGL, 'glColor4bv');
+    @glColor4d := GetGLProcAddress(LibGL, 'glColor4d');
+    @glColor4dv := GetGLProcAddress(LibGL, 'glColor4dv');
+    @glColor4f := GetGLProcAddress(LibGL, 'glColor4f');
+    @glColor4fv := GetGLProcAddress(LibGL, 'glColor4fv');
+    @glColor4i := GetGLProcAddress(LibGL, 'glColor4i');
+    @glColor4iv := GetGLProcAddress(LibGL, 'glColor4iv');
+    @glColor4s := GetGLProcAddress(LibGL, 'glColor4s');
+    @glColor4sv := GetGLProcAddress(LibGL, 'glColor4sv');
+    @glColor4ub := GetGLProcAddress(LibGL, 'glColor4ub');
+    @glColor4ubv := GetGLProcAddress(LibGL, 'glColor4ubv');
+    @glColor4ui := GetGLProcAddress(LibGL, 'glColor4ui');
+    @glColor4uiv := GetGLProcAddress(LibGL, 'glColor4uiv');
+    @glColor4us := GetGLProcAddress(LibGL, 'glColor4us');
+    @glColor4usv := GetGLProcAddress(LibGL, 'glColor4usv');
+    @glColorMask := GetGLProcAddress(LibGL, 'glColorMask');
+    @glColorMaterial := GetGLProcAddress(LibGL, 'glColorMaterial');
+    @glColorPointer := GetGLProcAddress(LibGL, 'glColorPointer');
+    @glCopyPixels := GetGLProcAddress(LibGL, 'glCopyPixels');
+    @glCopyTexImage1D := GetGLProcAddress(LibGL, 'glCopyTexImage1D');
+    @glCopyTexImage2D := GetGLProcAddress(LibGL, 'glCopyTexImage2D');
+    @glCopyTexSubImage1D := GetGLProcAddress(LibGL, 'glCopyTexSubImage1D');
+    @glCopyTexSubImage2D := GetGLProcAddress(LibGL, 'glCopyTexSubImage2D');
+    @glCullFace := GetGLProcAddress(LibGL, 'glCullFace');
+    @glDeleteLists := GetGLProcAddress(LibGL, 'glDeleteLists');
+    @glDeleteTextures := GetGLProcAddress(LibGL, 'glDeleteTextures');
+    @glDepthFunc := GetGLProcAddress(LibGL, 'glDepthFunc');
+    @glDepthMask := GetGLProcAddress(LibGL, 'glDepthMask');
+    @glDepthRange := GetGLProcAddress(LibGL, 'glDepthRange');
+    @glDisable := GetGLProcAddress(LibGL, 'glDisable');
+    @glDisableClientState := GetGLProcAddress(LibGL, 'glDisableClientState');
+    @glDrawArrays := GetGLProcAddress(LibGL, 'glDrawArrays');
+    @glDrawBuffer := GetGLProcAddress(LibGL, 'glDrawBuffer');
+    @glDrawElements := GetGLProcAddress(LibGL, 'glDrawElements');
+    @glDrawPixels := GetGLProcAddress(LibGL, 'glDrawPixels');
+    @glEdgeFlag := GetGLProcAddress(LibGL, 'glEdgeFlag');
+    @glEdgeFlagPointer := GetGLProcAddress(LibGL, 'glEdgeFlagPointer');
+    @glEdgeFlagv := GetGLProcAddress(LibGL, 'glEdgeFlagv');
+    @glEnable := GetGLProcAddress(LibGL, 'glEnable');
+    @glEnableClientState := GetGLProcAddress(LibGL, 'glEnableClientState');
+    @glEnd := GetGLProcAddress(LibGL, 'glEnd');
+    @glEndList := GetGLProcAddress(LibGL, 'glEndList');
+    @glEvalCoord1d := GetGLProcAddress(LibGL, 'glEvalCoord1d');
+    @glEvalCoord1dv := GetGLProcAddress(LibGL, 'glEvalCoord1dv');
+    @glEvalCoord1f := GetGLProcAddress(LibGL, 'glEvalCoord1f');
+    @glEvalCoord1fv := GetGLProcAddress(LibGL, 'glEvalCoord1fv');
+    @glEvalCoord2d := GetGLProcAddress(LibGL, 'glEvalCoord2d');
+    @glEvalCoord2dv := GetGLProcAddress(LibGL, 'glEvalCoord2dv');
+    @glEvalCoord2f := GetGLProcAddress(LibGL, 'glEvalCoord2f');
+    @glEvalCoord2fv := GetGLProcAddress(LibGL, 'glEvalCoord2fv');
+    @glEvalMesh1 := GetGLProcAddress(LibGL, 'glEvalMesh1');
+    @glEvalMesh2 := GetGLProcAddress(LibGL, 'glEvalMesh2');
+    @glEvalPoint1 := GetGLProcAddress(LibGL, 'glEvalPoint1');
+    @glEvalPoint2 := GetGLProcAddress(LibGL, 'glEvalPoint2');
+    @glFeedbackBuffer := GetGLProcAddress(LibGL, 'glFeedbackBuffer');
+    @glFinish := GetGLProcAddress(LibGL, 'glFinish');
+    @glFlush := GetGLProcAddress(LibGL, 'glFlush');
+    @glFogf := GetGLProcAddress(LibGL, 'glFogf');
+    @glFogfv := GetGLProcAddress(LibGL, 'glFogfv');
+    @glFogi := GetGLProcAddress(LibGL, 'glFogi');
+    @glFogiv := GetGLProcAddress(LibGL, 'glFogiv');
+    @glFrontFace := GetGLProcAddress(LibGL, 'glFrontFace');
+    @glFrustum := GetGLProcAddress(LibGL, 'glFrustum');
+    @glGenLists := GetGLProcAddress(LibGL, 'glGenLists');
+    @glGenTextures := GetGLProcAddress(LibGL, 'glGenTextures');
+    @glGetBooleanv := GetGLProcAddress(LibGL, 'glGetBooleanv');
+    @glGetClipPlane := GetGLProcAddress(LibGL, 'glGetClipPlane');
+    @glGetDoublev := GetGLProcAddress(LibGL, 'glGetDoublev');
+    @glGetError := GetGLProcAddress(LibGL, 'glGetError');
+    @glGetFloatv := GetGLProcAddress(LibGL, 'glGetFloatv');
+    @glGetIntegerv := GetGLProcAddress(LibGL, 'glGetIntegerv');
+    @glGetLightfv := GetGLProcAddress(LibGL, 'glGetLightfv');
+    @glGetLightiv := GetGLProcAddress(LibGL, 'glGetLightiv');
+    @glGetMapdv := GetGLProcAddress(LibGL, 'glGetMapdv');
+    @glGetMapfv := GetGLProcAddress(LibGL, 'glGetMapfv');
+    @glGetMapiv := GetGLProcAddress(LibGL, 'glGetMapiv');
+    @glGetMaterialfv := GetGLProcAddress(LibGL, 'glGetMaterialfv');
+    @glGetMaterialiv := GetGLProcAddress(LibGL, 'glGetMaterialiv');
+    @glGetPixelMapfv := GetGLProcAddress(LibGL, 'glGetPixelMapfv');
+    @glGetPixelMapuiv := GetGLProcAddress(LibGL, 'glGetPixelMapuiv');
+    @glGetPixelMapusv := GetGLProcAddress(LibGL, 'glGetPixelMapusv');
+    @glGetPointerv := GetGLProcAddress(LibGL, 'glGetPointerv');
+    @glGetPolygonStipple := GetGLProcAddress(LibGL, 'glGetPolygonStipple');
+    @glGetString := GetGLProcAddress(LibGL, 'glGetString');
+    @glGetTexEnvfv := GetGLProcAddress(LibGL, 'glGetTexEnvfv');
+    @glGetTexEnviv := GetGLProcAddress(LibGL, 'glGetTexEnviv');
+    @glGetTexGendv := GetGLProcAddress(LibGL, 'glGetTexGendv');
+    @glGetTexGenfv := GetGLProcAddress(LibGL, 'glGetTexGenfv');
+    @glGetTexGeniv := GetGLProcAddress(LibGL, 'glGetTexGeniv');
+    @glGetTexImage := GetGLProcAddress(LibGL, 'glGetTexImage');
+    @glGetTexLevelParameterfv := GetGLProcAddress(LibGL, 'glGetTexLevelParameterfv');
+    @glGetTexLevelParameteriv := GetGLProcAddress(LibGL, 'glGetTexLevelParameteriv');
+    @glGetTexParameterfv := GetGLProcAddress(LibGL, 'glGetTexParameterfv');
+    @glGetTexParameteriv := GetGLProcAddress(LibGL, 'glGetTexParameteriv');
+    @glHint := GetGLProcAddress(LibGL, 'glHint');
+    @glIndexMask := GetGLProcAddress(LibGL, 'glIndexMask');
+    @glIndexPointer := GetGLProcAddress(LibGL, 'glIndexPointer');
+    @glIndexd := GetGLProcAddress(LibGL, 'glIndexd');
+    @glIndexdv := GetGLProcAddress(LibGL, 'glIndexdv');
+    @glIndexf := GetGLProcAddress(LibGL, 'glIndexf');
+    @glIndexfv := GetGLProcAddress(LibGL, 'glIndexfv');
+    @glIndexi := GetGLProcAddress(LibGL, 'glIndexi');
+    @glIndexiv := GetGLProcAddress(LibGL, 'glIndexiv');
+    @glIndexs := GetGLProcAddress(LibGL, 'glIndexs');
+    @glIndexsv := GetGLProcAddress(LibGL, 'glIndexsv');
+    @glIndexub := GetGLProcAddress(LibGL, 'glIndexub');
+    @glIndexubv := GetGLProcAddress(LibGL, 'glIndexubv');
+    @glInitNames := GetGLProcAddress(LibGL, 'glInitNames');
+    @glInterleavedArrays := GetGLProcAddress(LibGL, 'glInterleavedArrays');
+    @glIsEnabled := GetGLProcAddress(LibGL, 'glIsEnabled');
+    @glIsList := GetGLProcAddress(LibGL, 'glIsList');
+    @glIsTexture := GetGLProcAddress(LibGL, 'glIsTexture');
+    @glLightModelf := GetGLProcAddress(LibGL, 'glLightModelf');
+    @glLightModelfv := GetGLProcAddress(LibGL, 'glLightModelfv');
+    @glLightModeli := GetGLProcAddress(LibGL, 'glLightModeli');
+    @glLightModeliv := GetGLProcAddress(LibGL, 'glLightModeliv');
+    @glLightf := GetGLProcAddress(LibGL, 'glLightf');
+    @glLightfv := GetGLProcAddress(LibGL, 'glLightfv');
+    @glLighti := GetGLProcAddress(LibGL, 'glLighti');
+    @glLightiv := GetGLProcAddress(LibGL, 'glLightiv');
+    @glLineStipple := GetGLProcAddress(LibGL, 'glLineStipple');
+    @glLineWidth := GetGLProcAddress(LibGL, 'glLineWidth');
+    @glListBase := GetGLProcAddress(LibGL, 'glListBase');
+    @glLoadIdentity := GetGLProcAddress(LibGL, 'glLoadIdentity');
+    @glLoadMatrixd := GetGLProcAddress(LibGL, 'glLoadMatrixd');
+    @glLoadMatrixf := GetGLProcAddress(LibGL, 'glLoadMatrixf');
+    @glLoadName := GetGLProcAddress(LibGL, 'glLoadName');
+    @glLogicOp := GetGLProcAddress(LibGL, 'glLogicOp');
+    @glMap1d := GetGLProcAddress(LibGL, 'glMap1d');
+    @glMap1f := GetGLProcAddress(LibGL, 'glMap1f');
+    @glMap2d := GetGLProcAddress(LibGL, 'glMap2d');
+    @glMap2f := GetGLProcAddress(LibGL, 'glMap2f');
+    @glMapGrid1d := GetGLProcAddress(LibGL, 'glMapGrid1d');
+    @glMapGrid1f := GetGLProcAddress(LibGL, 'glMapGrid1f');
+    @glMapGrid2d := GetGLProcAddress(LibGL, 'glMapGrid2d');
+    @glMapGrid2f := GetGLProcAddress(LibGL, 'glMapGrid2f');
+    @glMaterialf := GetGLProcAddress(LibGL, 'glMaterialf');
+    @glMaterialfv := GetGLProcAddress(LibGL, 'glMaterialfv');
+    @glMateriali := GetGLProcAddress(LibGL, 'glMateriali');
+    @glMaterialiv := GetGLProcAddress(LibGL, 'glMaterialiv');
+    @glMatrixMode := GetGLProcAddress(LibGL, 'glMatrixMode');
+    @glMultMatrixd := GetGLProcAddress(LibGL, 'glMultMatrixd');
+    @glMultMatrixf := GetGLProcAddress(LibGL, 'glMultMatrixf');
+    @glNewList := GetGLProcAddress(LibGL, 'glNewList');
+    @glNormal3b := GetGLProcAddress(LibGL, 'glNormal3b');
+    @glNormal3bv := GetGLProcAddress(LibGL, 'glNormal3bv');
+    @glNormal3d := GetGLProcAddress(LibGL, 'glNormal3d');
+    @glNormal3dv := GetGLProcAddress(LibGL, 'glNormal3dv');
+    @glNormal3f := GetGLProcAddress(LibGL, 'glNormal3f');
+    @glNormal3fv := GetGLProcAddress(LibGL, 'glNormal3fv');
+    @glNormal3i := GetGLProcAddress(LibGL, 'glNormal3i');
+    @glNormal3iv := GetGLProcAddress(LibGL, 'glNormal3iv');
+    @glNormal3s := GetGLProcAddress(LibGL, 'glNormal3s');
+    @glNormal3sv := GetGLProcAddress(LibGL, 'glNormal3sv');
+    @glNormalPointer := GetGLProcAddress(LibGL, 'glNormalPointer');
+    @glOrtho := GetGLProcAddress(LibGL, 'glOrtho');
+    @glPassThrough := GetGLProcAddress(LibGL, 'glPassThrough');
+    @glPixelMapfv := GetGLProcAddress(LibGL, 'glPixelMapfv');
+    @glPixelMapuiv := GetGLProcAddress(LibGL, 'glPixelMapuiv');
+    @glPixelMapusv := GetGLProcAddress(LibGL, 'glPixelMapusv');
+    @glPixelStoref := GetGLProcAddress(LibGL, 'glPixelStoref');
+    @glPixelStorei := GetGLProcAddress(LibGL, 'glPixelStorei');
+    @glPixelTransferf := GetGLProcAddress(LibGL, 'glPixelTransferf');
+    @glPixelTransferi := GetGLProcAddress(LibGL, 'glPixelTransferi');
+    @glPixelZoom := GetGLProcAddress(LibGL, 'glPixelZoom');
+    @glPointSize := GetGLProcAddress(LibGL, 'glPointSize');
+    @glPolygonMode := GetGLProcAddress(LibGL, 'glPolygonMode');
+    @glPolygonOffset := GetGLProcAddress(LibGL, 'glPolygonOffset');
+    @glPolygonStipple := GetGLProcAddress(LibGL, 'glPolygonStipple');
+    @glPopAttrib := GetGLProcAddress(LibGL, 'glPopAttrib');
+    @glPopClientAttrib := GetGLProcAddress(LibGL, 'glPopClientAttrib');
+    @glPopMatrix := GetGLProcAddress(LibGL, 'glPopMatrix');
+    @glPopName := GetGLProcAddress(LibGL, 'glPopName');
+    @glPrioritizeTextures := GetGLProcAddress(LibGL, 'glPrioritizeTextures');
+    @glPushAttrib := GetGLProcAddress(LibGL, 'glPushAttrib');
+    @glPushClientAttrib := GetGLProcAddress(LibGL, 'glPushClientAttrib');
+    @glPushMatrix := GetGLProcAddress(LibGL, 'glPushMatrix');
+    @glPushName := GetGLProcAddress(LibGL, 'glPushName');
+    @glRasterPos2d := GetGLProcAddress(LibGL, 'glRasterPos2d');
+    @glRasterPos2dv := GetGLProcAddress(LibGL, 'glRasterPos2dv');
+    @glRasterPos2f := GetGLProcAddress(LibGL, 'glRasterPos2f');
+    @glRasterPos2fv := GetGLProcAddress(LibGL, 'glRasterPos2fv');
+    @glRasterPos2i := GetGLProcAddress(LibGL, 'glRasterPos2i');
+    @glRasterPos2iv := GetGLProcAddress(LibGL, 'glRasterPos2iv');
+    @glRasterPos2s := GetGLProcAddress(LibGL, 'glRasterPos2s');
+    @glRasterPos2sv := GetGLProcAddress(LibGL, 'glRasterPos2sv');
+    @glRasterPos3d := GetGLProcAddress(LibGL, 'glRasterPos3d');
+    @glRasterPos3dv := GetGLProcAddress(LibGL, 'glRasterPos3dv');
+    @glRasterPos3f := GetGLProcAddress(LibGL, 'glRasterPos3f');
+    @glRasterPos3fv := GetGLProcAddress(LibGL, 'glRasterPos3fv');
+    @glRasterPos3i := GetGLProcAddress(LibGL, 'glRasterPos3i');
+    @glRasterPos3iv := GetGLProcAddress(LibGL, 'glRasterPos3iv');
+    @glRasterPos3s := GetGLProcAddress(LibGL, 'glRasterPos3s');
+    @glRasterPos3sv := GetGLProcAddress(LibGL, 'glRasterPos3sv');
+    @glRasterPos4d := GetGLProcAddress(LibGL, 'glRasterPos4d');
+    @glRasterPos4dv := GetGLProcAddress(LibGL, 'glRasterPos4dv');
+    @glRasterPos4f := GetGLProcAddress(LibGL, 'glRasterPos4f');
+    @glRasterPos4fv := GetGLProcAddress(LibGL, 'glRasterPos4fv');
+    @glRasterPos4i := GetGLProcAddress(LibGL, 'glRasterPos4i');
+    @glRasterPos4iv := GetGLProcAddress(LibGL, 'glRasterPos4iv');
+    @glRasterPos4s := GetGLProcAddress(LibGL, 'glRasterPos4s');
+    @glRasterPos4sv := GetGLProcAddress(LibGL, 'glRasterPos4sv');
+    @glReadBuffer := GetGLProcAddress(LibGL, 'glReadBuffer');
+    @glReadPixels := GetGLProcAddress(LibGL, 'glReadPixels');
+    @glRectd := GetGLProcAddress(LibGL, 'glRectd');
+    @glRectdv := GetGLProcAddress(LibGL, 'glRectdv');
+    @glRectf := GetGLProcAddress(LibGL, 'glRectf');
+    @glRectfv := GetGLProcAddress(LibGL, 'glRectfv');
+    @glRecti := GetGLProcAddress(LibGL, 'glRecti');
+    @glRectiv := GetGLProcAddress(LibGL, 'glRectiv');
+    @glRects := GetGLProcAddress(LibGL, 'glRects');
+    @glRectsv := GetGLProcAddress(LibGL, 'glRectsv');
+    @glRenderMode := GetGLProcAddress(LibGL, 'glRenderMode');
+    @glRotated := GetGLProcAddress(LibGL, 'glRotated');
+    @glRotatef := GetGLProcAddress(LibGL, 'glRotatef');
+    @glScaled := GetGLProcAddress(LibGL, 'glScaled');
+    @glScalef := GetGLProcAddress(LibGL, 'glScalef');
+    @glScissor := GetGLProcAddress(LibGL, 'glScissor');
+    @glSelectBuffer := GetGLProcAddress(LibGL, 'glSelectBuffer');
+    @glShadeModel := GetGLProcAddress(LibGL, 'glShadeModel');
+    @glStencilFunc := GetGLProcAddress(LibGL, 'glStencilFunc');
+    @glStencilMask := GetGLProcAddress(LibGL, 'glStencilMask');
+    @glStencilOp := GetGLProcAddress(LibGL, 'glStencilOp');
+    @glTexCoord1d := GetGLProcAddress(LibGL, 'glTexCoord1d');
+    @glTexCoord1dv := GetGLProcAddress(LibGL, 'glTexCoord1dv');
+    @glTexCoord1f := GetGLProcAddress(LibGL, 'glTexCoord1f');
+    @glTexCoord1fv := GetGLProcAddress(LibGL, 'glTexCoord1fv');
+    @glTexCoord1i := GetGLProcAddress(LibGL, 'glTexCoord1i');
+    @glTexCoord1iv := GetGLProcAddress(LibGL, 'glTexCoord1iv');
+    @glTexCoord1s := GetGLProcAddress(LibGL, 'glTexCoord1s');
+    @glTexCoord1sv := GetGLProcAddress(LibGL, 'glTexCoord1sv');
+    @glTexCoord2d := GetGLProcAddress(LibGL, 'glTexCoord2d');
+    @glTexCoord2dv := GetGLProcAddress(LibGL, 'glTexCoord2dv');
+    @glTexCoord2f := GetGLProcAddress(LibGL, 'glTexCoord2f');
+    @glTexCoord2fv := GetGLProcAddress(LibGL, 'glTexCoord2fv');
+    @glTexCoord2i := GetGLProcAddress(LibGL, 'glTexCoord2i');
+    @glTexCoord2iv := GetGLProcAddress(LibGL, 'glTexCoord2iv');
+    @glTexCoord2s := GetGLProcAddress(LibGL, 'glTexCoord2s');
+    @glTexCoord2sv := GetGLProcAddress(LibGL, 'glTexCoord2sv');
+    @glTexCoord3d := GetGLProcAddress(LibGL, 'glTexCoord3d');
+    @glTexCoord3dv := GetGLProcAddress(LibGL, 'glTexCoord3dv');
+    @glTexCoord3f := GetGLProcAddress(LibGL, 'glTexCoord3f');
+    @glTexCoord3fv := GetGLProcAddress(LibGL, 'glTexCoord3fv');
+    @glTexCoord3i := GetGLProcAddress(LibGL, 'glTexCoord3i');
+    @glTexCoord3iv := GetGLProcAddress(LibGL, 'glTexCoord3iv');
+    @glTexCoord3s := GetGLProcAddress(LibGL, 'glTexCoord3s');
+    @glTexCoord3sv := GetGLProcAddress(LibGL, 'glTexCoord3sv');
+    @glTexCoord4d := GetGLProcAddress(LibGL, 'glTexCoord4d');
+    @glTexCoord4dv := GetGLProcAddress(LibGL, 'glTexCoord4dv');
+    @glTexCoord4f := GetGLProcAddress(LibGL, 'glTexCoord4f');
+    @glTexCoord4fv := GetGLProcAddress(LibGL, 'glTexCoord4fv');
+    @glTexCoord4i := GetGLProcAddress(LibGL, 'glTexCoord4i');
+    @glTexCoord4iv := GetGLProcAddress(LibGL, 'glTexCoord4iv');
+    @glTexCoord4s := GetGLProcAddress(LibGL, 'glTexCoord4s');
+    @glTexCoord4sv := GetGLProcAddress(LibGL, 'glTexCoord4sv');
+    @glTexCoordPointer := GetGLProcAddress(LibGL, 'glTexCoordPointer');
+    @glTexEnvf := GetGLProcAddress(LibGL, 'glTexEnvf');
+    @glTexEnvfv := GetGLProcAddress(LibGL, 'glTexEnvfv');
+    @glTexEnvi := GetGLProcAddress(LibGL, 'glTexEnvi');
+    @glTexEnviv := GetGLProcAddress(LibGL, 'glTexEnviv');
+    @glTexGend := GetGLProcAddress(LibGL, 'glTexGend');
+    @glTexGendv := GetGLProcAddress(LibGL, 'glTexGendv');
+    @glTexGenf := GetGLProcAddress(LibGL, 'glTexGenf');
+    @glTexGenfv := GetGLProcAddress(LibGL, 'glTexGenfv');
+    @glTexGeni := GetGLProcAddress(LibGL, 'glTexGeni');
+    @glTexGeniv := GetGLProcAddress(LibGL, 'glTexGeniv');
+    @glTexImage1D := GetGLProcAddress(LibGL, 'glTexImage1D');
+    @glTexImage2D := GetGLProcAddress(LibGL, 'glTexImage2D');
+    @glTexParameterf := GetGLProcAddress(LibGL, 'glTexParameterf');
+    @glTexParameterfv := GetGLProcAddress(LibGL, 'glTexParameterfv');
+    @glTexParameteri := GetGLProcAddress(LibGL, 'glTexParameteri');
+    @glTexParameteriv := GetGLProcAddress(LibGL, 'glTexParameteriv');
+    @glTexSubImage1D := GetGLProcAddress(LibGL, 'glTexSubImage1D');
+    @glTexSubImage2D := GetGLProcAddress(LibGL, 'glTexSubImage2D');
+    @glTranslated := GetGLProcAddress(LibGL, 'glTranslated');
+    @glTranslatef := GetGLProcAddress(LibGL, 'glTranslatef');
+    @glVertex2d := GetGLProcAddress(LibGL, 'glVertex2d');
+    @glVertex2dv := GetGLProcAddress(LibGL, 'glVertex2dv');
+    @glVertex2f := GetGLProcAddress(LibGL, 'glVertex2f');
+    @glVertex2fv := GetGLProcAddress(LibGL, 'glVertex2fv');
+    @glVertex2i := GetGLProcAddress(LibGL, 'glVertex2i');
+    @glVertex2iv := GetGLProcAddress(LibGL, 'glVertex2iv');
+    @glVertex2s := GetGLProcAddress(LibGL, 'glVertex2s');
+    @glVertex2sv := GetGLProcAddress(LibGL, 'glVertex2sv');
+    @glVertex3d := GetGLProcAddress(LibGL, 'glVertex3d');
+    @glVertex3dv := GetGLProcAddress(LibGL, 'glVertex3dv');
+    @glVertex3f := GetGLProcAddress(LibGL, 'glVertex3f');
+    @glVertex3fv := GetGLProcAddress(LibGL, 'glVertex3fv');
+    @glVertex3i := GetGLProcAddress(LibGL, 'glVertex3i');
+    @glVertex3iv := GetGLProcAddress(LibGL, 'glVertex3iv');
+    @glVertex3s := GetGLProcAddress(LibGL, 'glVertex3s');
+    @glVertex3sv := GetGLProcAddress(LibGL, 'glVertex3sv');
+    @glVertex4d := GetGLProcAddress(LibGL, 'glVertex4d');
+    @glVertex4dv := GetGLProcAddress(LibGL, 'glVertex4dv');
+    @glVertex4f := GetGLProcAddress(LibGL, 'glVertex4f');
+    @glVertex4fv := GetGLProcAddress(LibGL, 'glVertex4fv');
+    @glVertex4i := GetGLProcAddress(LibGL, 'glVertex4i');
+    @glVertex4iv := GetGLProcAddress(LibGL, 'glVertex4iv');
+    @glVertex4s := GetGLProcAddress(LibGL, 'glVertex4s');
+    @glVertex4sv := GetGLProcAddress(LibGL, 'glVertex4sv');
+    @glVertexPointer := GetGLProcAddress(LibGL, 'glVertexPointer');
+    @glViewport := GetGLProcAddress(LibGL, 'glViewport');
+  except
+    raise Exception.Create('Failed loading ' + MethodName +' from ' + dll);
+  end;
 
   {$IFDEF Win32}
-  @ChoosePixelFormat := GetProcAddress(LibGL, 'ChoosePixelFormat');
-  if not Assigned(ChoosePixelFormat) then
-    @ChoosePixelFormat := @WinChoosePixelFormat;
+  try
+    @ChoosePixelFormat := GetGLProcAddress(LibGL, 'ChoosePixelFormat');
+    if not Assigned(ChoosePixelFormat) then
+      @ChoosePixelFormat := @WinChoosePixelFormat;
+  except
+    raise Exception.Create('Unable to select pixel format');
+  end;
   {$ENDIF}
 
 end;
@@ -2249,20 +2265,15 @@ initialization
   Set8087CW($133F);
   {$ENDIF WIN32}
 
-  try
-    {$IFDEF Win32}
-    LoadOpenGL('opengl32.dll');
-    {$ELSE}
-    {$ifdef darwin}
-    LoadOpenGL('/System/Library/Frameworks/OpenGL.framework/Libraries/libGL.dylib');
-    {$ELSE}
-    LoadOpenGL('libGL.so.1');
-    {$endif}
-    {$ENDIF}
-  except
-    writeln('Error opening OpenGL library');
-    halt(1);
-  end;
+  {$IFDEF Win32}
+  LoadOpenGL('opengl32.dll');
+  {$ELSE}
+  {$ifdef darwin}
+  LoadOpenGL('/System/Library/Frameworks/OpenGL.framework/Libraries/libGL.dylib');
+  {$ELSE}
+  LoadOpenGL('libGL.so.1');
+  {$endif}
+  {$ENDIF}
 
 finalization
 

packages/extra/opengl/glu.pp

@@ -432,85 +432,91 @@ begin
 end;
 
 procedure LoadGLu(const dll: String);
+var
+  MethodName: string = '';
+  
+  function GetGLuProcAddress(Lib: PtrInt; ProcName: PChar): Pointer;
+  begin
+    MethodName:=ProcName;
+    Result:=GetProcAddress(Lib, ProcName);
+  end;
+
 begin
 
   FreeGLu;
 
   hDLL := LoadLibrary(PChar(dll));
   if hDLL = 0 then raise Exception.Create('Could not load GLu from ' + dll);
-
-  @gluErrorString := GetProcAddress(hDLL, 'gluErrorString');
-  @gluErrorUnicodeStringEXT := GetProcAddress(hDLL, 'gluErrorUnicodeStringEXT');
-  @gluGetString := GetProcAddress(hDLL, 'gluGetString');
-  @gluOrtho2D := GetProcAddress(hDLL, 'gluOrtho2D');
-  @gluPerspective := GetProcAddress(hDLL, 'gluPerspective');
-  @gluPickMatrix := GetProcAddress(hDLL, 'gluPickMatrix');
-  @gluLookAt := GetProcAddress(hDLL, 'gluLookAt');
-  @gluProject := GetProcAddress(hDLL, 'gluProject');
-  @gluUnProject := GetProcAddress(hDLL, 'gluUnProject');
-  @gluScaleImage := GetProcAddress(hDLL, 'gluScaleImage');
-  @gluBuild1DMipmaps := GetProcAddress(hDLL, 'gluBuild1DMipmaps');
-  @gluBuild2DMipmaps := GetProcAddress(hDLL, 'gluBuild2DMipmaps');
-  @gluNewQuadric := GetProcAddress(hDLL, 'gluNewQuadric');
-  @gluDeleteQuadric := GetProcAddress(hDLL, 'gluDeleteQuadric');
-  @gluQuadricNormals := GetProcAddress(hDLL, 'gluQuadricNormals');
-  @gluQuadricTexture := GetProcAddress(hDLL, 'gluQuadricTexture');
-  @gluQuadricOrientation := GetProcAddress(hDLL, 'gluQuadricOrientation');
-  @gluQuadricDrawStyle := GetProcAddress(hDLL, 'gluQuadricDrawStyle');
-  @gluCylinder := GetProcAddress(hDLL, 'gluCylinder');
-  @gluDisk := GetProcAddress(hDLL, 'gluDisk');
-  @gluPartialDisk := GetProcAddress(hDLL, 'gluPartialDisk');
-  @gluSphere := GetProcAddress(hDLL, 'gluSphere');
-  @gluQuadricCallback := GetProcAddress(hDLL, 'gluQuadricCallback');
-  @gluNewTess := GetProcAddress(hDLL, 'gluNewTess');
-  @gluDeleteTess := GetProcAddress(hDLL, 'gluDeleteTess');
-  @gluTessBeginPolygon := GetProcAddress(hDLL, 'gluTessBeginPolygon');
-  @gluTessBeginContour := GetProcAddress(hDLL, 'gluTessBeginContour');
-  @gluTessVertex := GetProcAddress(hDLL, 'gluTessVertex');
-  @gluTessEndContour := GetProcAddress(hDLL, 'gluTessEndContour');
-  @gluTessEndPolygon := GetProcAddress(hDLL, 'gluTessEndPolygon');
-  @gluTessProperty := GetProcAddress(hDLL, 'gluTessProperty');
-  @gluTessNormal := GetProcAddress(hDLL, 'gluTessNormal');
-  @gluTessCallback := GetProcAddress(hDLL, 'gluTessCallback');
-  @gluGetTessProperty := GetProcAddress(hDLL, 'gluGetTessProperty');
-  @gluNewNurbsRenderer := GetProcAddress(hDLL, 'gluNewNurbsRenderer');
-  @gluDeleteNurbsRenderer := GetProcAddress(hDLL, 'gluDeleteNurbsRenderer');
-  @gluBeginSurface := GetProcAddress(hDLL, 'gluBeginSurface');
-  @gluBeginCurve := GetProcAddress(hDLL, 'gluBeginCurve');
-  @gluEndCurve := GetProcAddress(hDLL, 'gluEndCurve');
-  @gluEndSurface := GetProcAddress(hDLL, 'gluEndSurface');
-  @gluBeginTrim := GetProcAddress(hDLL, 'gluBeginTrim');
-  @gluEndTrim := GetProcAddress(hDLL, 'gluEndTrim');
-  @gluPwlCurve := GetProcAddress(hDLL, 'gluPwlCurve');
-  @gluNurbsCurve := GetProcAddress(hDLL, 'gluNurbsCurve');
-  @gluNurbsSurface := GetProcAddress(hDLL, 'gluNurbsSurface');
-  @gluLoadSamplingMatrices := GetProcAddress(hDLL, 'gluLoadSamplingMatrices');
-  @gluNurbsProperty := GetProcAddress(hDLL, 'gluNurbsProperty');
-  @gluGetNurbsProperty := GetProcAddress(hDLL, 'gluGetNurbsProperty');
-  @gluNurbsCallback := GetProcAddress(hDLL, 'gluNurbsCallback');
-
-  @gluBeginPolygon := GetProcAddress(hDLL, 'gluBeginPolygon');
-  @gluNextContour := GetProcAddress(hDLL, 'gluNextContour');
-  @gluEndPolygon := GetProcAddress(hDLL, 'gluEndPolygon');
-
+  try
+    @gluErrorString := GetGLuProcAddress(hDLL, 'gluErrorString');
+    @gluErrorUnicodeStringEXT := GetGLuProcAddress(hDLL, 'gluErrorUnicodeStringEXT');
+    @gluGetString := GetGLuProcAddress(hDLL, 'gluGetString');
+    @gluOrtho2D := GetGLuProcAddress(hDLL, 'gluOrtho2D');
+    @gluPerspective := GetGLuProcAddress(hDLL, 'gluPerspective');
+    @gluPickMatrix := GetGLuProcAddress(hDLL, 'gluPickMatrix');
+    @gluLookAt := GetGLuProcAddress(hDLL, 'gluLookAt');
+    @gluProject := GetGLuProcAddress(hDLL, 'gluProject');
+    @gluUnProject := GetGLuProcAddress(hDLL, 'gluUnProject');
+    @gluScaleImage := GetGLuProcAddress(hDLL, 'gluScaleImage');
+    @gluBuild1DMipmaps := GetGLuProcAddress(hDLL, 'gluBuild1DMipmaps');
+    @gluBuild2DMipmaps := GetGLuProcAddress(hDLL, 'gluBuild2DMipmaps');
+    @gluNewQuadric := GetGLuProcAddress(hDLL, 'gluNewQuadric');
+    @gluDeleteQuadric := GetGLuProcAddress(hDLL, 'gluDeleteQuadric');
+    @gluQuadricNormals := GetGLuProcAddress(hDLL, 'gluQuadricNormals');
+    @gluQuadricTexture := GetGLuProcAddress(hDLL, 'gluQuadricTexture');
+    @gluQuadricOrientation := GetGLuProcAddress(hDLL, 'gluQuadricOrientation');
+    @gluQuadricDrawStyle := GetGLuProcAddress(hDLL, 'gluQuadricDrawStyle');
+    @gluCylinder := GetGLuProcAddress(hDLL, 'gluCylinder');
+    @gluDisk := GetGLuProcAddress(hDLL, 'gluDisk');
+    @gluPartialDisk := GetGLuProcAddress(hDLL, 'gluPartialDisk');
+    @gluSphere := GetGLuProcAddress(hDLL, 'gluSphere');
+    @gluQuadricCallback := GetGLuProcAddress(hDLL, 'gluQuadricCallback');
+    @gluNewTess := GetGLuProcAddress(hDLL, 'gluNewTess');
+    @gluDeleteTess := GetGLuProcAddress(hDLL, 'gluDeleteTess');
+    @gluTessBeginPolygon := GetGLuProcAddress(hDLL, 'gluTessBeginPolygon');
+    @gluTessBeginContour := GetGLuProcAddress(hDLL, 'gluTessBeginContour');
+    @gluTessVertex := GetGLuProcAddress(hDLL, 'gluTessVertex');
+    @gluTessEndContour := GetGLuProcAddress(hDLL, 'gluTessEndContour');
+    @gluTessEndPolygon := GetGLuProcAddress(hDLL, 'gluTessEndPolygon');
+    @gluTessProperty := GetGLuProcAddress(hDLL, 'gluTessProperty');
+    @gluTessNormal := GetGLuProcAddress(hDLL, 'gluTessNormal');
+    @gluTessCallback := GetGLuProcAddress(hDLL, 'gluTessCallback');
+    @gluGetTessProperty := GetGLuProcAddress(hDLL, 'gluGetTessProperty');
+    @gluNewNurbsRenderer := GetGLuProcAddress(hDLL, 'gluNewNurbsRenderer');
+    @gluDeleteNurbsRenderer := GetGLuProcAddress(hDLL, 'gluDeleteNurbsRenderer');
+    @gluBeginSurface := GetGLuProcAddress(hDLL, 'gluBeginSurface');
+    @gluBeginCurve := GetGLuProcAddress(hDLL, 'gluBeginCurve');
+    @gluEndCurve := GetGLuProcAddress(hDLL, 'gluEndCurve');
+    @gluEndSurface := GetGLuProcAddress(hDLL, 'gluEndSurface');
+    @gluBeginTrim := GetGLuProcAddress(hDLL, 'gluBeginTrim');
+    @gluEndTrim := GetGLuProcAddress(hDLL, 'gluEndTrim');
+    @gluPwlCurve := GetGLuProcAddress(hDLL, 'gluPwlCurve');
+    @gluNurbsCurve := GetGLuProcAddress(hDLL, 'gluNurbsCurve');
+    @gluNurbsSurface := GetGLuProcAddress(hDLL, 'gluNurbsSurface');
+    @gluLoadSamplingMatrices := GetGLuProcAddress(hDLL, 'gluLoadSamplingMatrices');
+    @gluNurbsProperty := GetGLuProcAddress(hDLL, 'gluNurbsProperty');
+    @gluGetNurbsProperty := GetGLuProcAddress(hDLL, 'gluGetNurbsProperty');
+    @gluNurbsCallback := GetGLuProcAddress(hDLL, 'gluNurbsCallback');
+
+    @gluBeginPolygon := GetGLuProcAddress(hDLL, 'gluBeginPolygon');
+    @gluNextContour := GetGLuProcAddress(hDLL, 'gluNextContour');
+    @gluEndPolygon := GetGLuProcAddress(hDLL, 'gluEndPolygon');
+  except
+    raise Exception.Create('Could not load ' + MethodName + ' from ' + dll);
+  end;
 end;
 
 initialization
 
-  try
-    {$IFDEF Win32}
-    LoadGLu('glu32.dll');
-    {$ELSE}
-    {$ifdef darwin}
-    LoadGLu('/System/Library/Frameworks/OpenGL.framework/Libraries/libGLU.dylib');
-    {$else}
-    LoadGLu('libGLU.so.1');
-    {$ENDIF}
-    {$endif}
-  except
-    writeln('error opening libGLU');
-    halt(1);
-  end;
+  {$IFDEF Win32}
+  LoadGLu('glu32.dll');
+  {$ELSE}
+  {$ifdef darwin}
+  LoadGLu('/System/Library/Frameworks/OpenGL.framework/Libraries/libGLU.dylib');
+  {$else}
+  LoadGLu('libGLU.so.1');
+  {$ENDIF}
+  {$endif}
 
 finalization
 

packages/extra/opengl/glut.pp

@@ -511,140 +511,146 @@ begin
 end;
 
 procedure LoadGlut(const dll: String);
+var
+  MethodName: string = '';
+
+  function GetGLutProcAddress(Lib: PtrInt; ProcName: PChar): Pointer;
+  begin
+    MethodName:=ProcName;
+    Result:=GetProcAddress(Lib, ProcName);
+  end;
+
 begin
 
   FreeGlut;
 
   hDLL := LoadLibrary(PChar(dll));
   if hDLL = 0 then raise Exception.Create('Could not load Glut from ' + dll);
-
-  @glutInit := GetProcAddress(hDLL, 'glutInit');
-  @glutInitDisplayMode := GetProcAddress(hDLL, 'glutInitDisplayMode');
-  @glutInitDisplayString := GetProcAddress(hDLL, 'glutInitDisplayString');
-  @glutInitWindowPosition := GetProcAddress(hDLL, 'glutInitWindowPosition');
-  @glutInitWindowSize := GetProcAddress(hDLL, 'glutInitWindowSize');
-  @glutMainLoop := GetProcAddress(hDLL, 'glutMainLoop');
-  @glutCreateWindow := GetProcAddress(hDLL, 'glutCreateWindow');
-  @glutCreateSubWindow := GetProcAddress(hDLL, 'glutCreateSubWindow');
-  @glutDestroyWindow := GetProcAddress(hDLL, 'glutDestroyWindow');
-  @glutPostRedisplay := GetProcAddress(hDLL, 'glutPostRedisplay');
-  @glutPostWindowRedisplay := GetProcAddress(hDLL, 'glutPostWindowRedisplay');
-  @glutSwapBuffers := GetProcAddress(hDLL, 'glutSwapBuffers');
-  @glutGetWindow := GetProcAddress(hDLL, 'glutGetWindow');
-  @glutSetWindow := GetProcAddress(hDLL, 'glutSetWindow');
-  @glutSetWindowTitle := GetProcAddress(hDLL, 'glutSetWindowTitle');
-  @glutSetIconTitle := GetProcAddress(hDLL, 'glutSetIconTitle');
-  @glutPositionWindow := GetProcAddress(hDLL, 'glutPositionWindow');
-  @glutReshapeWindow := GetProcAddress(hDLL, 'glutReshapeWindow');
-  @glutPopWindow := GetProcAddress(hDLL, 'glutPopWindow');
-  @glutPushWindow := GetProcAddress(hDLL, 'glutPushWindow');
-  @glutIconifyWindow := GetProcAddress(hDLL, 'glutIconifyWindow');
-  @glutShowWindow := GetProcAddress(hDLL, 'glutShowWindow');
-  @glutHideWindow := GetProcAddress(hDLL, 'glutHideWindow');
-  @glutFullScreen := GetProcAddress(hDLL, 'glutFullScreen');
-  @glutSetCursor := GetProcAddress(hDLL, 'glutSetCursor');
-  @glutWarpPointer := GetProcAddress(hDLL, 'glutWarpPointer');
-  @glutEstablishOverlay := GetProcAddress(hDLL, 'glutEstablishOverlay');
-  @glutRemoveOverlay := GetProcAddress(hDLL, 'glutRemoveOverlay');
-  @glutUseLayer := GetProcAddress(hDLL, 'glutUseLayer');
-  @glutPostOverlayRedisplay := GetProcAddress(hDLL, 'glutPostOverlayRedisplay');
-  @glutPostWindowOverlayRedisplay := GetProcAddress(hDLL, 'glutPostWindowOverlayRedisplay');
-  @glutShowOverlay := GetProcAddress(hDLL, 'glutShowOverlay');
-  @glutHideOverlay := GetProcAddress(hDLL, 'glutHideOverlay');
-  @glutCreateMenu := GetProcAddress(hDLL, 'glutCreateMenu');
-  @glutDestroyMenu := GetProcAddress(hDLL, 'glutDestroyMenu');
-  @glutGetMenu := GetProcAddress(hDLL, 'glutGetMenu');
-  @glutSetMenu := GetProcAddress(hDLL, 'glutSetMenu');
-  @glutAddMenuEntry := GetProcAddress(hDLL, 'glutAddMenuEntry');
-  @glutAddSubMenu := GetProcAddress(hDLL, 'glutAddSubMenu');
-  @glutChangeToMenuEntry := GetProcAddress(hDLL, 'glutChangeToMenuEntry');
-  @glutChangeToSubMenu := GetProcAddress(hDLL, 'glutChangeToSubMenu');
-  @glutRemoveMenuItem := GetProcAddress(hDLL, 'glutRemoveMenuItem');
-  @glutAttachMenu := GetProcAddress(hDLL, 'glutAttachMenu');
-  @glutDetachMenu := GetProcAddress(hDLL, 'glutDetachMenu');
-  @glutDisplayFunc := GetProcAddress(hDLL, 'glutDisplayFunc');
-  @glutReshapeFunc := GetProcAddress(hDLL, 'glutReshapeFunc');
-  @glutKeyboardFunc := GetProcAddress(hDLL, 'glutKeyboardFunc');
-  @glutMouseFunc := GetProcAddress(hDLL, 'glutMouseFunc');
-  @glutMotionFunc := GetProcAddress(hDLL, 'glutMotionFunc');
-  @glutPassiveMotionFunc := GetProcAddress(hDLL, 'glutPassiveMotionFunc');
-  @glutEntryFunc := GetProcAddress(hDLL, 'glutEntryFunc');
-  @glutVisibilityFunc := GetProcAddress(hDLL, 'glutVisibilityFunc');
-  @glutIdleFunc := GetProcAddress(hDLL, 'glutIdleFunc');
-  @glutTimerFunc := GetProcAddress(hDLL, 'glutTimerFunc');
-  @glutMenuStateFunc := GetProcAddress(hDLL, 'glutMenuStateFunc');
-  @glutSpecialFunc := GetProcAddress(hDLL, 'glutSpecialFunc');
-  @glutSpaceballMotionFunc := GetProcAddress(hDLL, 'glutSpaceballMotionFunc');
-  @glutSpaceballRotateFunc := GetProcAddress(hDLL, 'glutSpaceballRotateFunc');
-  @glutSpaceballButtonFunc := GetProcAddress(hDLL, 'glutSpaceballButtonFunc');
-  @glutButtonBoxFunc := GetProcAddress(hDLL, 'glutButtonBoxFunc');
-  @glutDialsFunc := GetProcAddress(hDLL, 'glutDialsFunc');
-  @glutTabletMotionFunc := GetProcAddress(hDLL, 'glutTabletMotionFunc');
-  @glutTabletButtonFunc := GetProcAddress(hDLL, 'glutTabletButtonFunc');
-  @glutMenuStatusFunc := GetProcAddress(hDLL, 'glutMenuStatusFunc');
-  @glutOverlayDisplayFunc := GetProcAddress(hDLL, 'glutOverlayDisplayFunc');
-  @glutWindowStatusFunc := GetProcAddress(hDLL, 'glutWindowStatusFunc');
-  @glutSetColor := GetProcAddress(hDLL, 'glutSetColor');
-  @glutGetColor := GetProcAddress(hDLL, 'glutGetColor');
-  @glutCopyColormap := GetProcAddress(hDLL, 'glutCopyColormap');
-  @glutGet := GetProcAddress(hDLL, 'glutGet');
-  @glutDeviceGet := GetProcAddress(hDLL, 'glutDeviceGet');
-  @glutExtensionSupported := GetProcAddress(hDLL, 'glutExtensionSupported');
-  @glutGetModifiers := GetProcAddress(hDLL, 'glutGetModifiers');
-  @glutLayerGet := GetProcAddress(hDLL, 'glutLayerGet');
-  @glutBitmapCharacter := GetProcAddress(hDLL, 'glutBitmapCharacter');
-  @glutBitmapWidth := GetProcAddress(hDLL, 'glutBitmapWidth');
-  @glutStrokeCharacter := GetProcAddress(hDLL, 'glutStrokeCharacter');
-  @glutStrokeWidth := GetProcAddress(hDLL, 'glutStrokeWidth');
-  @glutBitmapLength := GetProcAddress(hDLL, 'glutBitmapLength');
-  @glutStrokeLength := GetProcAddress(hDLL, 'glutStrokeLength');
-  @glutWireSphere := GetProcAddress(hDLL, 'glutWireSphere');
-  @glutSolidSphere := GetProcAddress(hDLL, 'glutSolidSphere');
-  @glutWireCone := GetProcAddress(hDLL, 'glutWireCone');
-  @glutSolidCone := GetProcAddress(hDLL, 'glutSolidCone');
-  @glutWireCube := GetProcAddress(hDLL, 'glutWireCube');
-  @glutSolidCube := GetProcAddress(hDLL, 'glutSolidCube');
-  @glutWireTorus := GetProcAddress(hDLL, 'glutWireTorus');
-  @glutSolidTorus := GetProcAddress(hDLL, 'glutSolidTorus');
-  @glutWireDodecahedron := GetProcAddress(hDLL, 'glutWireDodecahedron');
-  @glutSolidDodecahedron := GetProcAddress(hDLL, 'glutSolidDodecahedron');
-  @glutWireTeapot := GetProcAddress(hDLL, 'glutWireTeapot');
-  @glutSolidTeapot := GetProcAddress(hDLL, 'glutSolidTeapot');
-  @glutWireOctahedron := GetProcAddress(hDLL, 'glutWireOctahedron');
-  @glutSolidOctahedron := GetProcAddress(hDLL, 'glutSolidOctahedron');
-  @glutWireTetrahedron := GetProcAddress(hDLL, 'glutWireTetrahedron');
-  @glutSolidTetrahedron := GetProcAddress(hDLL, 'glutSolidTetrahedron');
-  @glutWireIcosahedron := GetProcAddress(hDLL, 'glutWireIcosahedron');
-  @glutSolidIcosahedron := GetProcAddress(hDLL, 'glutSolidIcosahedron');
-  @glutVideoResizeGet := GetProcAddress(hDLL, 'glutVideoResizeGet');
-  @glutSetupVideoResizing := GetProcAddress(hDLL, 'glutSetupVideoResizing');
-  @glutStopVideoResizing := GetProcAddress(hDLL, 'glutStopVideoResizing');
-  @glutVideoResize := GetProcAddress(hDLL, 'glutVideoResize');
-  @glutVideoPan := GetProcAddress(hDLL, 'glutVideoPan');
-  @glutReportErrors := GetProcAddress(hDLL, 'glutReportErrors');
-  @glutGameModeString := GetProcAddress(hDLL, 'glutGameModeString');
-  @glutEnterGameMode  := GetProcAddress(hDLL, 'glutEnterGameMode');
-  @glutLeaveGameMode  := GetProcAddress(hDLL, 'glutLeaveGameMode');
-  @glutGameModeGet    := GetProcAddress(hDLL, 'glutGameModeGet');
-
+  try
+    @glutInit := GetGLutProcAddress(hDLL, 'glutInit');
+    @glutInitDisplayMode := GetGLutProcAddress(hDLL, 'glutInitDisplayMode');
+    @glutInitDisplayString := GetGLutProcAddress(hDLL, 'glutInitDisplayString');
+    @glutInitWindowPosition := GetGLutProcAddress(hDLL, 'glutInitWindowPosition');
+    @glutInitWindowSize := GetGLutProcAddress(hDLL, 'glutInitWindowSize');
+    @glutMainLoop := GetGLutProcAddress(hDLL, 'glutMainLoop');
+    @glutCreateWindow := GetGLutProcAddress(hDLL, 'glutCreateWindow');
+    @glutCreateSubWindow := GetGLutProcAddress(hDLL, 'glutCreateSubWindow');
+    @glutDestroyWindow := GetGLutProcAddress(hDLL, 'glutDestroyWindow');
+    @glutPostRedisplay := GetGLutProcAddress(hDLL, 'glutPostRedisplay');
+    @glutPostWindowRedisplay := GetGLutProcAddress(hDLL, 'glutPostWindowRedisplay');
+    @glutSwapBuffers := GetGLutProcAddress(hDLL, 'glutSwapBuffers');
+    @glutGetWindow := GetGLutProcAddress(hDLL, 'glutGetWindow');
+    @glutSetWindow := GetGLutProcAddress(hDLL, 'glutSetWindow');
+    @glutSetWindowTitle := GetGLutProcAddress(hDLL, 'glutSetWindowTitle');
+    @glutSetIconTitle := GetGLutProcAddress(hDLL, 'glutSetIconTitle');
+    @glutPositionWindow := GetGLutProcAddress(hDLL, 'glutPositionWindow');
+    @glutReshapeWindow := GetGLutProcAddress(hDLL, 'glutReshapeWindow');
+    @glutPopWindow := GetGLutProcAddress(hDLL, 'glutPopWindow');
+    @glutPushWindow := GetGLutProcAddress(hDLL, 'glutPushWindow');
+    @glutIconifyWindow := GetGLutProcAddress(hDLL, 'glutIconifyWindow');
+    @glutShowWindow := GetGLutProcAddress(hDLL, 'glutShowWindow');
+    @glutHideWindow := GetGLutProcAddress(hDLL, 'glutHideWindow');
+    @glutFullScreen := GetGLutProcAddress(hDLL, 'glutFullScreen');
+    @glutSetCursor := GetGLutProcAddress(hDLL, 'glutSetCursor');
+    @glutWarpPointer := GetGLutProcAddress(hDLL, 'glutWarpPointer');
+    @glutEstablishOverlay := GetGLutProcAddress(hDLL, 'glutEstablishOverlay');
+    @glutRemoveOverlay := GetGLutProcAddress(hDLL, 'glutRemoveOverlay');
+    @glutUseLayer := GetGLutProcAddress(hDLL, 'glutUseLayer');
+    @glutPostOverlayRedisplay := GetGLutProcAddress(hDLL, 'glutPostOverlayRedisplay');
+    @glutPostWindowOverlayRedisplay := GetGLutProcAddress(hDLL, 'glutPostWindowOverlayRedisplay');
+    @glutShowOverlay := GetGLutProcAddress(hDLL, 'glutShowOverlay');
+    @glutHideOverlay := GetGLutProcAddress(hDLL, 'glutHideOverlay');
+    @glutCreateMenu := GetGLutProcAddress(hDLL, 'glutCreateMenu');
+    @glutDestroyMenu := GetGLutProcAddress(hDLL, 'glutDestroyMenu');
+    @glutGetMenu := GetGLutProcAddress(hDLL, 'glutGetMenu');
+    @glutSetMenu := GetGLutProcAddress(hDLL, 'glutSetMenu');
+    @glutAddMenuEntry := GetGLutProcAddress(hDLL, 'glutAddMenuEntry');
+    @glutAddSubMenu := GetGLutProcAddress(hDLL, 'glutAddSubMenu');
+    @glutChangeToMenuEntry := GetGLutProcAddress(hDLL, 'glutChangeToMenuEntry');
+    @glutChangeToSubMenu := GetGLutProcAddress(hDLL, 'glutChangeToSubMenu');
+    @glutRemoveMenuItem := GetGLutProcAddress(hDLL, 'glutRemoveMenuItem');
+    @glutAttachMenu := GetGLutProcAddress(hDLL, 'glutAttachMenu');
+    @glutDetachMenu := GetGLutProcAddress(hDLL, 'glutDetachMenu');
+    @glutDisplayFunc := GetGLutProcAddress(hDLL, 'glutDisplayFunc');
+    @glutReshapeFunc := GetGLutProcAddress(hDLL, 'glutReshapeFunc');
+    @glutKeyboardFunc := GetGLutProcAddress(hDLL, 'glutKeyboardFunc');
+    @glutMouseFunc := GetGLutProcAddress(hDLL, 'glutMouseFunc');
+    @glutMotionFunc := GetGLutProcAddress(hDLL, 'glutMotionFunc');
+    @glutPassiveMotionFunc := GetGLutProcAddress(hDLL, 'glutPassiveMotionFunc');
+    @glutEntryFunc := GetGLutProcAddress(hDLL, 'glutEntryFunc');
+    @glutVisibilityFunc := GetGLutProcAddress(hDLL, 'glutVisibilityFunc');
+    @glutIdleFunc := GetGLutProcAddress(hDLL, 'glutIdleFunc');
+    @glutTimerFunc := GetGLutProcAddress(hDLL, 'glutTimerFunc');
+    @glutMenuStateFunc := GetGLutProcAddress(hDLL, 'glutMenuStateFunc');
+    @glutSpecialFunc := GetGLutProcAddress(hDLL, 'glutSpecialFunc');
+    @glutSpaceballMotionFunc := GetGLutProcAddress(hDLL, 'glutSpaceballMotionFunc');
+    @glutSpaceballRotateFunc := GetGLutProcAddress(hDLL, 'glutSpaceballRotateFunc');
+    @glutSpaceballButtonFunc := GetGLutProcAddress(hDLL, 'glutSpaceballButtonFunc');
+    @glutButtonBoxFunc := GetGLutProcAddress(hDLL, 'glutButtonBoxFunc');
+    @glutDialsFunc := GetGLutProcAddress(hDLL, 'glutDialsFunc');
+    @glutTabletMotionFunc := GetGLutProcAddress(hDLL, 'glutTabletMotionFunc');
+    @glutTabletButtonFunc := GetGLutProcAddress(hDLL, 'glutTabletButtonFunc');
+    @glutMenuStatusFunc := GetGLutProcAddress(hDLL, 'glutMenuStatusFunc');
+    @glutOverlayDisplayFunc := GetGLutProcAddress(hDLL, 'glutOverlayDisplayFunc');
+    @glutWindowStatusFunc := GetGLutProcAddress(hDLL, 'glutWindowStatusFunc');
+    @glutSetColor := GetGLutProcAddress(hDLL, 'glutSetColor');
+    @glutGetColor := GetGLutProcAddress(hDLL, 'glutGetColor');
+    @glutCopyColormap := GetGLutProcAddress(hDLL, 'glutCopyColormap');
+    @glutGet := GetGLutProcAddress(hDLL, 'glutGet');
+    @glutDeviceGet := GetGLutProcAddress(hDLL, 'glutDeviceGet');
+    @glutExtensionSupported := GetGLutProcAddress(hDLL, 'glutExtensionSupported');
+    @glutGetModifiers := GetGLutProcAddress(hDLL, 'glutGetModifiers');
+    @glutLayerGet := GetGLutProcAddress(hDLL, 'glutLayerGet');
+    @glutBitmapCharacter := GetGLutProcAddress(hDLL, 'glutBitmapCharacter');
+    @glutBitmapWidth := GetGLutProcAddress(hDLL, 'glutBitmapWidth');
+    @glutStrokeCharacter := GetGLutProcAddress(hDLL, 'glutStrokeCharacter');
+    @glutStrokeWidth := GetGLutProcAddress(hDLL, 'glutStrokeWidth');
+    @glutBitmapLength := GetGLutProcAddress(hDLL, 'glutBitmapLength');
+    @glutStrokeLength := GetGLutProcAddress(hDLL, 'glutStrokeLength');
+    @glutWireSphere := GetGLutProcAddress(hDLL, 'glutWireSphere');
+    @glutSolidSphere := GetGLutProcAddress(hDLL, 'glutSolidSphere');
+    @glutWireCone := GetGLutProcAddress(hDLL, 'glutWireCone');
+    @glutSolidCone := GetGLutProcAddress(hDLL, 'glutSolidCone');
+    @glutWireCube := GetGLutProcAddress(hDLL, 'glutWireCube');
+    @glutSolidCube := GetGLutProcAddress(hDLL, 'glutSolidCube');
+    @glutWireTorus := GetGLutProcAddress(hDLL, 'glutWireTorus');
+    @glutSolidTorus := GetGLutProcAddress(hDLL, 'glutSolidTorus');
+    @glutWireDodecahedron := GetGLutProcAddress(hDLL, 'glutWireDodecahedron');
+    @glutSolidDodecahedron := GetGLutProcAddress(hDLL, 'glutSolidDodecahedron');
+    @glutWireTeapot := GetGLutProcAddress(hDLL, 'glutWireTeapot');
+    @glutSolidTeapot := GetGLutProcAddress(hDLL, 'glutSolidTeapot');
+    @glutWireOctahedron := GetGLutProcAddress(hDLL, 'glutWireOctahedron');
+    @glutSolidOctahedron := GetGLutProcAddress(hDLL, 'glutSolidOctahedron');
+    @glutWireTetrahedron := GetGLutProcAddress(hDLL, 'glutWireTetrahedron');
+    @glutSolidTetrahedron := GetGLutProcAddress(hDLL, 'glutSolidTetrahedron');
+    @glutWireIcosahedron := GetGLutProcAddress(hDLL, 'glutWireIcosahedron');
+    @glutSolidIcosahedron := GetGLutProcAddress(hDLL, 'glutSolidIcosahedron');
+    @glutVideoResizeGet := GetGLutProcAddress(hDLL, 'glutVideoResizeGet');
+    @glutSetupVideoResizing := GetGLutProcAddress(hDLL, 'glutSetupVideoResizing');
+    @glutStopVideoResizing := GetGLutProcAddress(hDLL, 'glutStopVideoResizing');
+    @glutVideoResize := GetGLutProcAddress(hDLL, 'glutVideoResize');
+    @glutVideoPan := GetGLutProcAddress(hDLL, 'glutVideoPan');
+    @glutReportErrors := GetGLutProcAddress(hDLL, 'glutReportErrors');
+    @glutGameModeString := GetGLutProcAddress(hDLL, 'glutGameModeString');
+    @glutEnterGameMode  := GetGLutProcAddress(hDLL, 'glutEnterGameMode');
+    @glutLeaveGameMode  := GetGLutProcAddress(hDLL, 'glutLeaveGameMode');
+    @glutGameModeGet    := GetGLutProcAddress(hDLL, 'glutGameModeGet');
+  except
+    raise Exception.Create('Could not load ' + MethodName + ' from ' + dll);
+  end;
 end;
 
 initialization
 
-  try
-    {$IFDEF Win32}
-    LoadGlut('glut32.dll');
-    {$ELSE}
-    {$ifdef darwin}
-    LoadGlut('/System/Library/Frameworks/GLUT.framework/GLUT');
-    {$else}
-    LoadGlut('libglut.so.3');
-    {$endif}
-    {$ENDIF}
-  except
-    writeln('Can''t load glut library');
-    halt(1);
-  end;
+  {$IFDEF Win32}
+  LoadGlut('glut32.dll');
+  {$ELSE}
+  {$ifdef darwin}
+  LoadGlut('/System/Library/Frameworks/GLUT.framework/GLUT');
+  {$else}
+  LoadGlut('libglut.so.3');
+  {$endif}
+  {$ENDIF}
 
 finalization