2002-11-18 15:02:17 -05:00
|
|
|
/* ----------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2001-2002, Lev Povalahev
|
|
|
|
All rights reserved.
|
|
|
|
|
2004-02-15 10:21:24 -05:00
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
2002-11-18 15:02:17 -05:00
|
|
|
are permitted provided that the following conditions are met:
|
|
|
|
|
2004-02-15 10:21:24 -05:00
|
|
|
* Redistributions of source code must retain the above copyright notice,
|
2003-09-21 03:43:02 -04:00
|
|
|
this list of conditions and the following disclaimer.
|
2004-02-15 10:21:24 -05:00
|
|
|
* Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
this list of conditions and the following disclaimer in the documentation
|
2003-09-21 03:43:02 -04:00
|
|
|
and/or other materials provided with the distribution.
|
2004-02-15 10:21:24 -05:00
|
|
|
* The name of the author may be used to endorse or promote products
|
2003-09-21 03:43:02 -04:00
|
|
|
derived from this software without specific prior written permission.
|
2002-11-18 15:02:17 -05:00
|
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
2004-02-15 10:21:24 -05:00
|
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
|
|
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
|
|
|
|
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
|
|
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
|
|
|
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
|
|
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
2002-11-18 15:02:17 -05:00
|
|
|
THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
------------------------------------------------------------------------------*/
|
2004-02-15 10:21:24 -05:00
|
|
|
/*
|
2003-09-21 03:43:02 -04:00
|
|
|
Lev Povalahev
|
2002-11-18 15:02:17 -05:00
|
|
|
|
2003-09-21 03:43:02 -04:00
|
|
|
levp@gmx.net
|
2002-11-18 15:02:17 -05:00
|
|
|
|
2003-09-21 03:43:02 -04:00
|
|
|
http://www.uni-karlsruhe.de/~uli2/
|
2002-11-18 15:02:17 -05:00
|
|
|
|
2004-02-15 10:21:24 -05:00
|
|
|
*/
|
2002-12-31 23:05:44 -05:00
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
#include <stdio.h>
|
2004-03-07 10:49:00 -05:00
|
|
|
#include <stdlib.h>
|
2002-11-18 15:02:17 -05:00
|
|
|
#include <string.h>
|
2003-12-15 06:49:17 -05:00
|
|
|
#include "extgl.h"
|
|
|
|
#include "common_tools.h"
|
2002-11-18 15:02:17 -05:00
|
|
|
|
|
|
|
/* turn off the warning for the borland compiler*/
|
|
|
|
#ifdef __BORLANDC__
|
|
|
|
#pragma warn -8064
|
|
|
|
#pragma warn -8065
|
|
|
|
#endif /* __BORLANDC__ */
|
|
|
|
|
2002-12-30 02:07:40 -05:00
|
|
|
#ifdef _X11
|
2002-12-11 02:16:31 -05:00
|
|
|
|
|
|
|
#include <dlfcn.h>
|
|
|
|
|
|
|
|
glXGetFBConfigsPROC glXGetFBConfigs = NULL;
|
|
|
|
glXChooseFBConfigPROC glXChooseFBConfig = NULL;
|
|
|
|
glXGetFBConfigAttribPROC glXGetFBConfigAttrib = NULL;
|
|
|
|
glXGetVisualFromFBConfigPROC glXGetVisualFromFBConfig = NULL;
|
|
|
|
glXCreateWindowPROC glXCreateWindow = NULL;
|
|
|
|
glXDestroyWindowPROC glXDestroyWindow = NULL;
|
|
|
|
glXCreatePixmapPROC glXCreatePixmap = NULL;
|
|
|
|
glXDestroyPixmapPROC glXDestroyPixmap = NULL;
|
|
|
|
glXCreatePbufferPROC glXCreatePbuffer = NULL;
|
|
|
|
glXDestroyPbufferPROC glXDestroyPbuffer = NULL;
|
|
|
|
glXQueryDrawablePROC glXQueryDrawable = NULL;
|
|
|
|
glXCreateNewContextPROC glXCreateNewContext = NULL;
|
|
|
|
glXMakeContextCurrentPROC glXMakeContextCurrent = NULL;
|
|
|
|
glXGetCurrentReadDrawablePROC glXGetCurrentReadDrawable = NULL;
|
|
|
|
glXGetCurrentDisplayPROC glXGetCurrentDisplay = NULL;
|
|
|
|
glXQueryContextPROC glXQueryContext = NULL;
|
|
|
|
glXSelectEventPROC glXSelectEvent = NULL;
|
|
|
|
glXGetSelectedEventPROC glXGetSelectedEvent = NULL;
|
|
|
|
glXGetProcAddressARBPROC glXGetProcAddressARB = NULL;
|
|
|
|
glXChooseVisualPROC glXChooseVisual = NULL;
|
|
|
|
glXCopyContextPROC glXCopyContext = NULL;
|
|
|
|
glXCreateContextPROC glXCreateContext = NULL;
|
|
|
|
glXCreateGLXPixmapPROC glXCreateGLXPixmap = NULL;
|
|
|
|
glXDestroyContextPROC glXDestroyContext = NULL;
|
|
|
|
glXDestroyGLXPixmapPROC glXDestroyGLXPixmap = NULL;
|
|
|
|
glXGetConfigPROC glXGetConfig = NULL;
|
|
|
|
glXGetCurrentContextPROC glXGetCurrentContext = NULL;
|
|
|
|
glXGetCurrentDrawablePROC glXGetCurrentDrawable = NULL;
|
|
|
|
glXIsDirectPROC glXIsDirect = NULL;
|
|
|
|
glXMakeCurrentPROC glXMakeCurrent = NULL;
|
|
|
|
glXQueryExtensionPROC glXQueryExtension = NULL;
|
|
|
|
glXQueryVersionPROC glXQueryVersion = NULL;
|
|
|
|
glXSwapBuffersPROC glXSwapBuffers = NULL;
|
|
|
|
glXUseXFontPROC glXUseXFont = NULL;
|
|
|
|
glXWaitGLPROC glXWaitGL = NULL;
|
|
|
|
glXWaitXPROC glXWaitX = NULL;
|
|
|
|
glXGetClientStringPROC glXGetClientString = NULL;
|
|
|
|
glXQueryServerStringPROC glXQueryServerString = NULL;
|
|
|
|
glXQueryExtensionsStringPROC glXQueryExtensionsString = NULL;
|
2004-01-03 03:09:17 -05:00
|
|
|
|
|
|
|
/* GLX_SGI_swap_control */
|
|
|
|
glXSwapIntervalSGIPROC glXSwapIntervalSGI = NULL;
|
2002-12-11 02:16:31 -05:00
|
|
|
#endif
|
|
|
|
|
2003-09-29 05:26:20 -04:00
|
|
|
#ifdef _AGL
|
|
|
|
aglChoosePixelFormatPROC aglChoosePixelFormat = NULL;
|
|
|
|
aglDestroyPixelFormatPROC aglDestroyPixelFormat = NULL;
|
|
|
|
aglNextPixelFormatPROC aglNextPixelFormat = NULL;
|
|
|
|
aglDescribePixelFormatPROC aglDescribePixelFormat = NULL;
|
|
|
|
aglDevicesOfPixelFormatPROC aglDevicesOfPixelFormat = NULL;
|
|
|
|
aglQueryRendererInfoPROC aglQueryRendererInfo = NULL;
|
|
|
|
aglDestroyRendererInfoPROC aglDestroyRendererInfo = NULL;
|
|
|
|
aglNextRendererInfoPROC aglNextRendererInfo = NULL;
|
|
|
|
aglDescribeRendererPROC aglDescribeRenderer = NULL;
|
|
|
|
aglCreateContextPROC aglCreateContext = NULL;
|
|
|
|
aglDestroyContextPROC aglDestroyContext = NULL;
|
|
|
|
aglCopyContextPROC aglCopyContext = NULL;
|
|
|
|
aglUpdateContextPROC aglUpdateContext = NULL;
|
|
|
|
aglSetCurrentContextPROC aglSetCurrentContext = NULL;
|
|
|
|
aglGetCurrentContextPROC aglGetCurrentContext = NULL;
|
|
|
|
aglSetDrawablePROC aglSetDrawable = NULL;
|
|
|
|
aglSetOffScreenPROC aglSetOffScreen = NULL;
|
|
|
|
aglSetFullScreenPROC aglSetFullScreen = NULL;
|
|
|
|
aglGetDrawablePROC aglGetDrawable = NULL;
|
|
|
|
aglSetVirtualScreenPROC aglSetVirtualScreen = NULL;
|
|
|
|
aglGetVirtualScreenPROC aglGetVirtualScreen = NULL;
|
|
|
|
aglGetVersionPROC aglGetVersion = NULL;
|
|
|
|
aglSwapBuffersPROC aglSwapBuffers = NULL;
|
|
|
|
aglEnablePROC aglEnable = NULL;
|
|
|
|
aglDisablePROC aglDisable = NULL;
|
|
|
|
aglIsEnabledPROC aglIsEnabled = NULL;
|
|
|
|
aglSetIntegerPROC aglSetInteger = NULL;
|
|
|
|
aglGetIntegerPROC aglGetInteger = NULL;
|
|
|
|
aglUseFontPROC aglUseFont = NULL;
|
|
|
|
aglGetErrorPROC aglGetError = NULL;
|
|
|
|
aglErrorStringPROC aglErrorString = NULL;
|
|
|
|
aglResetLibraryPROC aglResetLibrary = NULL;
|
2004-02-15 10:21:24 -05:00
|
|
|
aglSurfaceTexturePROC aglSurfaceTexture = NULL;
|
2003-09-29 05:26:20 -04:00
|
|
|
#endif
|
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
/* function variables */
|
|
|
|
|
2004-01-29 17:08:59 -05:00
|
|
|
/*glAccumPROC glAccum = NULL;
|
2002-12-11 02:16:31 -05:00
|
|
|
glAlphaFuncPROC glAlphaFunc = NULL;
|
|
|
|
glAreTexturesResidentPROC glAreTexturesResident = NULL;
|
|
|
|
glArrayElementPROC glArrayElement = NULL;
|
|
|
|
glBeginPROC glBegin = NULL;
|
|
|
|
glBindTexturePROC glBindTexture = NULL;
|
|
|
|
glBitmapPROC glBitmap = NULL;
|
|
|
|
glBlendFuncPROC glBlendFunc = NULL;
|
|
|
|
glCallListPROC glCallList = NULL;
|
|
|
|
glCallListsPROC glCallLists = NULL;
|
|
|
|
glClearPROC glClear = NULL;
|
|
|
|
glClearAccumPROC glClearAccum = NULL;
|
|
|
|
glClearColorPROC glClearColor = NULL;
|
|
|
|
glClearDepthPROC glClearDepth = NULL;
|
|
|
|
glClearIndexPROC glClearIndex = NULL;
|
|
|
|
glClearStencilPROC glClearStencil = NULL;
|
|
|
|
glClipPlanePROC glClipPlane = NULL;
|
|
|
|
glColor3bPROC glColor3b = NULL;
|
|
|
|
glColor3bvPROC glColor3bv = NULL;
|
|
|
|
glColor3dPROC glColor3d = NULL;
|
|
|
|
glColor3dvPROC glColor3dv = NULL;
|
|
|
|
glColor3fPROC glColor3f = NULL;
|
|
|
|
glColor3fvPROC glColor3fv = NULL;
|
|
|
|
glColor3iPROC glColor3i = NULL;
|
|
|
|
glColor3ivPROC glColor3iv = NULL;
|
|
|
|
glColor3sPROC glColor3s = NULL;
|
|
|
|
glColor3svPROC glColor3sv = NULL;
|
|
|
|
glColor3ubPROC glColor3ub = NULL;
|
|
|
|
glColor3ubvPROC glColor3ubv = NULL;
|
|
|
|
glColor3uiPROC glColor3ui = NULL;
|
|
|
|
glColor3uivPROC glColor3uiv = NULL;
|
|
|
|
glColor3usPROC glColor3us = NULL;
|
|
|
|
glColor3usvPROC glColor3usv = NULL;
|
|
|
|
glColor4bPROC glColor4b = NULL;
|
|
|
|
glColor4bvPROC glColor4bv = NULL;
|
|
|
|
glColor4dPROC glColor4d = NULL;
|
|
|
|
glColor4dvPROC glColor4dv = NULL;
|
|
|
|
glColor4fPROC glColor4f = NULL;
|
|
|
|
glColor4fvPROC glColor4fv = NULL;
|
|
|
|
glColor4iPROC glColor4i = NULL;
|
|
|
|
glColor4ivPROC glColor4iv = NULL;
|
|
|
|
glColor4sPROC glColor4s = NULL;
|
|
|
|
glColor4svPROC glColor4sv = NULL;
|
|
|
|
glColor4ubPROC glColor4ub = NULL;
|
|
|
|
glColor4ubvPROC glColor4ubv = NULL;
|
|
|
|
glColor4uiPROC glColor4ui = NULL;
|
|
|
|
glColor4uivPROC glColor4uiv = NULL;
|
|
|
|
glColor4usPROC glColor4us = NULL;
|
|
|
|
glColor4usvPROC glColor4usv = NULL;
|
|
|
|
glColorMaskPROC glColorMask = NULL;
|
|
|
|
glColorMaterialPROC glColorMaterial = NULL;
|
|
|
|
glColorPointerPROC glColorPointer = NULL;
|
|
|
|
glCopyPixelsPROC glCopyPixels = NULL;
|
|
|
|
glCopyTexImage1DPROC glCopyTexImage1D = NULL;
|
|
|
|
glCopyTexImage2DPROC glCopyTexImage2D = NULL;
|
|
|
|
glCopyTexSubImage1DPROC glCopyTexSubImage1D = NULL;
|
|
|
|
glCopyTexSubImage2DPROC glCopyTexSubImage2D = NULL;
|
|
|
|
glCullFacePROC glCullFace = NULL;
|
|
|
|
glDeleteListsPROC glDeleteLists = NULL;
|
|
|
|
glDeleteTexturesPROC glDeleteTextures = NULL;
|
|
|
|
glDepthFuncPROC glDepthFunc = NULL;
|
|
|
|
glDepthMaskPROC glDepthMask = NULL;
|
|
|
|
glDepthRangePROC glDepthRange = NULL;
|
|
|
|
glDisablePROC glDisable = NULL;
|
|
|
|
glDisableClientStatePROC glDisableClientState = NULL;
|
|
|
|
glDrawArraysPROC glDrawArrays = NULL;
|
|
|
|
glDrawBufferPROC glDrawBuffer = NULL;
|
|
|
|
glDrawElementsPROC glDrawElements = NULL;
|
|
|
|
glDrawPixelsPROC glDrawPixels = NULL;
|
|
|
|
glEdgeFlagPROC glEdgeFlag = NULL;
|
|
|
|
glEdgeFlagPointerPROC glEdgeFlagPointer = NULL;
|
|
|
|
glEdgeFlagvPROC glEdgeFlagv = NULL;
|
|
|
|
glEnablePROC glEnable = NULL;
|
|
|
|
glEnableClientStatePROC glEnableClientState = NULL;
|
|
|
|
glEndPROC glEnd = NULL;
|
|
|
|
glEndListPROC glEndList = NULL;
|
|
|
|
glEvalCoord1dPROC glEvalCoord1d = NULL;
|
|
|
|
glEvalCoord1dvPROC glEvalCoord1dv = NULL;
|
|
|
|
glEvalCoord1fPROC glEvalCoord1f = NULL;
|
|
|
|
glEvalCoord1fvPROC glEvalCoord1fv = NULL;
|
|
|
|
glEvalCoord2dPROC glEvalCoord2d = NULL;
|
|
|
|
glEvalCoord2dvPROC glEvalCoord2dv = NULL;
|
|
|
|
glEvalCoord2fPROC glEvalCoord2f = NULL;
|
|
|
|
glEvalCoord2fvPROC glEvalCoord2fv = NULL;
|
|
|
|
glEvalMesh1PROC glEvalMesh1 = NULL;
|
|
|
|
glEvalMesh2PROC glEvalMesh2 = NULL;
|
|
|
|
glEvalPoint1PROC glEvalPoint1 = NULL;
|
|
|
|
glEvalPoint2PROC glEvalPoint2 = NULL;
|
|
|
|
glFeedbackBufferPROC glFeedbackBuffer = NULL;
|
|
|
|
glFinishPROC glFinish = NULL;
|
|
|
|
glFlushPROC glFlush = NULL;
|
|
|
|
glFogfPROC glFogf = NULL;
|
|
|
|
glFogfvPROC glFogfv = NULL;
|
|
|
|
glFogiPROC glFogi = NULL;
|
|
|
|
glFogivPROC glFogiv = NULL;
|
|
|
|
glFrontFacePROC glFrontFace = NULL;
|
|
|
|
glFrustumPROC glFrustum = NULL;
|
|
|
|
glGenListsPROC glGenLists = NULL;
|
|
|
|
glGenTexturesPROC glGenTextures = NULL;
|
|
|
|
glGetBooleanvPROC glGetBooleanv = NULL;
|
|
|
|
glGetClipPlanePROC glGetClipPlane = NULL;
|
|
|
|
glGetDoublevPROC glGetDoublev = NULL;
|
|
|
|
glGetErrorPROC glGetError = NULL;
|
|
|
|
glGetFloatvPROC glGetFloatv = NULL;
|
|
|
|
glGetIntegervPROC glGetIntegerv = NULL;
|
|
|
|
glGetLightfvPROC glGetLightfv = NULL;
|
|
|
|
glGetLightivPROC glGetLightiv = NULL;
|
|
|
|
glGetMapdvPROC glGetMapdv = NULL;
|
|
|
|
glGetMapfvPROC glGetMapfv = NULL;
|
|
|
|
glGetMapivPROC glGetMapiv = NULL;
|
|
|
|
glGetMaterialfvPROC glGetMaterialfv = NULL;
|
|
|
|
glGetMaterialivPROC glGetMaterialiv = NULL;
|
|
|
|
glGetPixelMapfvPROC glGetPixelMapfv = NULL;
|
|
|
|
glGetPixelMapuivPROC glGetPixelMapuiv = NULL;
|
|
|
|
glGetPixelMapusvPROC glGetPixelMapusv = NULL;
|
|
|
|
glGetPointervPROC glGetPointerv = NULL;
|
|
|
|
glGetPolygonStipplePROC glGetPolygonStipple = NULL;
|
|
|
|
glGetStringPROC glGetString = NULL;
|
|
|
|
glGetTexEnvfvPROC glGetTexEnvfv = NULL;
|
|
|
|
glGetTexEnvivPROC glGetTexEnviv = NULL;
|
|
|
|
glGetTexGendvPROC glGetTexGendv = NULL;
|
|
|
|
glGetTexGenfvPROC glGetTexGenfv = NULL;
|
|
|
|
glGetTexGenivPROC glGetTexGeniv = NULL;
|
|
|
|
glGetTexImagePROC glGetTexImage = NULL;
|
|
|
|
glGetTexLevelParameterfvPROC glGetTexLevelParameterfv = NULL;
|
|
|
|
glGetTexLevelParameterivPROC glGetTexLevelParameteriv = NULL;
|
|
|
|
glGetTexParameterfvPROC glGetTexParameterfv = NULL;
|
|
|
|
glGetTexParameterivPROC glGetTexParameteriv = NULL;
|
|
|
|
glHintPROC glHint = NULL;
|
|
|
|
glIndexMaskPROC glIndexMask = NULL;
|
|
|
|
glIndexPointerPROC glIndexPointer = NULL;
|
|
|
|
glIndexdPROC glIndexd = NULL;
|
|
|
|
glIndexdvPROC glIndexdv = NULL;
|
|
|
|
glIndexfPROC glIndexf = NULL;
|
|
|
|
glIndexfvPROC glIndexfv = NULL;
|
|
|
|
glIndexiPROC glIndexi = NULL;
|
|
|
|
glIndexivPROC glIndexiv = NULL;
|
|
|
|
glIndexsPROC glIndexs = NULL;
|
|
|
|
glIndexsvPROC glIndexsv = NULL;
|
|
|
|
glIndexubPROC glIndexub = NULL;
|
|
|
|
glIndexubvPROC glIndexubv = NULL;
|
|
|
|
glInitNamesPROC glInitNames = NULL;
|
|
|
|
glInterleavedArraysPROC glInterleavedArrays = NULL;
|
|
|
|
glIsEnabledPROC glIsEnabled = NULL;
|
|
|
|
glIsListPROC glIsList = NULL;
|
|
|
|
glIsTexturePROC glIsTexture = NULL;
|
|
|
|
glLightModelfPROC glLightModelf = NULL;
|
|
|
|
glLightModelfvPROC glLightModelfv = NULL;
|
|
|
|
glLightModeliPROC glLightModeli = NULL;
|
|
|
|
glLightModelivPROC glLightModeliv = NULL;
|
|
|
|
glLightfPROC glLightf = NULL;
|
|
|
|
glLightfvPROC glLightfv = NULL;
|
|
|
|
glLightiPROC glLighti = NULL;
|
|
|
|
glLightivPROC glLightiv = NULL;
|
|
|
|
glLineStipplePROC glLineStipple = NULL;
|
|
|
|
glLineWidthPROC glLineWidth = NULL;
|
|
|
|
glListBasePROC glListBase = NULL;
|
|
|
|
glLoadIdentityPROC glLoadIdentity = NULL;
|
|
|
|
glLoadMatrixdPROC glLoadMatrixd = NULL;
|
|
|
|
glLoadMatrixfPROC glLoadMatrixf = NULL;
|
|
|
|
glLoadNamePROC glLoadName = NULL;
|
|
|
|
glLogicOpPROC glLogicOp = NULL;
|
|
|
|
glMap1dPROC glMap1d = NULL;
|
|
|
|
glMap1fPROC glMap1f = NULL;
|
|
|
|
glMap2dPROC glMap2d = NULL;
|
|
|
|
glMap2fPROC glMap2f = NULL;
|
|
|
|
glMapGrid1dPROC glMapGrid1d = NULL;
|
|
|
|
glMapGrid1fPROC glMapGrid1f = NULL;
|
|
|
|
glMapGrid2dPROC glMapGrid2d = NULL;
|
|
|
|
glMapGrid2fPROC glMapGrid2f = NULL;
|
|
|
|
glMaterialfPROC glMaterialf = NULL;
|
|
|
|
glMaterialfvPROC glMaterialfv = NULL;
|
|
|
|
glMaterialiPROC glMateriali = NULL;
|
|
|
|
glMaterialivPROC glMaterialiv = NULL;
|
|
|
|
glMatrixModePROC glMatrixMode = NULL;
|
|
|
|
glMultMatrixdPROC glMultMatrixd = NULL;
|
|
|
|
glMultMatrixfPROC glMultMatrixf = NULL;
|
|
|
|
glNewListPROC glNewList = NULL;
|
|
|
|
glNormal3bPROC glNormal3b = NULL;
|
|
|
|
glNormal3bvPROC glNormal3bv = NULL;
|
|
|
|
glNormal3dPROC glNormal3d = NULL;
|
|
|
|
glNormal3dvPROC glNormal3dv = NULL;
|
|
|
|
glNormal3fPROC glNormal3f = NULL;
|
|
|
|
glNormal3fvPROC glNormal3fv = NULL;
|
|
|
|
glNormal3iPROC glNormal3i = NULL;
|
|
|
|
glNormal3ivPROC glNormal3iv = NULL;
|
|
|
|
glNormal3sPROC glNormal3s = NULL;
|
|
|
|
glNormal3svPROC glNormal3sv = NULL;
|
|
|
|
glNormalPointerPROC glNormalPointer = NULL;
|
|
|
|
glOrthoPROC glOrtho = NULL;
|
|
|
|
glPassThroughPROC glPassThrough = NULL;
|
|
|
|
glPixelMapfvPROC glPixelMapfv = NULL;
|
|
|
|
glPixelMapuivPROC glPixelMapuiv = NULL;
|
|
|
|
glPixelMapusvPROC glPixelMapusv = NULL;
|
|
|
|
glPixelStorefPROC glPixelStoref = NULL;
|
|
|
|
glPixelStoreiPROC glPixelStorei = NULL;
|
|
|
|
glPixelTransferfPROC glPixelTransferf = NULL;
|
|
|
|
glPixelTransferiPROC glPixelTransferi = NULL;
|
|
|
|
glPixelZoomPROC glPixelZoom = NULL;
|
|
|
|
glPointSizePROC glPointSize = NULL;
|
|
|
|
glPolygonModePROC glPolygonMode = NULL;
|
|
|
|
glPolygonOffsetPROC glPolygonOffset = NULL;
|
|
|
|
glPolygonStipplePROC glPolygonStipple = NULL;
|
|
|
|
glPopAttribPROC glPopAttrib = NULL;
|
|
|
|
glPopClientAttribPROC glPopClientAttrib = NULL;
|
|
|
|
glPopMatrixPROC glPopMatrix = NULL;
|
|
|
|
glPopNamePROC glPopName = NULL;
|
|
|
|
glPrioritizeTexturesPROC glPrioritizeTextures = NULL;
|
|
|
|
glPushAttribPROC glPushAttrib = NULL;
|
|
|
|
glPushClientAttribPROC glPushClientAttrib = NULL;
|
|
|
|
glPushMatrixPROC glPushMatrix = NULL;
|
|
|
|
glPushNamePROC glPushName = NULL;
|
|
|
|
glRasterPos2dPROC glRasterPos2d = NULL;
|
|
|
|
glRasterPos2dvPROC glRasterPos2dv = NULL;
|
|
|
|
glRasterPos2fPROC glRasterPos2f = NULL;
|
|
|
|
glRasterPos2fvPROC glRasterPos2fv = NULL;
|
|
|
|
glRasterPos2iPROC glRasterPos2i = NULL;
|
|
|
|
glRasterPos2ivPROC glRasterPos2iv = NULL;
|
|
|
|
glRasterPos2sPROC glRasterPos2s = NULL;
|
|
|
|
glRasterPos2svPROC glRasterPos2sv = NULL;
|
|
|
|
glRasterPos3dPROC glRasterPos3d = NULL;
|
|
|
|
glRasterPos3dvPROC glRasterPos3dv = NULL;
|
|
|
|
glRasterPos3fPROC glRasterPos3f = NULL;
|
|
|
|
glRasterPos3fvPROC glRasterPos3fv = NULL;
|
|
|
|
glRasterPos3iPROC glRasterPos3i = NULL;
|
|
|
|
glRasterPos3ivPROC glRasterPos3iv = NULL;
|
|
|
|
glRasterPos3sPROC glRasterPos3s = NULL;
|
|
|
|
glRasterPos3svPROC glRasterPos3sv = NULL;
|
|
|
|
glRasterPos4dPROC glRasterPos4d = NULL;
|
|
|
|
glRasterPos4dvPROC glRasterPos4dv = NULL;
|
|
|
|
glRasterPos4fPROC glRasterPos4f = NULL;
|
|
|
|
glRasterPos4fvPROC glRasterPos4fv = NULL;
|
|
|
|
glRasterPos4iPROC glRasterPos4i = NULL;
|
|
|
|
glRasterPos4ivPROC glRasterPos4iv = NULL;
|
|
|
|
glRasterPos4sPROC glRasterPos4s = NULL;
|
|
|
|
glRasterPos4svPROC glRasterPos4sv = NULL;
|
|
|
|
glReadBufferPROC glReadBuffer = NULL;
|
|
|
|
glReadPixelsPROC glReadPixels = NULL;
|
|
|
|
glRectdPROC glRectd = NULL;
|
|
|
|
glRectdvPROC glRectdv = NULL;
|
|
|
|
glRectfPROC glRectf = NULL;
|
|
|
|
glRectfvPROC glRectfv = NULL;
|
|
|
|
glRectiPROC glRecti = NULL;
|
|
|
|
glRectivPROC glRectiv = NULL;
|
|
|
|
glRectsPROC glRects = NULL;
|
|
|
|
glRectsvPROC glRectsv = NULL;
|
|
|
|
glRenderModePROC glRenderMode = NULL;
|
|
|
|
glRotatedPROC glRotated = NULL;
|
|
|
|
glRotatefPROC glRotatef = NULL;
|
|
|
|
glScaledPROC glScaled = NULL;
|
|
|
|
glScalefPROC glScalef = NULL;
|
|
|
|
glScissorPROC glScissor = NULL;
|
|
|
|
glSelectBufferPROC glSelectBuffer = NULL;
|
|
|
|
glShadeModelPROC glShadeModel = NULL;
|
|
|
|
glStencilFuncPROC glStencilFunc = NULL;
|
|
|
|
glStencilMaskPROC glStencilMask = NULL;
|
|
|
|
glStencilOpPROC glStencilOp = NULL;
|
|
|
|
glTexCoord1dPROC glTexCoord1d = NULL;
|
|
|
|
glTexCoord1dvPROC glTexCoord1dv = NULL;
|
|
|
|
glTexCoord1fPROC glTexCoord1f = NULL;
|
|
|
|
glTexCoord1fvPROC glTexCoord1fv = NULL;
|
|
|
|
glTexCoord1iPROC glTexCoord1i = NULL;
|
|
|
|
glTexCoord1ivPROC glTexCoord1iv = NULL;
|
|
|
|
glTexCoord1sPROC glTexCoord1s = NULL;
|
|
|
|
glTexCoord1svPROC glTexCoord1sv = NULL;
|
|
|
|
glTexCoord2dPROC glTexCoord2d = NULL;
|
|
|
|
glTexCoord2dvPROC glTexCoord2dv = NULL;
|
|
|
|
glTexCoord2fPROC glTexCoord2f = NULL;
|
|
|
|
glTexCoord2fvPROC glTexCoord2fv = NULL;
|
|
|
|
glTexCoord2iPROC glTexCoord2i = NULL;
|
|
|
|
glTexCoord2ivPROC glTexCoord2iv = NULL;
|
|
|
|
glTexCoord2sPROC glTexCoord2s = NULL;
|
|
|
|
glTexCoord2svPROC glTexCoord2sv = NULL;
|
|
|
|
glTexCoord3dPROC glTexCoord3d = NULL;
|
|
|
|
glTexCoord3dvPROC glTexCoord3dv = NULL;
|
|
|
|
glTexCoord3fPROC glTexCoord3f = NULL;
|
|
|
|
glTexCoord3fvPROC glTexCoord3fv = NULL;
|
|
|
|
glTexCoord3iPROC glTexCoord3i = NULL;
|
|
|
|
glTexCoord3ivPROC glTexCoord3iv = NULL;
|
|
|
|
glTexCoord3sPROC glTexCoord3s = NULL;
|
|
|
|
glTexCoord3svPROC glTexCoord3sv = NULL;
|
|
|
|
glTexCoord4dPROC glTexCoord4d = NULL;
|
|
|
|
glTexCoord4dvPROC glTexCoord4dv = NULL;
|
|
|
|
glTexCoord4fPROC glTexCoord4f = NULL;
|
|
|
|
glTexCoord4fvPROC glTexCoord4fv = NULL;
|
|
|
|
glTexCoord4iPROC glTexCoord4i = NULL;
|
|
|
|
glTexCoord4ivPROC glTexCoord4iv = NULL;
|
|
|
|
glTexCoord4sPROC glTexCoord4s = NULL;
|
|
|
|
glTexCoord4svPROC glTexCoord4sv = NULL;
|
|
|
|
glTexCoordPointerPROC glTexCoordPointer = NULL;
|
|
|
|
glTexEnvfPROC glTexEnvf = NULL;
|
|
|
|
glTexEnvfvPROC glTexEnvfv = NULL;
|
|
|
|
glTexEnviPROC glTexEnvi = NULL;
|
|
|
|
glTexEnvivPROC glTexEnviv = NULL;
|
|
|
|
glTexGendPROC glTexGend = NULL;
|
|
|
|
glTexGendvPROC glTexGendv = NULL;
|
|
|
|
glTexGenfPROC glTexGenf = NULL;
|
|
|
|
glTexGenfvPROC glTexGenfv = NULL;
|
|
|
|
glTexGeniPROC glTexGeni = NULL;
|
|
|
|
glTexGenivPROC glTexGeniv = NULL;
|
|
|
|
glTexImage1DPROC glTexImage1D = NULL;
|
|
|
|
glTexImage2DPROC glTexImage2D = NULL;
|
|
|
|
glTexParameterfPROC glTexParameterf = NULL;
|
|
|
|
glTexParameterfvPROC glTexParameterfv = NULL;
|
|
|
|
glTexParameteriPROC glTexParameteri = NULL;
|
|
|
|
glTexParameterivPROC glTexParameteriv = NULL;
|
|
|
|
glTexSubImage1DPROC glTexSubImage1D = NULL;
|
|
|
|
glTexSubImage2DPROC glTexSubImage2D = NULL;
|
|
|
|
glTranslatedPROC glTranslated = NULL;
|
|
|
|
glTranslatefPROC glTranslatef = NULL;
|
|
|
|
glVertex2dPROC glVertex2d = NULL;
|
|
|
|
glVertex2dvPROC glVertex2dv = NULL;
|
|
|
|
glVertex2fPROC glVertex2f = NULL;
|
|
|
|
glVertex2fvPROC glVertex2fv = NULL;
|
|
|
|
glVertex2iPROC glVertex2i = NULL;
|
|
|
|
glVertex2ivPROC glVertex2iv = NULL;
|
|
|
|
glVertex2sPROC glVertex2s = NULL;
|
|
|
|
glVertex2svPROC glVertex2sv = NULL;
|
|
|
|
glVertex3dPROC glVertex3d = NULL;
|
|
|
|
glVertex3dvPROC glVertex3dv = NULL;
|
|
|
|
glVertex3fPROC glVertex3f = NULL;
|
|
|
|
glVertex3fvPROC glVertex3fv = NULL;
|
|
|
|
glVertex3iPROC glVertex3i = NULL;
|
|
|
|
glVertex3ivPROC glVertex3iv = NULL;
|
|
|
|
glVertex3sPROC glVertex3s = NULL;
|
|
|
|
glVertex3svPROC glVertex3sv = NULL;
|
|
|
|
glVertex4dPROC glVertex4d = NULL;
|
|
|
|
glVertex4dvPROC glVertex4dv = NULL;
|
|
|
|
glVertex4fPROC glVertex4f = NULL;
|
|
|
|
glVertex4fvPROC glVertex4fv = NULL;
|
|
|
|
glVertex4iPROC glVertex4i = NULL;
|
|
|
|
glVertex4ivPROC glVertex4iv = NULL;
|
|
|
|
glVertex4sPROC glVertex4s = NULL;
|
|
|
|
glVertex4svPROC glVertex4sv = NULL;
|
|
|
|
glVertexPointerPROC glVertexPointer = NULL;
|
2004-01-29 17:08:59 -05:00
|
|
|
glViewportPROC glViewport = NULL;*/
|
2002-12-11 02:16:31 -05:00
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
/*-------------------------------------*/
|
|
|
|
/* WGL stuff */
|
|
|
|
/*-------------------------------------*/
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
|
|
|
/* WGL_EXT_etxension_string */
|
|
|
|
|
|
|
|
wglGetExtensionsStringEXTPROC wglGetExtensionsStringEXT = NULL;
|
|
|
|
|
|
|
|
/* WGL_ARB_buffer_region */
|
|
|
|
|
|
|
|
wglCreateBufferRegionARBPROC wglCreateBufferRegionARB = NULL;
|
|
|
|
wglDeleteBufferRegionARBPROC wglDeleteBufferRegionARB = NULL;
|
|
|
|
wglSaveBufferRegionARBPROC wglSaveBufferRegionARB = NULL;
|
|
|
|
wglRestoreBufferRegionARBPROC wglRestoreBufferRegionARB = NULL;
|
|
|
|
|
|
|
|
/* WGL_ARB_extension_string */
|
|
|
|
|
|
|
|
|
|
|
|
wglGetExtensionsStringARBPROC wglGetExtensionsStringARB = NULL;
|
|
|
|
|
|
|
|
/* WGL_ARB_pbuffer */
|
|
|
|
|
|
|
|
wglCreatePbufferARBPROC wglCreatePbufferARB = NULL;
|
|
|
|
wglGetPbufferDCARBPROC wglGetPbufferDCARB = NULL;
|
|
|
|
wglReleasePbufferDCARBPROC wglReleasePbufferDCARB = NULL;
|
|
|
|
wglDestroyPbufferARBPROC wglDestroyPbufferARB = NULL;
|
|
|
|
wglQueryPbufferARBPROC wglQueryPbufferARB = NULL;
|
|
|
|
|
|
|
|
/* WGL_ARB_pixel_format */
|
|
|
|
|
|
|
|
wglGetPixelFormatAttribivARBPROC wglGetPixelFormatAttribivARB = NULL;
|
|
|
|
wglGetPixelFormatAttribfvARBPROC wglGetPixelFormatAttribfvARB = NULL;
|
|
|
|
wglChoosePixelFormatARBPROC wglChoosePixelFormatARB = NULL;
|
|
|
|
|
|
|
|
/* WGL_ARB_render_texture */
|
|
|
|
|
|
|
|
wglBindTexImageARBPROC wglBindTexImageARB = NULL;
|
|
|
|
wglReleaseTexImageARBPROC wglReleaseTexImageARB = NULL;
|
|
|
|
wglSetPbufferAttribARBPROC wglSetPbufferAttribARB = NULL;
|
|
|
|
|
|
|
|
/* WGL_EXT_swap_control */
|
|
|
|
|
|
|
|
wglSwapIntervalEXTPROC wglSwapIntervalEXT = NULL;
|
|
|
|
wglGetSwapIntervalEXTPROC wglGetSwapIntervalEXT = NULL;
|
|
|
|
|
|
|
|
/* WGL_ARB_make_current_read */
|
|
|
|
|
|
|
|
wglMakeContextCurrentARBPROC wglMakeContextCurrentARB = NULL;
|
|
|
|
wglGetCurrentReadDCARBPROC wglGetCurrentReadDCARB = NULL;
|
|
|
|
|
|
|
|
/* VAR */
|
|
|
|
|
|
|
|
#endif /* WIN32 */
|
|
|
|
|
|
|
|
/*-------------------------------------*/
|
|
|
|
/*---WGL STUFF END---------------------*/
|
|
|
|
/*-------------------------------------*/
|
|
|
|
|
|
|
|
|
2004-01-29 17:08:59 -05:00
|
|
|
/*glBlendColorPROC glBlendColor = NULL;
|
2002-11-18 15:02:17 -05:00
|
|
|
glBlendEquationPROC glBlendEquation = NULL;
|
|
|
|
glColorTablePROC glColorTable = NULL;
|
|
|
|
glColorTableParameterfvPROC glColorTableParameterfv = NULL;
|
|
|
|
glColorTableParameterivPROC glColorTableParameteriv = NULL;
|
|
|
|
glCopyColorTablePROC glCopyColorTable = NULL;
|
|
|
|
glGetColorTablePROC glGetColorTable = NULL;
|
|
|
|
glGetColorTableParameterfvPROC glGetColorTableParameterfv = NULL;
|
|
|
|
glGetColorTableParameterivPROC glGetColorTableParameteriv = NULL;
|
|
|
|
glColorSubTablePROC glColorSubTable = NULL;
|
|
|
|
glCopyColorSubTablePROC glCopyColorSubTable = NULL;
|
|
|
|
glConvolutionFilter1DPROC glConvolutionFilter1D = NULL;
|
|
|
|
glConvolutionFilter2DPROC glConvolutionFilter2D = NULL;
|
|
|
|
glConvolutionParameterfPROC glConvolutionParameterf = NULL;
|
|
|
|
glConvolutionParameterfvPROC glConvolutionParameterfv = NULL;
|
|
|
|
glConvolutionParameteriPROC glConvolutionParameteri = NULL;
|
|
|
|
glConvolutionParameterivPROC glConvolutionParameteriv = NULL;
|
|
|
|
glCopyConvolutionFilter1DPROC glCopyConvolutionFilter1D = NULL;
|
|
|
|
glCopyConvolutionFilter2DPROC glCopyConvolutionFilter2D = NULL;
|
|
|
|
glGetConvolutionFilterPROC glGetConvolutionFilter = NULL;
|
|
|
|
glGetConvolutionParameterfvPROC glGetConvolutionParameterfv = NULL;
|
|
|
|
glGetConvolutionParameterivPROC glGetConvolutionParameteriv = NULL;
|
|
|
|
glGetSeparableFilterPROC glGetSeparableFilter = NULL;
|
|
|
|
glSeparableFilter2DPROC glSeparableFilter2D = NULL;
|
|
|
|
glGetHistogramPROC glGetHistogram = NULL;
|
|
|
|
glGetHistogramParameterfvPROC glGetHistogramParameterfv = NULL;
|
|
|
|
glGetHistogramParameterivPROC glGetHistogramParameteriv = NULL;
|
|
|
|
glGetMinmaxPROC glGetMinmax = NULL;
|
|
|
|
glGetMinmaxParameterfvPROC glGetMinmaxParameterfv = NULL;
|
|
|
|
glGetMinmaxParameterivPROC glGetMinmaxParameteriv = NULL;
|
|
|
|
glHistogramPROC glHistogram = NULL;
|
|
|
|
glMinmaxPROC glMinmax = NULL;
|
|
|
|
glResetHistogramPROC glResetHistogram = NULL;
|
2004-01-29 17:08:59 -05:00
|
|
|
glResetMinmaxPROC glResetMinmax = NULL;*/
|
2002-11-18 15:02:17 -05:00
|
|
|
|
|
|
|
/* EXT_cull_vertex */
|
|
|
|
|
|
|
|
glCullParameterfvEXTPROC glCullParameterfvEXT = NULL;
|
|
|
|
glCullParameterdvEXTPROC glCullParameterdvEXT = NULL;
|
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
//glBlendFuncSeparateEXTPROC glBlendFuncSeparateEXT = NULL;
|
|
|
|
//glBlendFuncSeparateINGRPROC glBlendFuncSeparateINGR = NULL;
|
2002-11-18 15:02:17 -05:00
|
|
|
|
|
|
|
glElementPointerNVPROC glElementPointerNV = NULL;
|
|
|
|
glDrawElementArrayNVPROC glDrawElementArrayNV = NULL;
|
|
|
|
glDrawRangeElementArrayNVPROC glDrawRangeElementArrayNV = NULL;
|
|
|
|
glMultiDrawElementArrayNVPROC glMultiDrawElementArrayNV = NULL;
|
|
|
|
glMultiDrawRangeElementArrayNVPROC glMultiDrawRangeElementArrayNV = NULL;
|
|
|
|
|
2004-01-29 17:08:59 -05:00
|
|
|
bool extgl_error = false;
|
2002-11-18 15:02:17 -05:00
|
|
|
|
|
|
|
struct ExtensionTypes extgl_Extensions;
|
|
|
|
|
2002-12-11 02:16:31 -05:00
|
|
|
#ifdef _WIN32
|
|
|
|
HMODULE lib_gl_handle = NULL;
|
2002-12-30 02:07:40 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef _X11
|
2002-12-11 02:16:31 -05:00
|
|
|
void * lib_gl_handle = NULL;
|
|
|
|
#endif
|
2002-11-18 15:02:17 -05:00
|
|
|
|
2003-09-07 12:11:15 -04:00
|
|
|
#ifdef _AGL
|
2003-09-29 07:58:35 -04:00
|
|
|
CFBundleRef opengl_bundle_ref = NULL;
|
|
|
|
CFBundleRef agl_bundle_ref = NULL;
|
2003-09-07 12:11:15 -04:00
|
|
|
#endif
|
|
|
|
|
2004-03-07 10:18:47 -05:00
|
|
|
jclass extgl_ResetClass(JNIEnv *env, const char *class_name) {
|
|
|
|
jclass clazz = env->FindClass(class_name);
|
|
|
|
jint result = env->UnregisterNatives(clazz);
|
|
|
|
if (result != 0)
|
|
|
|
printfDebug("Could not unregister natives for class %s\n", class_name);
|
|
|
|
return clazz;
|
|
|
|
}
|
|
|
|
|
|
|
|
void extgl_InitializeClass(JNIEnv *env, jclass clazz, jobject ext_set, const char *ext_name, int num_functions, JavaMethodAndGLFunction *functions) {
|
2004-03-07 10:49:00 -05:00
|
|
|
JNINativeMethod *methods = (JNINativeMethod *)malloc(num_functions*sizeof(JNINativeMethod));
|
2004-03-07 10:18:47 -05:00
|
|
|
for (int i = 0; i < num_functions; i++) {
|
|
|
|
JavaMethodAndGLFunction *function = functions + i;
|
|
|
|
if (function->gl_function_name != NULL) {
|
|
|
|
void *gl_func_pointer = extgl_GetProcAddress(function->gl_function_name);
|
|
|
|
if (gl_func_pointer == NULL) {
|
|
|
|
printf("NOTICE: %s disabled because of missing driver symbols\n", ext_name);
|
|
|
|
if (ext_set != NULL)
|
|
|
|
extgl_removeExtension(env, ext_set, ext_name);
|
2004-03-07 10:49:00 -05:00
|
|
|
free(methods);
|
2004-03-07 10:18:47 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
void **gl_function_pointer_pointer = function->gl_function_pointer;
|
|
|
|
*gl_function_pointer_pointer = gl_func_pointer;
|
|
|
|
}
|
|
|
|
JNINativeMethod *method = methods + i;
|
|
|
|
method->name = function->method_name;
|
|
|
|
method->signature = function->signature;
|
|
|
|
method->fnPtr = function->method_pointer;
|
|
|
|
}
|
|
|
|
jint result = env->RegisterNatives(clazz, methods, num_functions);
|
2004-03-07 10:49:00 -05:00
|
|
|
free(methods);
|
2004-03-07 10:18:47 -05:00
|
|
|
if (result != 0)
|
|
|
|
printfDebug("Could not register natives for extension %s\n", ext_name);
|
|
|
|
}
|
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
static void doExtension(JNIEnv *env, jobject ext_set, const char *method_name, const char *ext) {
|
|
|
|
jclass clazz = env->GetObjectClass(ext_set);
|
|
|
|
jmethodID id = env->GetMethodID(clazz, method_name, "(Ljava/lang/Object;)Z");
|
|
|
|
if (id == NULL)
|
|
|
|
return;
|
|
|
|
jstring ext_string = env->NewStringUTF(ext);
|
|
|
|
if (ext_string == NULL) {
|
|
|
|
printf("Could not allocate java string from %s\n", ext);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
env->CallBooleanMethod(ext_set, id, ext_string);
|
|
|
|
}
|
|
|
|
|
2004-01-29 17:08:59 -05:00
|
|
|
void extgl_removeExtension(JNIEnv *env, jobject ext_set, const char *ext) {
|
2003-09-26 09:59:50 -04:00
|
|
|
doExtension(env, ext_set, "remove", ext);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void insertExtension(JNIEnv *env, jobject ext_set, const char *ext) {
|
|
|
|
doExtension(env, ext_set, "add", ext);
|
|
|
|
}
|
2003-09-22 04:31:51 -04:00
|
|
|
|
2003-09-07 12:11:15 -04:00
|
|
|
#ifdef _AGL
|
|
|
|
// -------------------------
|
2003-09-29 07:58:35 -04:00
|
|
|
static CFBundleRef loadBundle(const Str255 frameworkName)
|
2003-09-07 12:11:15 -04:00
|
|
|
{
|
2003-09-21 03:43:02 -04:00
|
|
|
OSStatus err = noErr;
|
|
|
|
FSRefParam fileRefParam;
|
|
|
|
FSRef fileRef;
|
|
|
|
CFURLRef bundleURLOpenGL;
|
2003-09-29 07:58:35 -04:00
|
|
|
CFBundleRef bundle_ref;
|
|
|
|
|
2003-09-21 03:43:02 -04:00
|
|
|
memset(&fileRefParam, 0, sizeof(fileRefParam));
|
|
|
|
memset(&fileRef, 0, sizeof(fileRef));
|
|
|
|
fileRefParam.ioNamePtr = frameworkName;
|
|
|
|
fileRefParam.newRef = &fileRef;
|
|
|
|
|
|
|
|
// Frameworks directory/folder
|
|
|
|
//
|
|
|
|
err = FindFolder (kSystemDomain, kFrameworksFolderType, false, &fileRefParam.ioVRefNum, &fileRefParam.ioDirID);
|
|
|
|
if (noErr != err)
|
|
|
|
{
|
2003-12-20 17:03:25 -05:00
|
|
|
printfDebug("Could not find frameworks folder\n");
|
2003-09-29 07:58:35 -04:00
|
|
|
return NULL;
|
2003-09-21 03:43:02 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// make FSRef for folder
|
|
|
|
//
|
|
|
|
err = PBMakeFSRefSync (&fileRefParam);
|
|
|
|
|
|
|
|
|
|
|
|
if (noErr != err)
|
|
|
|
{
|
2003-12-20 17:03:25 -05:00
|
|
|
printfDebug("Could make FSref to frameworks folder\n");
|
2003-09-29 07:58:35 -04:00
|
|
|
return NULL;
|
2003-09-21 03:43:02 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// create URL to folder
|
|
|
|
//
|
|
|
|
bundleURLOpenGL = CFURLCreateFromFSRef (kCFAllocatorDefault, &fileRef);
|
|
|
|
if (!bundleURLOpenGL)
|
|
|
|
{
|
2003-12-20 17:03:25 -05:00
|
|
|
printfDebug("Could create framework URL\n");
|
2003-09-29 07:58:35 -04:00
|
|
|
return NULL;
|
2003-09-21 03:43:02 -04:00
|
|
|
}
|
|
|
|
|
2003-09-29 07:58:35 -04:00
|
|
|
bundle_ref = CFBundleCreate(kCFAllocatorDefault,bundleURLOpenGL);
|
|
|
|
CFRelease (bundleURLOpenGL);
|
|
|
|
if (bundle_ref == NULL)
|
2003-09-21 03:43:02 -04:00
|
|
|
{
|
2003-12-20 17:03:25 -05:00
|
|
|
printfDebug("Could not load framework\n");
|
2003-09-29 07:58:35 -04:00
|
|
|
return NULL;
|
2003-09-21 03:43:02 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// if the code was successfully loaded, look for our function.
|
2003-09-29 07:58:35 -04:00
|
|
|
if (!CFBundleLoadExecutable(bundle_ref))
|
2003-09-21 03:43:02 -04:00
|
|
|
{
|
2003-12-20 17:03:25 -05:00
|
|
|
printfDebug("Could not load MachO executable\n");
|
2003-09-29 07:58:35 -04:00
|
|
|
CFRelease(bundle_ref);
|
|
|
|
return NULL;
|
2003-09-21 03:43:02 -04:00
|
|
|
}
|
|
|
|
|
2003-09-29 07:58:35 -04:00
|
|
|
return bundle_ref;
|
2003-09-07 12:11:15 -04:00
|
|
|
}
|
|
|
|
|
2003-09-29 07:58:35 -04:00
|
|
|
static void aglUnloadFramework(CFBundleRef f)
|
2003-09-07 12:11:15 -04:00
|
|
|
{
|
2003-09-29 07:58:35 -04:00
|
|
|
CFBundleUnloadExecutable(f);
|
|
|
|
CFRelease(f);
|
2003-09-07 12:11:15 -04:00
|
|
|
}
|
|
|
|
|
2002-12-30 17:06:28 -05:00
|
|
|
#endif
|
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
/* getProcAddress */
|
|
|
|
|
2004-01-29 17:08:59 -05:00
|
|
|
void *extgl_GetProcAddress(const char *name)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
|
|
|
#ifdef _WIN32
|
2003-09-21 03:43:02 -04:00
|
|
|
void *t = wglGetProcAddress(name);
|
|
|
|
if (t == NULL)
|
|
|
|
{
|
2002-12-11 02:16:31 -05:00
|
|
|
t = GetProcAddress(lib_gl_handle, name);
|
|
|
|
if (t == NULL)
|
|
|
|
{
|
2004-02-05 12:14:51 -05:00
|
|
|
printfDebug("Could not locate symbol %s\n", name);
|
|
|
|
extgl_error = true;
|
2002-12-11 02:16:31 -05:00
|
|
|
}
|
2003-09-21 03:43:02 -04:00
|
|
|
}
|
|
|
|
return t;
|
2002-12-30 02:07:40 -05:00
|
|
|
#endif
|
2004-02-15 10:21:24 -05:00
|
|
|
|
2002-12-30 02:07:40 -05:00
|
|
|
#ifdef _X11
|
2003-09-21 03:43:02 -04:00
|
|
|
void *t = (void*)glXGetProcAddressARB((const GLubyte*)name);
|
|
|
|
if (t == NULL)
|
|
|
|
{
|
2002-12-11 02:16:31 -05:00
|
|
|
t = dlsym(lib_gl_handle, name);
|
|
|
|
if (t == NULL)
|
|
|
|
{
|
2004-02-05 12:14:51 -05:00
|
|
|
printfDebug("Could not locate symbol %s\n", name);
|
|
|
|
extgl_error = true;
|
2002-12-11 02:16:31 -05:00
|
|
|
}
|
2003-09-21 03:43:02 -04:00
|
|
|
}
|
|
|
|
return t;
|
2002-11-18 15:02:17 -05:00
|
|
|
#endif
|
2002-12-30 17:06:28 -05:00
|
|
|
|
2003-09-07 12:11:15 -04:00
|
|
|
#ifdef _AGL
|
2004-03-05 17:20:10 -05:00
|
|
|
CFStringRef str = CFStringCreateWithCStringNoCopy(NULL, name, kCFStringEncodingUTF8, kCFAllocatorNull);
|
2003-09-29 07:58:35 -04:00
|
|
|
void *func_pointer = CFBundleGetFunctionPointerForName(opengl_bundle_ref, str);
|
|
|
|
if (func_pointer == NULL) {
|
|
|
|
func_pointer = CFBundleGetFunctionPointerForName(agl_bundle_ref, str);
|
|
|
|
if (func_pointer == NULL) {
|
2003-12-20 17:03:25 -05:00
|
|
|
printfDebug("Could not locate symbol %s\n", name);
|
2003-09-29 07:58:35 -04:00
|
|
|
extgl_error = true;
|
|
|
|
}
|
2003-09-25 11:34:13 -04:00
|
|
|
}
|
2003-09-29 07:58:35 -04:00
|
|
|
CFRelease(str);
|
|
|
|
return func_pointer;
|
2004-02-15 10:21:24 -05:00
|
|
|
#endif
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
static bool QueryExtension(JNIEnv *env, jobject ext_set, const GLubyte*extensions, const char *name)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2003-09-21 03:43:02 -04:00
|
|
|
const GLubyte *start;
|
|
|
|
GLubyte *where, *terminator;
|
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
if (extensions == NULL) {
|
2003-12-20 17:03:25 -05:00
|
|
|
printfDebug("NULL extension string\n");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_error = true;
|
|
|
|
return false;
|
|
|
|
}
|
2004-01-20 04:06:00 -05:00
|
|
|
|
2003-09-21 03:43:02 -04:00
|
|
|
/* Extension names should not have spaces. */
|
|
|
|
where = (GLubyte *) strchr(name, ' ');
|
|
|
|
if (where || *name == '\0')
|
2003-09-26 09:59:50 -04:00
|
|
|
return false;
|
2004-01-20 04:06:00 -05:00
|
|
|
|
2003-09-21 03:43:02 -04:00
|
|
|
/* It takes a bit of care to be fool-proof about parsing the
|
|
|
|
OpenGL extensions string. Don't be fooled by sub-strings,
|
|
|
|
etc. */
|
|
|
|
start = extensions;
|
2004-02-15 10:21:24 -05:00
|
|
|
for (;;)
|
2003-09-21 03:43:02 -04:00
|
|
|
{
|
|
|
|
where = (GLubyte *) strstr((const char *) start, name);
|
|
|
|
if (!where)
|
|
|
|
break;
|
|
|
|
terminator = where + strlen(name);
|
|
|
|
if (where == start || *(where - 1) == ' ')
|
2003-09-26 09:59:50 -04:00
|
|
|
if (*terminator == ' ' || *terminator == '\0') {
|
2004-02-23 18:42:58 -05:00
|
|
|
if (ext_set != NULL) {
|
|
|
|
insertExtension(env, ext_set, name);
|
|
|
|
}
|
2003-09-26 09:59:50 -04:00
|
|
|
return true;
|
|
|
|
}
|
2003-09-21 03:43:02 -04:00
|
|
|
start = terminator;
|
|
|
|
}
|
2003-09-26 09:59:50 -04:00
|
|
|
return false;
|
2004-01-20 04:06:00 -05:00
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
}
|
2004-01-20 04:06:00 -05:00
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
/*-----------------------------------------------------*/
|
|
|
|
/* WGL stuff */
|
|
|
|
/*-----------------------------------------------------*/
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
|
|
|
/** returns true if the extention is available */
|
2004-02-23 18:42:58 -05:00
|
|
|
static bool WGLQueryExtension(JNIEnv *env, const char *name)
|
2003-09-26 09:59:50 -04:00
|
|
|
{
|
|
|
|
const GLubyte *extensions;
|
|
|
|
|
|
|
|
if (wglGetExtensionsStringARB == NULL)
|
|
|
|
if (wglGetExtensionsStringEXT == NULL)
|
|
|
|
return false;
|
|
|
|
else
|
|
|
|
extensions = (GLubyte*)wglGetExtensionsStringEXT();
|
|
|
|
else
|
|
|
|
extensions = (GLubyte*)wglGetExtensionsStringARB(wglGetCurrentDC());
|
2004-02-23 18:42:58 -05:00
|
|
|
return QueryExtension(env, NULL, extensions, name);
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2004-02-23 18:42:58 -05:00
|
|
|
static void extgl_InitWGLARBBufferRegion(JNIEnv *env)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2003-09-26 09:59:50 -04:00
|
|
|
if (!extgl_Extensions.WGL_ARB_buffer_region)
|
2003-09-21 03:43:02 -04:00
|
|
|
return;
|
|
|
|
wglCreateBufferRegionARB = (wglCreateBufferRegionARBPROC) extgl_GetProcAddress("wglCreateBufferRegionARB");
|
|
|
|
wglDeleteBufferRegionARB = (wglDeleteBufferRegionARBPROC) extgl_GetProcAddress("wglDeleteBufferRegionARB");
|
|
|
|
wglSaveBufferRegionARB = (wglSaveBufferRegionARBPROC) extgl_GetProcAddress("wglSaveBufferRegionARB");
|
|
|
|
wglRestoreBufferRegionARB = (wglRestoreBufferRegionARBPROC) extgl_GetProcAddress("wglRestoreBufferRegionARB");
|
2004-01-20 04:06:00 -05:00
|
|
|
|
2004-03-07 10:18:47 -05:00
|
|
|
EXTGL_SANITY_CHECK(env, WGL_ARB_buffer_region);
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2004-02-23 18:42:58 -05:00
|
|
|
static void extgl_InitWGLARBPbuffer(JNIEnv *env)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2003-09-26 09:59:50 -04:00
|
|
|
if (!extgl_Extensions.WGL_ARB_pbuffer)
|
2003-09-21 03:43:02 -04:00
|
|
|
return;
|
|
|
|
wglCreatePbufferARB = (wglCreatePbufferARBPROC) extgl_GetProcAddress("wglCreatePbufferARB");
|
|
|
|
wglGetPbufferDCARB = (wglGetPbufferDCARBPROC) extgl_GetProcAddress("wglGetPbufferDCARB");
|
|
|
|
wglReleasePbufferDCARB = (wglReleasePbufferDCARBPROC) extgl_GetProcAddress("wglReleasePbufferDCARB");
|
|
|
|
wglDestroyPbufferARB = (wglDestroyPbufferARBPROC) extgl_GetProcAddress("wglDestroyPbufferARB");
|
|
|
|
wglQueryPbufferARB = (wglQueryPbufferARBPROC) extgl_GetProcAddress("wglQueryPbufferARB");
|
2004-03-07 10:18:47 -05:00
|
|
|
EXTGL_SANITY_CHECK(env, WGL_ARB_pbuffer);
|
2004-01-20 04:06:00 -05:00
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2004-02-23 18:42:58 -05:00
|
|
|
static void extgl_InitWGLARBPixelFormat(JNIEnv *env)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2003-09-26 09:59:50 -04:00
|
|
|
if (!extgl_Extensions.WGL_ARB_pixel_format)
|
2003-09-21 03:43:02 -04:00
|
|
|
return;
|
|
|
|
wglGetPixelFormatAttribivARB = (wglGetPixelFormatAttribivARBPROC) extgl_GetProcAddress("wglGetPixelFormatAttribivARB");
|
|
|
|
wglGetPixelFormatAttribfvARB = (wglGetPixelFormatAttribfvARBPROC) extgl_GetProcAddress("wglGetPixelFormatAttribfvARB");
|
|
|
|
wglChoosePixelFormatARB = (wglChoosePixelFormatARBPROC) extgl_GetProcAddress("wglChoosePixelFormatARB");
|
2004-03-07 10:18:47 -05:00
|
|
|
EXTGL_SANITY_CHECK(env, WGL_ARB_pixel_format);
|
2004-01-20 04:06:00 -05:00
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2004-02-23 18:42:58 -05:00
|
|
|
static void extgl_InitWGLARBRenderTexture(JNIEnv *env)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2003-09-26 09:59:50 -04:00
|
|
|
if (!extgl_Extensions.WGL_ARB_render_texture)
|
2003-09-21 03:43:02 -04:00
|
|
|
return;
|
|
|
|
wglBindTexImageARB = (wglBindTexImageARBPROC) extgl_GetProcAddress("wglBindTexImageARB");
|
|
|
|
wglReleaseTexImageARB = (wglReleaseTexImageARBPROC) extgl_GetProcAddress("wglReleaseTexImageARB");
|
|
|
|
wglSetPbufferAttribARB = (wglSetPbufferAttribARBPROC) extgl_GetProcAddress("wglSetPbufferAttribARB");
|
2004-03-07 10:18:47 -05:00
|
|
|
EXTGL_SANITY_CHECK(env, WGL_ARB_render_texture);
|
2004-01-20 04:06:00 -05:00
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2004-02-23 18:42:58 -05:00
|
|
|
static void extgl_InitWGLEXTSwapControl(JNIEnv *env)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2003-09-26 09:59:50 -04:00
|
|
|
if (!extgl_Extensions.WGL_EXT_swap_control)
|
2003-09-21 03:43:02 -04:00
|
|
|
return;
|
|
|
|
wglSwapIntervalEXT = (wglSwapIntervalEXTPROC) extgl_GetProcAddress("wglSwapIntervalEXT");
|
|
|
|
wglGetSwapIntervalEXT = (wglGetSwapIntervalEXTPROC) extgl_GetProcAddress("wglGetSwapIntervalEXT");
|
2004-03-07 10:18:47 -05:00
|
|
|
EXTGL_SANITY_CHECK(env, WGL_EXT_swap_control);
|
2004-01-20 04:06:00 -05:00
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2004-02-23 18:42:58 -05:00
|
|
|
static void extgl_InitWGLARBMakeCurrentRead(JNIEnv *env)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2003-09-26 09:59:50 -04:00
|
|
|
if (!extgl_Extensions.WGL_ARB_make_current_read)
|
2003-09-21 03:43:02 -04:00
|
|
|
return;
|
|
|
|
wglMakeContextCurrentARB = (wglMakeContextCurrentARBPROC) extgl_GetProcAddress("wglMakeContextCurrentARB");
|
|
|
|
wglGetCurrentReadDCARB = (wglGetCurrentReadDCARBPROC) extgl_GetProcAddress("wglGetCurrentReadDCARB");
|
2004-03-07 10:18:47 -05:00
|
|
|
EXTGL_SANITY_CHECK(env, WGL_ARB_make_current_read);
|
2004-01-20 04:06:00 -05:00
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2004-02-23 18:42:58 -05:00
|
|
|
static void extgl_InitSupportedWGLExtensions(JNIEnv *env)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2004-02-23 18:42:58 -05:00
|
|
|
extgl_Extensions.WGL_ARB_buffer_region = WGLQueryExtension(env, "WGL_ARB_buffer_region");
|
|
|
|
extgl_Extensions.WGL_ARB_make_current_read = WGLQueryExtension(env, "WGL_ARB_make_current_read");
|
|
|
|
extgl_Extensions.WGL_ARB_multisample = WGLQueryExtension(env, "WGL_ARB_multisample");
|
|
|
|
extgl_Extensions.WGL_ARB_pbuffer = WGLQueryExtension(env, "WGL_ARB_pbuffer");
|
|
|
|
extgl_Extensions.WGL_ARB_pixel_format = WGLQueryExtension(env, "WGL_ARB_pixel_format");
|
|
|
|
extgl_Extensions.WGL_ARB_render_texture = WGLQueryExtension(env, "WGL_ARB_render_texture");
|
|
|
|
extgl_Extensions.WGL_EXT_swap_control = WGLQueryExtension(env, "WGL_EXT_swap_control");
|
|
|
|
extgl_Extensions.WGL_NV_render_depth_texture = WGLQueryExtension(env, "WGL_NV_render_depth_texture");
|
|
|
|
extgl_Extensions.WGL_NV_render_texture_rectangle = WGLQueryExtension(env, "WGL_NV_render_texture_rectangle");
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2004-02-23 18:42:58 -05:00
|
|
|
void extgl_InitWGL(JNIEnv *env)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2003-09-21 03:43:02 -04:00
|
|
|
wglGetExtensionsStringARB = (wglGetExtensionsStringARBPROC) extgl_GetProcAddress("wglGetExtensionsStringARB");
|
|
|
|
wglGetExtensionsStringEXT = (wglGetExtensionsStringEXTPROC) extgl_GetProcAddress("wglGetExtensionsStringEXT");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.WGL_ARB_extensions_string = wglGetExtensionsStringARB != NULL;
|
|
|
|
extgl_Extensions.WGL_EXT_extensions_string = wglGetExtensionsStringEXT != NULL;
|
|
|
|
extgl_error = false;
|
|
|
|
|
2004-02-23 18:42:58 -05:00
|
|
|
extgl_InitSupportedWGLExtensions(env);
|
2003-09-26 09:59:50 -04:00
|
|
|
|
2004-02-23 18:42:58 -05:00
|
|
|
extgl_InitWGLARBMakeCurrentRead(env);
|
|
|
|
extgl_InitWGLEXTSwapControl(env);
|
|
|
|
extgl_InitWGLARBRenderTexture(env);
|
|
|
|
extgl_InitWGLARBPixelFormat(env);
|
|
|
|
extgl_InitWGLARBPbuffer(env);
|
|
|
|
extgl_InitWGLARBBufferRegion(env);
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* WIN32 */
|
|
|
|
|
|
|
|
/*-----------------------------------------------------*/
|
|
|
|
/* WGL stuff END*/
|
|
|
|
/*-----------------------------------------------------*/
|
|
|
|
|
2002-12-30 17:06:28 -05:00
|
|
|
/*-----------------------------------------------------*/
|
|
|
|
/* AGL stuff BEGIN*/
|
|
|
|
/*-----------------------------------------------------*/
|
2003-09-07 12:11:15 -04:00
|
|
|
#ifdef _AGL
|
2002-12-30 17:06:28 -05:00
|
|
|
|
2004-03-05 17:57:51 -05:00
|
|
|
bool extgl_InitAGL(JNIEnv *env)
|
2003-09-29 05:26:20 -04:00
|
|
|
{
|
|
|
|
aglChoosePixelFormat = (aglChoosePixelFormatPROC)extgl_GetProcAddress("aglChoosePixelFormat");
|
|
|
|
aglDestroyPixelFormat = (aglDestroyPixelFormatPROC)extgl_GetProcAddress("aglDestroyPixelFormat");
|
|
|
|
aglNextPixelFormat = (aglNextPixelFormatPROC)extgl_GetProcAddress("aglNextPixelFormat");
|
|
|
|
aglDescribePixelFormat = (aglDescribePixelFormatPROC)extgl_GetProcAddress("aglDescribePixelFormat");
|
|
|
|
aglDevicesOfPixelFormat = (aglDevicesOfPixelFormatPROC)extgl_GetProcAddress("aglDevicesOfPixelFormat");
|
|
|
|
aglQueryRendererInfo = (aglQueryRendererInfoPROC)extgl_GetProcAddress("aglQueryRendererInfo");
|
|
|
|
aglDestroyRendererInfo = (aglDestroyRendererInfoPROC)extgl_GetProcAddress("aglDestroyRendererInfo");
|
|
|
|
aglNextRendererInfo = (aglNextRendererInfoPROC)extgl_GetProcAddress("aglNextRendererInfo");
|
|
|
|
aglDescribeRenderer = (aglDescribeRendererPROC)extgl_GetProcAddress("aglDescribeRenderer");
|
|
|
|
aglCreateContext = (aglCreateContextPROC)extgl_GetProcAddress("aglCreateContext");
|
|
|
|
aglDestroyContext = (aglDestroyContextPROC)extgl_GetProcAddress("aglDestroyContext");
|
|
|
|
aglCopyContext = (aglCopyContextPROC)extgl_GetProcAddress("aglCopyContext");
|
|
|
|
aglUpdateContext = (aglUpdateContextPROC)extgl_GetProcAddress("aglUpdateContext");
|
|
|
|
aglSetCurrentContext = (aglSetCurrentContextPROC)extgl_GetProcAddress("aglSetCurrentContext");
|
|
|
|
aglGetCurrentContext = (aglGetCurrentContextPROC)extgl_GetProcAddress("aglGetCurrentContext");
|
|
|
|
aglSetDrawable = (aglSetDrawablePROC)extgl_GetProcAddress("aglSetDrawable");
|
|
|
|
aglSetOffScreen = (aglSetOffScreenPROC)extgl_GetProcAddress("aglSetOffScreen");
|
|
|
|
aglSetFullScreen = (aglSetFullScreenPROC)extgl_GetProcAddress("aglSetFullScreen");
|
|
|
|
aglGetDrawable = (aglGetDrawablePROC)extgl_GetProcAddress("aglGetDrawable");
|
|
|
|
aglSetVirtualScreen = (aglSetVirtualScreenPROC)extgl_GetProcAddress("aglSetVirtualScreen");
|
|
|
|
aglGetVirtualScreen = (aglGetVirtualScreenPROC)extgl_GetProcAddress("aglGetVirtualScreen");
|
|
|
|
aglGetVersion = (aglGetVersionPROC)extgl_GetProcAddress("aglGetVersion");
|
|
|
|
aglSwapBuffers = (aglSwapBuffersPROC)extgl_GetProcAddress("aglSwapBuffers");
|
|
|
|
aglEnable = (aglEnablePROC)extgl_GetProcAddress("aglEnable");
|
|
|
|
aglDisable = (aglDisablePROC)extgl_GetProcAddress("aglDisable");
|
|
|
|
aglIsEnabled = (aglIsEnabledPROC)extgl_GetProcAddress("aglIsEnabled");
|
|
|
|
aglSetInteger = (aglSetIntegerPROC)extgl_GetProcAddress("aglSetInteger");
|
|
|
|
aglGetInteger = (aglGetIntegerPROC)extgl_GetProcAddress("aglGetInteger");
|
|
|
|
aglUseFont = (aglUseFontPROC)extgl_GetProcAddress("aglUseFont");
|
|
|
|
aglGetError = (aglGetErrorPROC)extgl_GetProcAddress("aglGetError");
|
|
|
|
aglErrorString = (aglErrorStringPROC)extgl_GetProcAddress("aglErrorString");
|
|
|
|
aglResetLibrary = (aglResetLibraryPROC)extgl_GetProcAddress("aglResetLibrary");
|
|
|
|
aglSurfaceTexture = (aglSurfaceTexturePROC)extgl_GetProcAddress("aglSurfaceTexture");
|
|
|
|
return !extgl_error;
|
2002-12-30 17:06:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
/*-----------------------------------------------------*/
|
|
|
|
/* AGL stuff END*/
|
|
|
|
/*-----------------------------------------------------*/
|
|
|
|
|
2002-12-30 02:07:40 -05:00
|
|
|
#ifdef _X11
|
2002-12-23 06:31:32 -05:00
|
|
|
/** returns true if the extention is available */
|
2004-02-25 13:09:10 -05:00
|
|
|
static bool GLXQueryExtension(JNIEnv* env, Display *disp, int screen, const char *name)
|
2002-12-23 06:31:32 -05:00
|
|
|
{
|
2003-09-21 03:43:02 -04:00
|
|
|
const GLubyte *exts = (const GLubyte *)glXQueryExtensionsString(disp, screen);
|
2004-02-25 13:09:10 -05:00
|
|
|
return QueryExtension(env, NULL, exts, name);
|
2002-12-23 06:31:32 -05:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-12-11 02:16:31 -05:00
|
|
|
/** returns true if the extention is available */
|
2003-09-26 09:59:50 -04:00
|
|
|
static bool GLQueryExtension(JNIEnv *env, jobject ext_set, const char *name)
|
2002-12-11 02:16:31 -05:00
|
|
|
{
|
2003-09-26 09:59:50 -04:00
|
|
|
return QueryExtension(env, ext_set, glGetString(GL_EXTENSIONS), name);
|
2002-12-11 02:16:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-12-30 02:07:40 -05:00
|
|
|
#ifdef _X11
|
2004-02-25 13:09:10 -05:00
|
|
|
static void extgl_InitGLX13(JNIEnv *env)
|
2002-12-11 02:16:31 -05:00
|
|
|
{
|
2003-09-26 09:59:50 -04:00
|
|
|
if (extgl_Extensions.GLX13 != 1)
|
2003-09-22 04:31:51 -04:00
|
|
|
return;
|
2002-12-11 02:16:31 -05:00
|
|
|
glXGetFBConfigs = (glXGetFBConfigsPROC) extgl_GetProcAddress("glXGetFBConfigs");
|
|
|
|
glXChooseFBConfig = (glXChooseFBConfigPROC) extgl_GetProcAddress("glXChooseFBConfig");
|
|
|
|
glXGetFBConfigAttrib = (glXGetFBConfigAttribPROC) extgl_GetProcAddress("glXGetFBConfigAttrib");
|
|
|
|
glXGetVisualFromFBConfig = (glXGetVisualFromFBConfigPROC) extgl_GetProcAddress("glXGetVisualFromFBConfig");
|
|
|
|
glXCreateWindow = (glXCreateWindowPROC) extgl_GetProcAddress("glXCreateWindow");
|
|
|
|
glXDestroyWindow = (glXDestroyWindowPROC) extgl_GetProcAddress("glXDestroyWindow");
|
|
|
|
glXCreatePixmap = (glXCreatePixmapPROC) extgl_GetProcAddress("glXCreatePixmap");
|
|
|
|
glXDestroyPixmap = (glXDestroyPixmapPROC) extgl_GetProcAddress("glXDestroyPixmap");
|
|
|
|
glXCreatePbuffer = (glXCreatePbufferPROC) extgl_GetProcAddress("glXCreatePbuffer");
|
|
|
|
glXDestroyPbuffer = (glXDestroyPbufferPROC) extgl_GetProcAddress("glXDestroyPbuffer");
|
|
|
|
glXQueryDrawable = (glXQueryDrawablePROC) extgl_GetProcAddress("glXQueryDrawable");
|
|
|
|
glXCreateNewContext = (glXCreateNewContextPROC) extgl_GetProcAddress("glXCreateNewContext");
|
|
|
|
glXMakeContextCurrent = (glXMakeContextCurrentPROC) extgl_GetProcAddress("glXMakeContextCurrent");
|
|
|
|
glXGetCurrentReadDrawable = (glXGetCurrentReadDrawablePROC) extgl_GetProcAddress("glXGetCurrentReadDrawable");
|
|
|
|
glXGetCurrentDisplay = (glXGetCurrentDisplayPROC) extgl_GetProcAddress("glXGetCurrentDisplay");
|
|
|
|
glXQueryContext = (glXQueryContextPROC) extgl_GetProcAddress("glXQueryContext");
|
|
|
|
glXSelectEvent = (glXSelectEventPROC) extgl_GetProcAddress("glXSelectEvent");
|
|
|
|
glXGetSelectedEvent = (glXGetSelectedEventPROC) extgl_GetProcAddress("glXGetSelectedEvent");
|
2004-03-07 10:18:47 -05:00
|
|
|
EXTGL_SANITY_CHECK(env, GLX13);
|
2002-12-11 02:16:31 -05:00
|
|
|
}
|
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
static bool extgl_InitGLX12(void)
|
2002-12-11 02:16:31 -05:00
|
|
|
{
|
|
|
|
glXChooseVisual = (glXChooseVisualPROC) extgl_GetProcAddress("glXChooseVisual");
|
|
|
|
glXCopyContext = (glXCopyContextPROC) extgl_GetProcAddress("glXCopyContext");
|
|
|
|
glXCreateContext = (glXCreateContextPROC) extgl_GetProcAddress("glXCreateContext");
|
|
|
|
glXCreateGLXPixmap = (glXCreateGLXPixmapPROC) extgl_GetProcAddress("glXCreateGLXPixmap");
|
|
|
|
glXDestroyContext = (glXDestroyContextPROC) extgl_GetProcAddress("glXDestroyContext");
|
|
|
|
glXDestroyGLXPixmap = (glXDestroyGLXPixmapPROC) extgl_GetProcAddress("glXDestroyGLXPixmap");
|
|
|
|
glXGetConfig = (glXGetConfigPROC) extgl_GetProcAddress("glXGetConfig");
|
|
|
|
glXGetCurrentContext = (glXGetCurrentContextPROC) extgl_GetProcAddress("glXGetCurrentContext");
|
|
|
|
glXGetCurrentDrawable = (glXGetCurrentDrawablePROC) extgl_GetProcAddress("glXGetCurrentDrawable");
|
|
|
|
glXIsDirect = (glXIsDirectPROC) extgl_GetProcAddress("glXIsDirect");
|
|
|
|
glXMakeCurrent = (glXMakeCurrentPROC) extgl_GetProcAddress("glXMakeCurrent");
|
|
|
|
glXQueryExtension = (glXQueryExtensionPROC) extgl_GetProcAddress("glXQueryExtension");
|
|
|
|
glXQueryVersion = (glXQueryVersionPROC) extgl_GetProcAddress("glXQueryVersion");
|
|
|
|
glXSwapBuffers = (glXSwapBuffersPROC) extgl_GetProcAddress("glXSwapBuffers");
|
|
|
|
glXUseXFont = (glXUseXFontPROC) extgl_GetProcAddress("glXUseXFont");
|
|
|
|
glXWaitGL = (glXWaitGLPROC) extgl_GetProcAddress("glXWaitGL");
|
|
|
|
glXWaitX = (glXWaitXPROC) extgl_GetProcAddress("glXWaitX");
|
|
|
|
glXGetClientString = (glXGetClientStringPROC) extgl_GetProcAddress("glXGetClientString");
|
|
|
|
glXQueryServerString = (glXQueryServerStringPROC) extgl_GetProcAddress("glXQueryServerString");
|
|
|
|
glXQueryExtensionsString = (glXQueryExtensionsStringPROC) extgl_GetProcAddress("glXQueryExtensionsString");
|
2003-09-26 09:59:50 -04:00
|
|
|
return !extgl_error;
|
2002-12-11 02:16:31 -05:00
|
|
|
}
|
|
|
|
|
2004-02-25 13:09:10 -05:00
|
|
|
static void extgl_InitGLXSupportedExtensions(JNIEnv *env, Display *disp, int screen)
|
2002-12-11 02:16:31 -05:00
|
|
|
{
|
2004-02-25 13:09:10 -05:00
|
|
|
extgl_Extensions.GLX_EXT_visual_info = GLXQueryExtension(env, disp, screen, "GLX_EXT_visual_info");
|
|
|
|
extgl_Extensions.GLX_EXT_visual_rating = GLXQueryExtension(env, disp, screen, "GLX_EXT_visual_rating");
|
|
|
|
extgl_Extensions.GLX_SGI_swap_control = GLXQueryExtension(env, disp, screen, "GLX_SGI_swap_control");
|
|
|
|
extgl_Extensions.GLX_ARB_multisample = GLXQueryExtension(env, disp, screen, "GLX_ARB_multisample");
|
2004-01-03 03:09:17 -05:00
|
|
|
}
|
|
|
|
|
2004-02-25 13:09:10 -05:00
|
|
|
static void extgl_InitGLXSGISwapControl(JNIEnv *env)
|
2004-01-03 03:09:17 -05:00
|
|
|
{
|
|
|
|
if (extgl_Extensions.GLX_SGI_swap_control != 1)
|
|
|
|
return;
|
|
|
|
glXSwapIntervalSGI = (glXSwapIntervalSGIPROC)extgl_GetProcAddress("glXSwapIntervalSGI");
|
2004-03-07 10:18:47 -05:00
|
|
|
EXTGL_SANITY_CHECK(env, GLX_SGI_swap_control);
|
2002-12-23 06:31:32 -05:00
|
|
|
}
|
2002-12-11 02:16:31 -05:00
|
|
|
|
2004-02-25 13:09:10 -05:00
|
|
|
bool extgl_InitGLX(JNIEnv *env, Display *disp, int screen)
|
2002-12-23 06:31:32 -05:00
|
|
|
{
|
2003-09-21 03:43:02 -04:00
|
|
|
int major, minor;
|
|
|
|
/* Assume glx ver >= 1.2 */
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GLX12 = true;
|
|
|
|
if (!extgl_InitGLX12())
|
|
|
|
return false;
|
2004-02-25 13:09:10 -05:00
|
|
|
extgl_InitGLXSupportedExtensions(env, disp, screen);
|
2003-09-21 03:43:02 -04:00
|
|
|
if (glXQueryVersion(disp, &major, &minor) != True)
|
2003-09-26 09:59:50 -04:00
|
|
|
return false;
|
2003-09-21 03:43:02 -04:00
|
|
|
if (major > 1 || (major == 1 && minor >= 3))
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GLX13 = true;
|
2004-02-25 13:09:10 -05:00
|
|
|
extgl_InitGLX13(env);
|
|
|
|
extgl_InitGLXSGISwapControl(env);
|
2003-09-26 09:59:50 -04:00
|
|
|
return true;
|
2002-12-11 02:16:31 -05:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-12-23 06:31:32 -05:00
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
static void extgl_InitSupportedExtensions(JNIEnv *env, jobject ext_set)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2003-09-21 03:43:02 -04:00
|
|
|
char *s = (char*) glGetString(GL_VERSION);
|
|
|
|
if (!s)
|
|
|
|
return;
|
|
|
|
s = strstr(s, "1.");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.OpenGL12 = false;
|
|
|
|
extgl_Extensions.OpenGL13 = false;
|
|
|
|
extgl_Extensions.OpenGL14 = false;
|
2004-02-15 10:21:24 -05:00
|
|
|
extgl_Extensions.OpenGL15 = false;
|
2003-09-26 09:59:50 -04:00
|
|
|
if (s != NULL)
|
|
|
|
{
|
|
|
|
// Fall trhough
|
|
|
|
switch (s[2]) {
|
2004-02-15 10:21:24 -05:00
|
|
|
case '5':
|
|
|
|
extgl_Extensions.OpenGL15 = true;
|
|
|
|
insertExtension(env, ext_set, "OpenGL15");
|
2003-09-26 09:59:50 -04:00
|
|
|
case '4':
|
|
|
|
extgl_Extensions.OpenGL14 = true;
|
|
|
|
insertExtension(env, ext_set, "OpenGL14");
|
|
|
|
case '3':
|
|
|
|
extgl_Extensions.OpenGL13 = true;
|
|
|
|
insertExtension(env, ext_set, "OpenGL13");
|
|
|
|
case '2':
|
|
|
|
extgl_Extensions.OpenGL12 = true;
|
|
|
|
insertExtension(env, ext_set, "OpenGL12");
|
|
|
|
break;
|
2003-09-21 03:43:02 -04:00
|
|
|
}
|
|
|
|
}
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_ARB_depth_texture = GLQueryExtension(env, ext_set, "GL_ARB_depth_texture");
|
|
|
|
extgl_Extensions.GL_ARB_fragment_program = GLQueryExtension(env, ext_set, "GL_ARB_fragment_program");
|
|
|
|
extgl_Extensions.GL_ARB_imaging = GLQueryExtension(env, ext_set, "GL_ARB_imaging");
|
|
|
|
extgl_Extensions.GL_ARB_matrix_palette = GLQueryExtension(env, ext_set, "GL_ARB_matrix_palette");
|
|
|
|
extgl_Extensions.GL_ARB_multisample = GLQueryExtension(env, ext_set, "GL_ARB_multisample");
|
|
|
|
extgl_Extensions.GL_ARB_multitexture = GLQueryExtension(env, ext_set, "GL_ARB_multitexture");
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_Extensions.GL_ARB_occlusion_query = GLQueryExtension(env, ext_set, "GL_ARB_occlusion_query");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_ARB_point_parameters = GLQueryExtension(env, ext_set, "GL_ARB_point_parameters");
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_Extensions.GL_ARB_shader_objects = GLQueryExtension(env, ext_set, "GL_ARB_shader_objects");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_ARB_shadow = GLQueryExtension(env, ext_set, "GL_ARB_shadow");
|
|
|
|
extgl_Extensions.GL_ARB_shadow_ambient = GLQueryExtension(env, ext_set, "GL_ARB_shadow_ambient");
|
|
|
|
extgl_Extensions.GL_ARB_texture_border_clamp = GLQueryExtension(env, ext_set, "GL_ARB_texture_border_clamp");
|
|
|
|
extgl_Extensions.GL_ARB_texture_compression = GLQueryExtension(env, ext_set, "GL_ARB_texture_compression");
|
|
|
|
extgl_Extensions.GL_ARB_texture_cube_map = GLQueryExtension(env, ext_set, "GL_ARB_texture_cube_map");
|
|
|
|
extgl_Extensions.GL_ARB_texture_env_add = GLQueryExtension(env, ext_set, "GL_ARB_texture_env_add");
|
|
|
|
extgl_Extensions.GL_ARB_texture_env_combine = GLQueryExtension(env, ext_set, "GL_ARB_texture_env_combine");
|
|
|
|
extgl_Extensions.GL_ARB_texture_env_crossbar = GLQueryExtension(env, ext_set, "GL_ARB_texture_env_crossbar");
|
|
|
|
extgl_Extensions.GL_ARB_texture_env_dot3 = GLQueryExtension(env, ext_set, "GL_ARB_texture_env_dot3");
|
|
|
|
extgl_Extensions.GL_ARB_texture_mirrored_repeat = GLQueryExtension(env, ext_set, "GL_ARB_texture_mirrored_repeat");
|
|
|
|
extgl_Extensions.GL_ARB_transpose_matrix = GLQueryExtension(env, ext_set, "GL_ARB_transpose_matrix");
|
|
|
|
extgl_Extensions.GL_ARB_vertex_blend = GLQueryExtension(env, ext_set, "GL_ARB_vertex_blend");
|
|
|
|
extgl_Extensions.GL_ARB_vertex_buffer_object = GLQueryExtension(env, ext_set, "GL_ARB_vertex_buffer_object");
|
|
|
|
extgl_Extensions.GL_ARB_vertex_program = GLQueryExtension(env, ext_set, "GL_ARB_vertex_program");
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_Extensions.GL_ARB_vertex_shader = GLQueryExtension(env, ext_set, "GL_ARB_vertex_shaders");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_ARB_window_pos = GLQueryExtension(env, ext_set, "GL_ARB_window_pos");
|
2004-01-30 15:34:09 -05:00
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_EXT_abgr = GLQueryExtension(env, ext_set, "GL_EXT_abgr");
|
|
|
|
extgl_Extensions.GL_EXT_bgra = GLQueryExtension(env, ext_set, "GL_EXT_bgra");
|
|
|
|
extgl_Extensions.GL_EXT_blend_func_separate = GLQueryExtension(env, ext_set, "GL_EXT_blend_function_separate");
|
|
|
|
extgl_Extensions.GL_EXT_compiled_vertex_array = GLQueryExtension(env, ext_set, "GL_EXT_compiled_vertex_array");
|
|
|
|
extgl_Extensions.GL_EXT_cull_vertex = GLQueryExtension(env, ext_set, "GL_EXT_cull_vertex");
|
|
|
|
extgl_Extensions.GL_EXT_draw_range_elements = GLQueryExtension(env, ext_set, "GL_EXT_draw_range_elements");
|
|
|
|
extgl_Extensions.GL_EXT_fog_coord = GLQueryExtension(env, ext_set, "GL_EXT_fog_coord");
|
|
|
|
extgl_Extensions.GL_EXT_multi_draw_arrays = GLQueryExtension(env, ext_set, "GL_EXT_multi_draw_arrays");
|
|
|
|
extgl_Extensions.GL_EXT_point_parameters = GLQueryExtension(env, ext_set, "GL_EXT_point_parameters");
|
|
|
|
extgl_Extensions.GL_EXT_secondary_color = GLQueryExtension(env, ext_set, "GL_EXT_secondary_color");
|
|
|
|
extgl_Extensions.GL_EXT_separate_specular_color = GLQueryExtension(env, ext_set, "GL_EXT_separate_specular_color");
|
|
|
|
extgl_Extensions.GL_EXT_shadow_funcs = GLQueryExtension(env, ext_set, "GL_EXT_shadow_funcs");
|
|
|
|
extgl_Extensions.GL_EXT_stencil_two_side = GLQueryExtension(env, ext_set, "GL_EXT_stencil_two_side");
|
|
|
|
extgl_Extensions.GL_EXT_stencil_wrap = GLQueryExtension(env, ext_set, "GL_EXT_stencil_wrap");
|
|
|
|
extgl_Extensions.GL_EXT_texture_compression_s3tc = GLQueryExtension(env, ext_set, "GL_EXT_texture_compression_s3tc");
|
|
|
|
extgl_Extensions.GL_EXT_texture_env_combine = GLQueryExtension(env, ext_set, "GL_EXT_texture_env_combine");
|
|
|
|
extgl_Extensions.GL_EXT_texture_filter_anisotropic = GLQueryExtension(env, ext_set, "GL_EXT_texture_filter_anisotropic");
|
|
|
|
extgl_Extensions.GL_EXT_texture_lod_bias = GLQueryExtension(env, ext_set, "GL_EXT_texture_lod_bias");
|
|
|
|
extgl_Extensions.GL_EXT_vertex_shader = GLQueryExtension(env, ext_set, "GL_EXT_vertex_shader");
|
|
|
|
extgl_Extensions.GL_EXT_vertex_weighting = GLQueryExtension(env, ext_set, "GL_EXT_vertex_weighting");
|
2004-01-30 15:34:09 -05:00
|
|
|
|
|
|
|
extgl_Extensions.GL_ATI_draw_buffers = GLQueryExtension(env, ext_set, "GL_ATI_draw_buffers");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_ATI_element_array = GLQueryExtension(env, ext_set, "GL_ATI_element_array");
|
|
|
|
extgl_Extensions.GL_ATI_envmap_bumpmap = GLQueryExtension(env, ext_set, "GL_ATI_envmap_bumpmap");
|
|
|
|
extgl_Extensions.GL_ATI_fragment_shader = GLQueryExtension(env, ext_set, "GL_ATI_fragment_shader");
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_Extensions.GL_ATI_map_object_buffer = GLQueryExtension(env, ext_set, "GL_ATI_map_object_buffer");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_ATI_pn_triangles = GLQueryExtension(env, ext_set, "GL_ATI_pn_triangles");
|
|
|
|
extgl_Extensions.GL_ATI_point_cull_mode = GLQueryExtension(env, ext_set, "GL_ATI_point_cull_mode");
|
|
|
|
extgl_Extensions.GL_ATI_separate_stencil = GLQueryExtension(env, ext_set, "GL_ATI_separate_stencil");
|
|
|
|
extgl_Extensions.GL_ATI_text_fragment_shader = GLQueryExtension(env, ext_set, "GL_ATI_text_fragment_shader");
|
|
|
|
extgl_Extensions.GL_ATI_texture_mirror_once = GLQueryExtension(env, ext_set, "GL_ATI_texture_mirror_once");
|
|
|
|
extgl_Extensions.GL_ATI_vertex_array_object = GLQueryExtension(env, ext_set, "GL_ATI_vertex_array_object");
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_Extensions.GL_ATI_vertex_attrib_array_object = GLQueryExtension(env, ext_set, "GL_ATI_vertex_attrib_array_object");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_ATI_vertex_streams = GLQueryExtension(env, ext_set, "GL_ATI_vertex_streams");
|
2004-01-30 15:34:09 -05:00
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_ATIX_point_sprites = GLQueryExtension(env, ext_set, "GL_ATIX_point_sprites");
|
|
|
|
extgl_Extensions.GL_ATIX_texture_env_route = GLQueryExtension(env, ext_set, "GL_ATIX_texture_env_route");
|
2004-01-30 15:34:09 -05:00
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_HP_occlusion_test = GLQueryExtension(env, ext_set, "GL_HP_occlusion_test");
|
2004-01-30 15:34:09 -05:00
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_NV_blend_square = GLQueryExtension(env, ext_set, "GL_NV_blend_square");
|
|
|
|
extgl_Extensions.GL_NV_copy_depth_to_color = GLQueryExtension(env, ext_set, "GL_NV_copy_depth_to_color");
|
|
|
|
extgl_Extensions.GL_NV_depth_clamp = GLQueryExtension(env, ext_set, "GL_NV_depth_clamp");
|
|
|
|
extgl_Extensions.GL_NV_element_array = GLQueryExtension(env, ext_set, "GL_NV_element_array");
|
|
|
|
extgl_Extensions.GL_NV_evaluators = GLQueryExtension(env, ext_set, "GL_NV_evaluators");
|
|
|
|
extgl_Extensions.GL_NV_fence = GLQueryExtension(env, ext_set, "GL_NV_fence");
|
|
|
|
extgl_Extensions.GL_NV_float_buffer = GLQueryExtension(env, ext_set, "GL_NV_float_buffer");
|
|
|
|
extgl_Extensions.GL_NV_fog_distance = GLQueryExtension(env, ext_set, "GL_NV_fog_distance");
|
|
|
|
extgl_Extensions.GL_NV_fragment_program = GLQueryExtension(env, ext_set, "GL_NV_fragment_program");
|
2004-01-30 17:13:56 -05:00
|
|
|
extgl_Extensions.GL_NV_half_float = GLQueryExtension(env, ext_set, "GL_NV_half_float");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_NV_light_max_exponent = GLQueryExtension(env, ext_set, "GL_NV_light_max_exponent");
|
|
|
|
extgl_Extensions.GL_NV_occlusion_query = GLQueryExtension(env, ext_set, "GL_NV_occlusion_query");
|
|
|
|
extgl_Extensions.GL_NV_packed_depth_stencil = GLQueryExtension(env, ext_set, "GL_NV_packed_depth_stencil");
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_Extensions.GL_NV_pixel_data_range = GLQueryExtension(env, ext_set, "GL_NV_pixel_data_range");
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_NV_point_sprite = GLQueryExtension(env, ext_set, "GL_NV_point_sprite");
|
|
|
|
extgl_Extensions.GL_NV_primitive_restart = GLQueryExtension(env, ext_set, "GL_NV_primitive_restart");
|
|
|
|
extgl_Extensions.GL_NV_register_combiners = GLQueryExtension(env, ext_set, "GL_NV_register_combiners");
|
|
|
|
extgl_Extensions.GL_NV_register_combiners2 = GLQueryExtension(env, ext_set, "GL_NV_register_combiners2");
|
|
|
|
extgl_Extensions.GL_NV_texgen_reflection = GLQueryExtension(env, ext_set, "GL_NV_texgen_reflection");
|
|
|
|
extgl_Extensions.GL_NV_texture_env_combine4 = GLQueryExtension(env, ext_set, "GL_NV_texture_env_combine4");
|
|
|
|
extgl_Extensions.GL_NV_texture_rectangle = GLQueryExtension(env, ext_set, "GL_NV_texture_rectangle");
|
|
|
|
extgl_Extensions.GL_NV_texture_shader = GLQueryExtension(env, ext_set, "GL_NV_texture_shader");
|
|
|
|
extgl_Extensions.GL_NV_texture_shader2 = GLQueryExtension(env, ext_set, "GL_NV_texture_shader2");
|
|
|
|
extgl_Extensions.GL_NV_texture_shader3 = GLQueryExtension(env, ext_set, "GL_NV_texture_shader3");
|
|
|
|
extgl_Extensions.GL_NV_vertex_array_range = GLQueryExtension(env, ext_set, "GL_NV_vertex_array_range");
|
|
|
|
extgl_Extensions.GL_NV_vertex_array_range2 = GLQueryExtension(env, ext_set, "GL_NV_vertex_array_range2");
|
|
|
|
extgl_Extensions.GL_NV_vertex_program = GLQueryExtension(env, ext_set, "GL_NV_vertex_program");
|
|
|
|
extgl_Extensions.GL_NV_vertex_program1_1 = GLQueryExtension(env, ext_set, "GL_NV_vertex_program1_1");
|
|
|
|
extgl_Extensions.GL_NV_vertex_program2 = GLQueryExtension(env, ext_set, "GL_NV_vertex_program2");
|
2004-01-30 15:34:09 -05:00
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_Extensions.GL_SGIS_generate_mipmap = GLQueryExtension(env, ext_set, "GL_SGIS_generate_mipmap");
|
|
|
|
extgl_Extensions.GL_SGIX_depth_texture = GLQueryExtension(env, ext_set, "GL_SGIX_depth_texture");
|
|
|
|
extgl_Extensions.GL_SGIX_shadow = GLQueryExtension(env, ext_set, "GL_SGIX_shadow");
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2004-03-07 10:18:47 -05:00
|
|
|
extern void extgl_InitOpenGL1_1(JNIEnv *env);
|
2004-01-30 15:34:09 -05:00
|
|
|
//extern void extgl_InitARBFragmentProgram(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitARBImaging(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitARBMatrixPalette(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitARBMultisample(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitARBMultitexture(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitARBOcclusionQuery(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitARBPointParameters(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitARBProgram(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitARBShaderObjects(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitARBTextureCompression(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitARBTransposeMatrix(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitARBVertexBlend(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitARBVertexBufferObject(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitARBVertexProgram(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitARBVertexShader(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitARBWindowPos(JNIEnv *env, jobject ext_set);
|
|
|
|
|
|
|
|
extern void extgl_InitEXTBlendFuncSeparate(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitEXTCompiledVertexArray(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitEXTDrawRangeElements(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitEXTFogCoord(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitEXTMultiDrawArrays(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitEXTPointParameters(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitEXTSecondaryColor(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitEXTStencilTwoSide(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitEXTVertexShader(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitEXTVertexWeighting(JNIEnv *env, jobject ext_set);
|
|
|
|
|
|
|
|
extern void extgl_InitNVEvaluators(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitNVFragmentProgram(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitNVFence(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitNVHalfFloat(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitNVOcclusionQuery(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitNVPixelDataRange(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitNVPointSprite(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitNVPrimitiveRestart(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitNVProgram(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitNVRegisterCombiners(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitNVRegisterCombiners2(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitNVVertexArrayRange(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitNVVertexProgram(JNIEnv *env, jobject ext_set);
|
|
|
|
|
|
|
|
extern void extgl_InitATIDrawBuffers(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitATIElementArray(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitATIEnvmapBumpmap(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitATIFragmentShader(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitATIMapObjectBuffer(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitATIPNTriangles(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitATISeparateStencil(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitATIVertexArrayObject(JNIEnv *env, jobject ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extern void extgl_InitATIVertexAttribArrayObject(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitATIVertexStreams(JNIEnv *env, jobject ext_set);
|
|
|
|
|
2004-01-29 17:08:59 -05:00
|
|
|
extern void extgl_InitOpenGL1_2(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitOpenGL1_3(JNIEnv *env, jobject ext_set);
|
|
|
|
extern void extgl_InitOpenGL1_4(JNIEnv *env, jobject ext_set);
|
2004-02-15 10:21:24 -05:00
|
|
|
extern void extgl_InitOpenGL1_5(JNIEnv *env, jobject ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
/* extgl_Init the extensions and load all the functions */
|
2003-09-26 09:59:50 -04:00
|
|
|
bool extgl_Initialize(JNIEnv *env, jobject ext_set)
|
2002-11-18 15:02:17 -05:00
|
|
|
{
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_error = false;
|
2004-03-07 10:18:47 -05:00
|
|
|
extgl_InitOpenGL1_1(env);
|
2003-09-26 09:59:50 -04:00
|
|
|
if (extgl_error)
|
|
|
|
return false;
|
2003-09-22 04:31:51 -04:00
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_InitSupportedExtensions(env, ext_set);
|
2004-02-15 10:21:24 -05:00
|
|
|
|
2004-01-29 17:08:59 -05:00
|
|
|
//extgl_InitEXTNurbsTesselator(env, ext_set);
|
2003-09-21 03:43:02 -04:00
|
|
|
|
|
|
|
/* first load the extensions */
|
2004-01-30 15:34:09 -05:00
|
|
|
// extgl_InitARBFragmentProgram(env, ext_set);
|
|
|
|
extgl_InitARBImaging(env, ext_set);
|
|
|
|
extgl_InitARBMatrixPalette(env, ext_set);
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_InitARBMultisample(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitARBMultitexture(env, ext_set);
|
|
|
|
extgl_InitARBOcclusionQuery(env, ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extgl_InitARBPointParameters(env, ext_set);
|
|
|
|
extgl_InitARBProgram(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitARBShaderObjects(env, ext_set);
|
|
|
|
extgl_InitARBTextureCompression(env, ext_set);
|
|
|
|
extgl_InitARBTransposeMatrix(env, ext_set);
|
|
|
|
extgl_InitARBVertexBlend(env, ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extgl_InitARBVertexBufferObject(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitARBVertexProgram(env, ext_set);
|
|
|
|
extgl_InitARBVertexShader(env, ext_set);
|
|
|
|
extgl_InitARBWindowPos(env, ext_set);
|
2004-02-15 10:21:24 -05:00
|
|
|
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitEXTBlendFuncSeparate(env, ext_set);
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_InitEXTCompiledVertexArray(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
//extgl_InitEXTCullVertex(env, ext_set);
|
|
|
|
extgl_InitEXTDrawRangeElements(env, ext_set);
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_InitEXTFogCoord(env, ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extgl_InitEXTMultiDrawArrays(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitEXTPointParameters(env, ext_set);
|
|
|
|
extgl_InitEXTSecondaryColor(env, ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extgl_InitEXTStencilTwoSide(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitEXTVertexShader(env, ext_set);
|
|
|
|
extgl_InitEXTVertexWeighting(env, ext_set);
|
|
|
|
|
|
|
|
//extgl_InitNVElementArray(env, ext_set);
|
|
|
|
extgl_InitNVEvaluators(env, ext_set);
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_InitNVFence(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitNVFragmentProgram(env, ext_set);
|
|
|
|
extgl_InitNVHalfFloat(env, ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extgl_InitNVOcclusionQuery(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitNVPixelDataRange(env, ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extgl_InitNVPointSprite(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitNVPrimitiveRestart(env, ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extgl_InitNVProgram(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitNVRegisterCombiners(env, ext_set);
|
|
|
|
extgl_InitNVRegisterCombiners2(env, ext_set);
|
|
|
|
extgl_InitNVVertexArrayRange(env, ext_set);
|
2004-01-29 17:08:59 -05:00
|
|
|
extgl_InitNVVertexProgram(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitATIDrawBuffers(env, ext_set);
|
|
|
|
extgl_InitATIElementArray(env, ext_set);
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_InitATIEnvmapBumpmap(env, ext_set);
|
|
|
|
extgl_InitATIFragmentShader(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitATIMapObjectBuffer(env, ext_set);
|
|
|
|
extgl_InitATIPNTriangles(env, ext_set);
|
|
|
|
extgl_InitATISeparateStencil(env, ext_set);
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_InitATIVertexArrayObject(env, ext_set);
|
2004-01-30 15:34:09 -05:00
|
|
|
extgl_InitATIVertexAttribArrayObject(env, ext_set);
|
|
|
|
extgl_InitATIVertexStreams(env, ext_set);
|
2004-02-15 10:21:24 -05:00
|
|
|
|
2002-11-18 15:02:17 -05:00
|
|
|
/* now load core opengl */
|
2003-09-26 09:59:50 -04:00
|
|
|
extgl_InitOpenGL1_2(env, ext_set);
|
|
|
|
extgl_InitOpenGL1_3(env, ext_set);
|
|
|
|
extgl_InitOpenGL1_4(env, ext_set);
|
2004-02-15 10:21:24 -05:00
|
|
|
extgl_InitOpenGL1_5(env, ext_set);
|
|
|
|
|
2003-09-26 09:59:50 -04:00
|
|
|
return true;
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
2003-09-29 07:58:35 -04:00
|
|
|
#ifdef _AGL
|
|
|
|
bool extgl_Open(void) {
|
2004-02-28 11:59:30 -05:00
|
|
|
if (opengl_bundle_ref != NULL)
|
|
|
|
return true;
|
2003-09-29 07:58:35 -04:00
|
|
|
opengl_bundle_ref = loadBundle("\pOpenGL.framework");
|
|
|
|
if (opengl_bundle_ref == NULL)
|
|
|
|
return false;
|
|
|
|
agl_bundle_ref = loadBundle("\pAGL.framework");
|
|
|
|
if (agl_bundle_ref == NULL) {
|
|
|
|
aglUnloadFramework(opengl_bundle_ref);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-12-30 02:07:40 -05:00
|
|
|
#ifdef _X11
|
2003-09-26 09:59:50 -04:00
|
|
|
bool extgl_Open()
|
2002-12-23 06:31:32 -05:00
|
|
|
{
|
2004-02-28 11:59:30 -05:00
|
|
|
if (lib_gl_handle != NULL)
|
|
|
|
return true;
|
2003-09-21 03:43:02 -04:00
|
|
|
lib_gl_handle = dlopen("libGL.so.1", RTLD_LAZY | RTLD_GLOBAL);
|
|
|
|
if (lib_gl_handle == NULL) {
|
2003-12-20 17:03:25 -05:00
|
|
|
printfDebug("Error loading libGL.so.1: %s\n", dlerror());
|
2003-09-26 09:59:50 -04:00
|
|
|
return false;
|
2003-09-21 03:43:02 -04:00
|
|
|
}
|
2004-02-29 03:24:56 -05:00
|
|
|
glXGetProcAddressARB = (glXGetProcAddressARBPROC) dlsym(lib_gl_handle, "glXGetProcAddressARB");
|
|
|
|
if (glXGetProcAddressARB == NULL) {
|
|
|
|
extgl_Close();
|
|
|
|
return false;
|
|
|
|
}
|
2003-09-26 09:59:50 -04:00
|
|
|
return true;
|
2002-12-23 06:31:32 -05:00
|
|
|
}
|
2003-03-30 14:26:39 -05:00
|
|
|
|
2002-12-30 17:06:28 -05:00
|
|
|
#endif /* X11 */
|
2002-12-30 02:07:40 -05:00
|
|
|
|
|
|
|
#ifdef _WIN32
|
2003-09-26 09:59:50 -04:00
|
|
|
bool extgl_Open(void)
|
2002-12-23 06:31:32 -05:00
|
|
|
{
|
2004-02-28 11:59:30 -05:00
|
|
|
if (lib_gl_handle != NULL)
|
|
|
|
return true;
|
2003-09-21 03:43:02 -04:00
|
|
|
// load the dynamic libraries for OpenGL
|
|
|
|
lib_gl_handle = LoadLibrary("opengl32.dll");
|
2002-12-11 02:16:31 -05:00
|
|
|
if (lib_gl_handle == NULL)
|
2003-09-26 09:59:50 -04:00
|
|
|
return false;
|
|
|
|
return true;
|
2002-12-30 17:06:28 -05:00
|
|
|
}
|
2003-09-29 07:58:35 -04:00
|
|
|
#endif /* WIN32 */
|
2002-12-11 02:16:31 -05:00
|
|
|
|
|
|
|
void extgl_Close(void)
|
|
|
|
{
|
2002-12-30 02:07:40 -05:00
|
|
|
#ifdef _X11
|
2002-12-11 02:16:31 -05:00
|
|
|
dlclose(lib_gl_handle);
|
2004-02-28 11:59:30 -05:00
|
|
|
lib_gl_handle = NULL;
|
2002-12-30 02:07:40 -05:00
|
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
2002-12-11 02:16:31 -05:00
|
|
|
FreeLibrary(lib_gl_handle);
|
2004-02-28 11:59:30 -05:00
|
|
|
lib_gl_handle = NULL;
|
2002-12-11 02:16:31 -05:00
|
|
|
#endif
|
2003-09-07 12:11:15 -04:00
|
|
|
#ifdef _AGL
|
2003-09-29 07:58:35 -04:00
|
|
|
aglUnloadFramework(opengl_bundle_ref);
|
|
|
|
aglUnloadFramework(agl_bundle_ref);
|
2004-02-28 11:59:30 -05:00
|
|
|
opengl_bundle_ref = NULL;
|
2004-02-15 10:21:24 -05:00
|
|
|
#endif
|
2002-11-18 15:02:17 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* turn on the warning for the borland compiler*/
|
|
|
|
#ifdef __BORLANDC__
|
|
|
|
#pragma warn .8064
|
|
|
|
#pragma warn .8065
|
|
|
|
#endif /* __BORLANDC__ */
|
|
|
|
|