673 lines
30 KiB
C++
Executable File
673 lines
30 KiB
C++
Executable File
/* ----------------------------------------------------------------------------
|
|
Copyright (c) 2001-2002, Lev Povalahev
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
* Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
* The name of the author may be used to endorse or promote products
|
|
derived from this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
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
|
|
THE POSSIBILITY OF SUCH DAMAGE.
|
|
------------------------------------------------------------------------------*/
|
|
/*
|
|
Lev Povalahev
|
|
|
|
levp@gmx.net
|
|
|
|
http://www.uni-karlsruhe.de/~uli2/
|
|
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "extgl.h"
|
|
#include "common_tools.h"
|
|
|
|
/* turn off the warning for the borland compiler*/
|
|
#ifdef __BORLANDC__
|
|
#pragma warn -8064
|
|
#pragma warn -8065
|
|
#endif /* __BORLANDC__ */
|
|
|
|
#ifdef _X11
|
|
|
|
#include <dlfcn.h>
|
|
#endif
|
|
|
|
#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;
|
|
aglSurfaceTexturePROC aglSurfaceTexture = NULL;
|
|
#endif
|
|
|
|
|
|
struct ExtensionTypes extgl_Extensions;
|
|
|
|
#ifdef _WIN32
|
|
HMODULE lib_gl_handle = NULL;
|
|
#endif
|
|
|
|
#ifdef _X11
|
|
void * lib_gl_handle = NULL;
|
|
|
|
typedef void * (APIENTRY * glXGetProcAddressARBPROC) (const GLubyte *procName);
|
|
|
|
static glXGetProcAddressARBPROC glXGetProcAddressARB;
|
|
#endif
|
|
|
|
#ifdef _AGL
|
|
CFBundleRef opengl_bundle_ref = NULL;
|
|
CFBundleRef agl_bundle_ref = NULL;
|
|
#endif
|
|
|
|
/* getProcAddress */
|
|
|
|
void *extgl_GetProcAddress(const char *name)
|
|
{
|
|
#ifdef _WIN32
|
|
void *t = wglGetProcAddress(name);
|
|
if (t == NULL)
|
|
{
|
|
t = GetProcAddress(lib_gl_handle, name);
|
|
if (t == NULL)
|
|
{
|
|
printfDebug("Could not locate symbol %s\n", name);
|
|
}
|
|
}
|
|
return t;
|
|
#endif
|
|
|
|
#ifdef _X11
|
|
void *t = (void*)glXGetProcAddressARB((const GLubyte*)name);
|
|
if (t == NULL)
|
|
{
|
|
t = dlsym(lib_gl_handle, name);
|
|
if (t == NULL)
|
|
{
|
|
printfDebug("Could not locate symbol %s\n", name);
|
|
}
|
|
}
|
|
return t;
|
|
#endif
|
|
|
|
#ifdef _AGL
|
|
CFStringRef str = CFStringCreateWithCStringNoCopy(NULL, name, kCFStringEncodingUTF8, kCFAllocatorNull);
|
|
void *func_pointer = CFBundleGetFunctionPointerForName(opengl_bundle_ref, str);
|
|
if (func_pointer == NULL) {
|
|
func_pointer = CFBundleGetFunctionPointerForName(agl_bundle_ref, str);
|
|
if (func_pointer == NULL) {
|
|
printfDebug("Could not locate symbol %s\n", name);
|
|
}
|
|
}
|
|
CFRelease(str);
|
|
return func_pointer;
|
|
#endif
|
|
}
|
|
|
|
bool extgl_InitializeClass(JNIEnv *env, jclass clazz, jobject ext_set, const char *ext_name, int num_functions, JavaMethodAndExtFunction *functions) {
|
|
return ext_InitializeClass(env, clazz, ext_set, ext_name, &extgl_GetProcAddress, num_functions, functions);
|
|
}
|
|
|
|
bool extgl_InitializeFunctions(int num_functions, ExtFunction *functions) {
|
|
return ext_InitializeFunctions(&extgl_GetProcAddress, num_functions, functions);
|
|
}
|
|
|
|
static void insertExtension(JNIEnv *env, jobject ext_set, const char *ext) {
|
|
doExtension(env, ext_set, "add", ext);
|
|
}
|
|
|
|
#ifdef _AGL
|
|
// -------------------------
|
|
static CFBundleRef loadBundle(const Str255 frameworkName)
|
|
{
|
|
OSStatus err = noErr;
|
|
FSRefParam fileRefParam;
|
|
FSRef fileRef;
|
|
CFURLRef bundleURLOpenGL;
|
|
CFBundleRef bundle_ref;
|
|
|
|
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)
|
|
{
|
|
printfDebug("Could not find frameworks folder\n");
|
|
return NULL;
|
|
}
|
|
|
|
// make FSRef for folder
|
|
//
|
|
err = PBMakeFSRefSync (&fileRefParam);
|
|
|
|
|
|
if (noErr != err)
|
|
{
|
|
printfDebug("Could make FSref to frameworks folder\n");
|
|
return NULL;
|
|
}
|
|
|
|
// create URL to folder
|
|
//
|
|
bundleURLOpenGL = CFURLCreateFromFSRef (kCFAllocatorDefault, &fileRef);
|
|
if (!bundleURLOpenGL)
|
|
{
|
|
printfDebug("Could create framework URL\n");
|
|
return NULL;
|
|
}
|
|
|
|
bundle_ref = CFBundleCreate(kCFAllocatorDefault,bundleURLOpenGL);
|
|
CFRelease (bundleURLOpenGL);
|
|
if (bundle_ref == NULL)
|
|
{
|
|
printfDebug("Could not load framework\n");
|
|
return NULL;
|
|
}
|
|
|
|
// if the code was successfully loaded, look for our function.
|
|
if (!CFBundleLoadExecutable(bundle_ref))
|
|
{
|
|
printfDebug("Could not load MachO executable\n");
|
|
CFRelease(bundle_ref);
|
|
return NULL;
|
|
}
|
|
|
|
return bundle_ref;
|
|
}
|
|
|
|
static void aglUnloadFramework(CFBundleRef f)
|
|
{
|
|
CFBundleUnloadExecutable(f);
|
|
CFRelease(f);
|
|
}
|
|
|
|
#endif
|
|
|
|
bool extgl_QueryExtension(JNIEnv *env, jobject ext_set, const GLubyte*extensions, const char *name)
|
|
{
|
|
const GLubyte *start;
|
|
GLubyte *where, *terminator;
|
|
|
|
if (extensions == NULL) {
|
|
printfDebug("NULL extension string\n");
|
|
return false;
|
|
}
|
|
|
|
/* Extension names should not have spaces. */
|
|
where = (GLubyte *) strchr(name, ' ');
|
|
if (where || *name == '\0')
|
|
return false;
|
|
|
|
/* 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;
|
|
for (;;)
|
|
{
|
|
where = (GLubyte *) strstr((const char *) start, name);
|
|
if (!where)
|
|
break;
|
|
terminator = where + strlen(name);
|
|
if (where == start || *(where - 1) == ' ')
|
|
if (*terminator == ' ' || *terminator == '\0') {
|
|
if (ext_set != NULL) {
|
|
insertExtension(env, ext_set, name);
|
|
}
|
|
return true;
|
|
}
|
|
start = terminator;
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
/*-----------------------------------------------------*/
|
|
/* AGL stuff BEGIN*/
|
|
/*-----------------------------------------------------*/
|
|
#ifdef _AGL
|
|
|
|
bool extgl_InitAGL(JNIEnv *env)
|
|
{
|
|
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; // Split out AGL into extgl_agl.cpp like wgl and glx and replace with InitializeFunctions
|
|
}
|
|
|
|
#endif
|
|
/*-----------------------------------------------------*/
|
|
/* AGL stuff END*/
|
|
/*-----------------------------------------------------*/
|
|
|
|
/** returns true if the extention is available */
|
|
static bool GLQueryExtension(JNIEnv *env, jobject ext_set, const char *name)
|
|
{
|
|
return extgl_QueryExtension(env, ext_set, glGetString(GL_EXTENSIONS), name);
|
|
}
|
|
|
|
static void extgl_InitSupportedExtensions(JNIEnv *env, jobject ext_set)
|
|
{
|
|
char *s = (char*) glGetString(GL_VERSION);
|
|
if (!s)
|
|
return;
|
|
s = strstr(s, "1.");
|
|
extgl_Extensions.OpenGL12 = false;
|
|
extgl_Extensions.OpenGL13 = false;
|
|
extgl_Extensions.OpenGL14 = false;
|
|
extgl_Extensions.OpenGL15 = false;
|
|
if (s != NULL)
|
|
{
|
|
// Fall trhough
|
|
switch (s[2]) {
|
|
case '5':
|
|
extgl_Extensions.OpenGL15 = true;
|
|
insertExtension(env, ext_set, "OpenGL15");
|
|
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;
|
|
}
|
|
}
|
|
|
|
extgl_Extensions.GL_ARB_imaging = GLQueryExtension(env, ext_set, "GL_ARB_imaging");
|
|
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_fragment_program_shadow = GLQueryExtension(env, ext_set, "GL_ARB_fragment_program_shadow");
|
|
extgl_Extensions.GL_ARB_fragment_shader = GLQueryExtension(env, ext_set, "GL_ARB_fragment_shader");
|
|
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");
|
|
extgl_Extensions.GL_ARB_occlusion_query = GLQueryExtension(env, ext_set, "GL_ARB_occlusion_query");
|
|
extgl_Extensions.GL_ARB_point_parameters = GLQueryExtension(env, ext_set, "GL_ARB_point_parameters");
|
|
extgl_Extensions.GL_ARB_point_sprite = GLQueryExtension(env, ext_set, "GL_ARB_point_sprite");
|
|
extgl_Extensions.GL_ARB_shading_language_100 = GLQueryExtension(env, ext_set, "GL_ARB_shading_language_100");
|
|
extgl_Extensions.GL_ARB_shader_objects = GLQueryExtension(env, ext_set, "GL_ARB_shader_objects");
|
|
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_texture_non_power_of_two = GLQueryExtension(env, ext_set, "GL_ARB_texture_non_power_of_two");
|
|
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");
|
|
extgl_Extensions.GL_ARB_vertex_shader = GLQueryExtension(env, ext_set, "GL_ARB_vertex_shader");
|
|
extgl_Extensions.GL_ARB_window_pos = GLQueryExtension(env, ext_set, "GL_ARB_window_pos");
|
|
|
|
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_equation_separate = GLQueryExtension(env, ext_set, "GL_EXT_blend_equation_separate");
|
|
extgl_Extensions.GL_EXT_blend_func_separate = GLQueryExtension(env, ext_set, "GL_EXT_blend_func_separate");
|
|
extgl_Extensions.GL_EXT_blend_subtract = GLQueryExtension(env, ext_set, "GL_EXT_blend_subtract");
|
|
extgl_Extensions.GL_EXT_Cg_shader = GLQueryExtension(env, ext_set, "GL_EXT_Cg_shader");
|
|
extgl_Extensions.GL_EXT_compiled_vertex_array = GLQueryExtension(env, ext_set, "GL_EXT_compiled_vertex_array");
|
|
extgl_Extensions.GL_EXT_depth_bounds_test = GLQueryExtension(env, ext_set, "GL_EXT_depth_bounds_test");
|
|
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_packed_pixels = GLQueryExtension(env, ext_set, "GL_EXT_packed_pixels");
|
|
extgl_Extensions.GL_EXT_pixel_buffer_object = GLQueryExtension(env, ext_set, "GL_EXT_pixel_buffer_object");
|
|
extgl_Extensions.GL_EXT_point_parameters = GLQueryExtension(env, ext_set, "GL_EXT_point_parameters");
|
|
extgl_Extensions.GL_EXT_rescale_normal = GLQueryExtension(env, ext_set, "GL_EXT_rescale_normal");
|
|
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_shared_texture_palette = GLQueryExtension(env, ext_set, "GL_EXT_shared_texture_palette");
|
|
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_env_dot3 = GLQueryExtension(env, ext_set, "GL_EXT_texture_env_dot3");
|
|
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_texture_rectangle = GLQueryExtension(env, ext_set, "GL_EXT_texture_rectangle");
|
|
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");
|
|
|
|
extgl_Extensions.GL_ATI_draw_buffers = GLQueryExtension(env, ext_set, "GL_ATI_draw_buffers");
|
|
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");
|
|
extgl_Extensions.GL_ATI_map_object_buffer = GLQueryExtension(env, ext_set, "GL_ATI_map_object_buffer");
|
|
extgl_Extensions.GL_ATI_pn_triangles = GLQueryExtension(env, ext_set, "GL_ATI_pn_triangles");
|
|
extgl_Extensions.GL_ATI_separate_stencil = GLQueryExtension(env, ext_set, "GL_ATI_separate_stencil");
|
|
extgl_Extensions.GL_ATI_texture_float = GLQueryExtension(env, ext_set, "GL_ATI_texture_float");
|
|
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");
|
|
extgl_Extensions.GL_ATI_vertex_streams = GLQueryExtension(env, ext_set, "GL_ATI_vertex_streams");
|
|
extgl_Extensions.GL_ATI_vertex_attrib_array_object = GLQueryExtension(env, ext_set, "GL_ATI_vertex_attrib_array_object");
|
|
|
|
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_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");
|
|
extgl_Extensions.GL_NV_fragment_program_option = GLQueryExtension(env, ext_set, "GL_NV_fragment_program_option");
|
|
extgl_Extensions.GL_NV_half_float = GLQueryExtension(env, ext_set, "GL_NV_half_float");
|
|
extgl_Extensions.GL_NV_light_max_exponent = GLQueryExtension(env, ext_set, "GL_NV_light_max_exponent");
|
|
extgl_Extensions.GL_NV_multisample_filter_hint = GLQueryExtension(env, ext_set, "GL_NV_multisample_filter_hint");
|
|
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");
|
|
extgl_Extensions.GL_NV_pixel_data_range = GLQueryExtension(env, ext_set, "GL_NV_pixel_data_range");
|
|
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_compression_vtc = GLQueryExtension(env, ext_set, "GL_NV_texture_compression_vtc");
|
|
extgl_Extensions.GL_NV_texture_env_combine4 = GLQueryExtension(env, ext_set, "GL_NV_texture_env_combine4");
|
|
extgl_Extensions.GL_NV_texture_expand_normal = GLQueryExtension(env, ext_set, "GL_NV_texture_expand_normal");
|
|
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");
|
|
extgl_Extensions.GL_NV_vertex_program2_option = GLQueryExtension(env, ext_set, "GL_NV_vertex_program2_option");
|
|
}
|
|
|
|
extern bool extgl_InitOpenGL1_1(JNIEnv *env);
|
|
|
|
extern void extgl_InitARBBufferObject(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitARBImaging(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitARBMatrixPalette(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitARBMultisample(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitARBMultitexture(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitARBOcclusionQuery(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitARBPointParameters(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitARBProgram(JNIEnv *env, jobject ext_set);
|
|
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);
|
|
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_InitEXTBlendEquationSeparate(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitEXTBlendFuncSeparate(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitEXTCompiledVertexArray(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitEXTDepthBoundsTest(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitEXTDrawRangeElements(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitEXTFogCoord(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitEXTMultiDrawArrays(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitEXTPointParameters(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitEXTSecondaryColor(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitEXTStencilTwoSide(JNIEnv *env, jobject ext_set);
|
|
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);
|
|
extern void extgl_InitNVFragmentProgram(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitNVFence(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitNVHalfFloat(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitNVOcclusionQuery(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitNVPixelDataRange(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitNVPointSprite(JNIEnv *env, jobject ext_set);
|
|
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);
|
|
extern void extgl_InitATIEnvmapBumpmap(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitATIFragmentShader(JNIEnv *env, jobject ext_set);
|
|
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);
|
|
extern void extgl_InitATIVertexArrayObject(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitATIVertexAttribArrayObject(JNIEnv *env, jobject ext_set);
|
|
extern void extgl_InitATIVertexStreams(JNIEnv *env, jobject ext_set);
|
|
|
|
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);
|
|
extern void extgl_InitOpenGL1_5(JNIEnv *env, jobject ext_set);
|
|
|
|
/* extgl_Init the extensions and load all the functions */
|
|
bool extgl_Initialize(JNIEnv *env, jobject ext_set)
|
|
{
|
|
bool result = extgl_InitOpenGL1_1(env);
|
|
if (!result)
|
|
return false;
|
|
|
|
extgl_InitSupportedExtensions(env, ext_set);
|
|
|
|
//extgl_InitEXTNurbsTesselator(env, ext_set);
|
|
/* first load the extensions */
|
|
extgl_InitARBBufferObject(env, ext_set);
|
|
extgl_InitARBImaging(env, ext_set);
|
|
extgl_InitARBMatrixPalette(env, ext_set);
|
|
extgl_InitARBMultisample(env, ext_set);
|
|
extgl_InitARBMultitexture(env, ext_set);
|
|
extgl_InitARBOcclusionQuery(env, ext_set);
|
|
extgl_InitARBPointParameters(env, ext_set);
|
|
extgl_InitARBProgram(env, ext_set);
|
|
extgl_InitARBShaderObjects(env, ext_set);
|
|
extgl_InitARBTextureCompression(env, ext_set);
|
|
extgl_InitARBTransposeMatrix(env, ext_set);
|
|
extgl_InitARBVertexBlend(env, ext_set);
|
|
extgl_InitARBVertexProgram(env, ext_set);
|
|
extgl_InitARBVertexShader(env, ext_set);
|
|
extgl_InitARBWindowPos(env, ext_set);
|
|
|
|
extgl_InitEXTBlendEquationSeparate(env, ext_set);
|
|
extgl_InitEXTBlendFuncSeparate(env, ext_set);
|
|
extgl_InitEXTCompiledVertexArray(env, ext_set);
|
|
extgl_InitEXTDepthBoundsTest(env, ext_set);
|
|
extgl_InitEXTDrawRangeElements(env, ext_set);
|
|
extgl_InitEXTFogCoord(env, ext_set);
|
|
extgl_InitEXTMultiDrawArrays(env, ext_set);
|
|
extgl_InitEXTPointParameters(env, ext_set);
|
|
extgl_InitEXTSecondaryColor(env, ext_set);
|
|
extgl_InitEXTStencilTwoSide(env, ext_set);
|
|
extgl_InitEXTVertexShader(env, ext_set);
|
|
extgl_InitEXTVertexWeighting(env, ext_set);
|
|
|
|
extgl_InitNVEvaluators(env, ext_set);
|
|
extgl_InitNVFence(env, ext_set);
|
|
extgl_InitNVFragmentProgram(env, ext_set);
|
|
extgl_InitNVHalfFloat(env, ext_set);
|
|
extgl_InitNVOcclusionQuery(env, ext_set);
|
|
extgl_InitNVPixelDataRange(env, ext_set);
|
|
extgl_InitNVPointSprite(env, ext_set);
|
|
extgl_InitNVPrimitiveRestart(env, ext_set);
|
|
extgl_InitNVProgram(env, ext_set);
|
|
extgl_InitNVRegisterCombiners(env, ext_set);
|
|
extgl_InitNVRegisterCombiners2(env, ext_set);
|
|
extgl_InitNVVertexArrayRange(env, ext_set);
|
|
extgl_InitNVVertexProgram(env, ext_set);
|
|
extgl_InitATIDrawBuffers(env, ext_set);
|
|
extgl_InitATIElementArray(env, ext_set);
|
|
extgl_InitATIEnvmapBumpmap(env, ext_set);
|
|
extgl_InitATIFragmentShader(env, ext_set);
|
|
extgl_InitATIMapObjectBuffer(env, ext_set);
|
|
extgl_InitATIPNTriangles(env, ext_set);
|
|
extgl_InitATISeparateStencil(env, ext_set);
|
|
extgl_InitATIVertexArrayObject(env, ext_set);
|
|
extgl_InitATIVertexAttribArrayObject(env, ext_set);
|
|
extgl_InitATIVertexStreams(env, ext_set);
|
|
|
|
/* now load core opengl */
|
|
extgl_InitOpenGL1_2(env, ext_set);
|
|
extgl_InitOpenGL1_3(env, ext_set);
|
|
extgl_InitOpenGL1_4(env, ext_set);
|
|
extgl_InitOpenGL1_5(env, ext_set);
|
|
|
|
return true;
|
|
}
|
|
|
|
#ifdef _AGL
|
|
bool extgl_Open(void) {
|
|
if (opengl_bundle_ref != NULL)
|
|
return true;
|
|
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
|
|
|
|
#ifdef _X11
|
|
bool extgl_Open()
|
|
{
|
|
if (lib_gl_handle != NULL)
|
|
return true;
|
|
lib_gl_handle = dlopen("libGL.so.1", RTLD_LAZY | RTLD_GLOBAL);
|
|
if (lib_gl_handle == NULL) {
|
|
printfDebug("Error loading libGL.so.1: %s\n", dlerror());
|
|
return false;
|
|
}
|
|
glXGetProcAddressARB = (glXGetProcAddressARBPROC) dlsym(lib_gl_handle, "glXGetProcAddressARB");
|
|
if (glXGetProcAddressARB == NULL) {
|
|
extgl_Close();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endif /* X11 */
|
|
|
|
#ifdef _WIN32
|
|
bool extgl_Open(void)
|
|
{
|
|
if (lib_gl_handle != NULL)
|
|
return true;
|
|
// load the dynamic libraries for OpenGL
|
|
lib_gl_handle = LoadLibrary("opengl32.dll");
|
|
if (lib_gl_handle == NULL)
|
|
return false;
|
|
return true;
|
|
}
|
|
#endif /* WIN32 */
|
|
|
|
void extgl_Close(void)
|
|
{
|
|
#ifdef _X11
|
|
dlclose(lib_gl_handle);
|
|
lib_gl_handle = NULL;
|
|
#endif
|
|
#ifdef _WIN32
|
|
FreeLibrary(lib_gl_handle);
|
|
lib_gl_handle = NULL;
|
|
#endif
|
|
#ifdef _AGL
|
|
aglUnloadFramework(opengl_bundle_ref);
|
|
aglUnloadFramework(agl_bundle_ref);
|
|
opengl_bundle_ref = NULL;
|
|
#endif
|
|
}
|
|
|
|
/* turn on the warning for the borland compiler*/
|
|
#ifdef __BORLANDC__
|
|
#pragma warn .8064
|
|
#pragma warn .8065
|
|
#endif /* __BORLANDC__ */
|
|
|