From 48360cccc3e995160a6966618bb173a84ebd101d Mon Sep 17 00:00:00 2001 From: Michael Bien Date: Sat, 27 Mar 2010 02:26:27 +0100 Subject: renamed com.sun.gluegen.runtime -> com.jogamp.gluegen.runtime. --- .../gluegen/runtime/opengl/GLExtensionNames.java | 187 +++++++++++++++++++++ 1 file changed, 187 insertions(+) create mode 100644 src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java (limited to 'src/java/com/jogamp') diff --git a/src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java b/src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java new file mode 100644 index 000000000..b07a96fbf --- /dev/null +++ b/src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java @@ -0,0 +1,187 @@ +/* + * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * - Redistribution of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistribution 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. + * + * Neither the name of Sun Microsystems, Inc. or the names of + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. ALL + * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, + * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, + * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF + * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for use + * in the design, construction, operation or maintenance of any nuclear + * facility. + * + */ + +package com.jogamp.gluegen.runtime.opengl; + +import java.util.*; +import com.jogamp.gluegen.runtime.*; + +public class GLExtensionNames { + //GL_XYZ : GL_XYZ, GL_XYZ_GL2, GL_XYZ_ARB, GL_XYZ_OES, GL_XYZ_OML + //GL_XYZ : GL_XYZ, GL_GL2_XYZ, GL_ARB_XYZ, GL_OES_XYZ, GL_OML_XYZ + // + // Pass-1 Unify ARB extensions with the same value + // Pass-2 Unify vendor extensions, + // if exist as an ARB extension with the same value. + // Pass-3 Emit + + public static final String[] extensionsARB = { "ARB", "GL2", "OES", "KHR", "OML" }; + public static final String[] extensionsVEN = { "3DFX", + "AMD", + "APPLE", + "ATI", + "EXT", + "HP", + "IBM", + "MESA", + "MESAX", + "NV", + "SGI", + "SGIS", + "SGIX", + "SUN", + "WIN" + }; + + + public static final boolean isGLFunction(String str) { + return str.startsWith("gl") || /* str.startsWith("glu") || str.startsWith("glX") || */ + str.startsWith("egl") || str.startsWith("wgl") || str.startsWith("agl") || + str.startsWith("cgl") ; + } + + public static final boolean isGLEnumeration(String str) { + return str.startsWith("GL_") || str.startsWith("GLU_") || str.startsWith("GLX_") || + str.startsWith("EGL_") || str.startsWith("WGL_") || str.startsWith("AGL_") || + str.startsWith("CGL_") ; + } + + public static final int getExtensionIdx(String[] extensions, String str, boolean isGLFunc) { + if(isGLFunc) { + for(int i = extensions.length - 1 ; i>=0 ; i--) { + if( str.endsWith(extensions[i]) ) { + return i; + } + } + } else { + for(int i = extensions.length - 1 ; i>=0 ; i--) { + if( str.endsWith("_"+extensions[i]) ) { + return i; + } + } + } + return -1; + } + + public static final boolean isExtension(String[] extensions, String str, boolean isGLFunc) { + return getExtensionIdx(extensions, str, isGLFunc)>=0; + } + + public static final String getExtensionSuffix(String str, boolean isGLFunc) { + int idx = getExtensionIdx(extensionsARB, str, isGLFunc); + if(idx>=0) { + return extensionsARB[idx]; + } + idx = getExtensionIdx(extensionsVEN, str, isGLFunc); + if(idx>=0) { + return extensionsVEN[idx]; + } + return null; + } + + public static final String normalize(String[] extensions, String str, boolean isGLFunc) { + boolean touched = false; + for(int i = extensions.length - 1 ; !touched && i>=0 ; i--) { + if(isGLFunc) { + if(str.endsWith(extensions[i])) { + // functions + str = str.substring(0, str.length()-extensions[i].length()); + touched=true; + } + } else { + if(str.endsWith("_"+extensions[i])) { + // enums + str = str.substring(0, str.length()-1-extensions[i].length()); + touched=true; + } + } + } + return str; + } + public static final String normalizeARB(String str, boolean isGLFunc) { + return normalize(extensionsARB, str, isGLFunc); + } + public static final boolean isExtensionARB(String str, boolean isGLFunc) { + return isExtension(extensionsARB, str, isGLFunc); + } + public static final String normalizeVEN(String str, boolean isGLFunc) { + return normalize(extensionsVEN, str, isGLFunc); + } + public static final boolean isExtensionVEN(String str, boolean isGLFunc) { + return isExtension(extensionsVEN, str, isGLFunc); + } + public static final String normalize(String str, boolean isGLFunc) { + if (isExtensionARB(str, isGLFunc)) { + return normalizeARB(str, isGLFunc); + } + if (isExtensionVEN(str, isGLFunc)) { + return normalizeVEN(str, isGLFunc); + } + return str; + } + public static final boolean isExtension(String str, boolean isGLFunc) { + return isExtension(extensionsARB, str, isGLFunc) || + isExtension(extensionsVEN, str, isGLFunc); + } + + public static final int getFuncNamePermutationNumber(String name) { + if(isExtensionARB(name, true) || isExtensionVEN(name, true)) { + // no name permutation, if it's already a known extension + return 1; + } + return 1 + extensionsARB.length + extensionsVEN.length; + } + + public static final String getFuncNamePermutation(String name, int i) { + // identity + if(i==0) { + return name; + } + if(0>i || i>=(1+extensionsARB.length + extensionsVEN.length)) { + throw new RuntimeException("Index out of range [0.."+(1+extensionsARB.length+extensionsVEN.length-1)+"]: "+i); + } + // ARB + i-=1; + if(i Date: Sat, 24 Apr 2010 18:13:36 +0200 Subject: Refactored ProcAddressTable generation. - ProcAddressTable is now the common superclass for all tables - Removed ProcAddressHelpers and added FunctionAddressResolver extension mechanism --- .../runtime/opengl/GLProcAddressResolver.java | 61 ++++++++++++++++++++++ src/java/com/sun/gluegen/opengl/GLEmitter.java | 10 ++-- 2 files changed, 66 insertions(+), 5 deletions(-) create mode 100644 src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java (limited to 'src/java/com/jogamp') diff --git a/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java b/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java new file mode 100644 index 000000000..ebe4d2685 --- /dev/null +++ b/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2010, Michael Bien + * 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. + * * Neither the name of JogAmp nor the + * names of its contributors 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 Michael Bien 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. + */ + +/* + * Created on Saturday, April 24 2010 16:44 + */ +package com.jogamp.gluegen.runtime.opengl; + +import com.jogamp.common.os.DynamicLookupHelper; +import com.jogamp.gluegen.runtime.FunctionAddressResolver; + +/** + * @author Sven Gothel + * @author Michael Bien + */ +public class GLProcAddressResolver implements FunctionAddressResolver { + + + public long resolve(String name, DynamicLookupHelper lookup) { + + int permutations = GLExtensionNames.getFuncNamePermutationNumber(name); + + for (int i = 0; i < permutations; i++) { + String funcName = GLExtensionNames.getFuncNamePermutation(name, i); + try { + return lookup.dynamicLookupFunction(funcName); + } catch (Exception e) { +// if (DEBUG) { +// dout.println(e); +// e.printStackTrace(); +// } + } + } + + throw new RuntimeException("unresolveable function name: "+name); + } +} diff --git a/src/java/com/sun/gluegen/opengl/GLEmitter.java b/src/java/com/sun/gluegen/opengl/GLEmitter.java index 006287e02..b5df6ff2d 100644 --- a/src/java/com/sun/gluegen/opengl/GLEmitter.java +++ b/src/java/com/sun/gluegen/opengl/GLEmitter.java @@ -419,17 +419,17 @@ public class GLEmitter extends ProcAddressEmitter { w.println(" * it was statically linked."); w.println(" */"); w.println(" public long getAddressFor(String functionNameUsr) {"); - w.println(" String functionNameBase = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.normalizeVEN(com.jogamp.gluegen.runtime.opengl.GLExtensionNames.normalizeARB(functionNameUsr, true), true);"); - w.println(" String addressFieldNameBase = " + getProcAddressConfig().gluegenRuntimePackage() + ".ProcAddressHelper.PROCADDRESS_VAR_PREFIX + functionNameBase;"); + w.println(" String functionNameBase = "+GLExtensionNames.class.getName()+".normalizeVEN(com.jogamp.gluegen.runtime.opengl.GLExtensionNames.normalizeARB(functionNameUsr, true), true);"); + w.println(" String addressFieldNameBase = PROCADDRESS_VAR_PREFIX + functionNameBase;"); w.println(" java.lang.reflect.Field addressField = null;"); - w.println(" int funcNamePermNum = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutationNumber(functionNameBase);"); + w.println(" int funcNamePermNum = "+GLExtensionNames.class.getName()+".getFuncNamePermutationNumber(functionNameBase);"); w.println(" for(int i = 0; null==addressField && i < funcNamePermNum; i++) {"); - w.println(" String addressFieldName = com.jogamp.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutation(addressFieldNameBase, i);"); + w.println(" String addressFieldName = "+GLExtensionNames.class.getName()+".getFuncNamePermutation(addressFieldNameBase, i);"); w.println(" try {"); w.println(" addressField = getClass().getField(addressFieldName);"); w.println(" } catch (Exception e) { }"); w.println(" }"); - w.println(""); + w.println(); w.println(" if(null==addressField) {"); w.println(" // The user is calling a bogus function or one which is not"); w.println(" // runtime linked"); -- cgit v1.2.3 From f8fe770c3e32b8159476b2f02cd316288bae06b1 Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Tue, 27 Apr 2010 03:21:40 +0200 Subject: Fix GLProcAddressResolver regression: Loop through all names until found or n/a. Return 0 if not found, no Exception --- .../gluegen/runtime/opengl/GLProcAddressResolver.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'src/java/com/jogamp') diff --git a/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java b/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java index ebe4d2685..914e52792 100644 --- a/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java +++ b/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java @@ -39,23 +39,23 @@ import com.jogamp.gluegen.runtime.FunctionAddressResolver; */ public class GLProcAddressResolver implements FunctionAddressResolver { + public static final boolean DEBUG = false; public long resolve(String name, DynamicLookupHelper lookup) { + long newProcAddress = 0; int permutations = GLExtensionNames.getFuncNamePermutationNumber(name); - for (int i = 0; i < permutations; i++) { + for (int i = 0; 0 == newProcAddress && i < permutations; i++) { String funcName = GLExtensionNames.getFuncNamePermutation(name, i); try { - return lookup.dynamicLookupFunction(funcName); + newProcAddress = lookup.dynamicLookupFunction(funcName); } catch (Exception e) { -// if (DEBUG) { -// dout.println(e); -// e.printStackTrace(); -// } + if (DEBUG) { + e.printStackTrace(); + } } } - - throw new RuntimeException("unresolveable function name: "+name); + return newProcAddress; } } -- cgit v1.2.3 From 4b3c44f66284fa932bf4dd5a4b7d00fab0d9e692 Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Tue, 14 Sep 2010 04:45:37 +0200 Subject: LICENSE.txt changes: - Added JogAmp Community and common denominator: New BSD 3-clause license - Added note to make/lib binary file (source and license) Added source and license text for external binaries used in build process (make/lib folder). Changed 'Sven Gothel' and 'Michael Bien' New BSD 3-clause license to 'JogAmp Community' Simplified BSD 2-clause license. --- .../runtime/opengl/GLProcAddressResolver.java | 51 +++++++++++----------- 1 file changed, 26 insertions(+), 25 deletions(-) (limited to 'src/java/com/jogamp') diff --git a/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java b/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java index 914e52792..fe9efebc7 100644 --- a/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java +++ b/src/java/com/jogamp/gluegen/runtime/opengl/GLProcAddressResolver.java @@ -1,30 +1,31 @@ -/* - * Copyright (c) 2010, Michael Bien - * 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. - * * Neither the name of JogAmp nor the - * names of its contributors may be used to endorse or promote products - * derived from this software without specific prior written permission. +/** + * Copyright 2010 JogAmp Community. All rights reserved. * - * 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 Michael Bien 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. + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``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 JogAmp Community 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. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. */ - + /* * Created on Saturday, April 24 2010 16:44 */ -- cgit v1.2.3 From 73c2bd4caae11f084dabc34ee201e946a88d20c0 Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Thu, 4 Nov 2010 21:14:30 +0100 Subject: Updated list of OpenGL extension vendor suffixes --- src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'src/java/com/jogamp') diff --git a/src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java b/src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java index b07a96fbf..914036312 100644 --- a/src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java +++ b/src/java/com/jogamp/gluegen/runtime/opengl/GLExtensionNames.java @@ -52,18 +52,24 @@ public class GLExtensionNames { public static final String[] extensionsARB = { "ARB", "GL2", "OES", "KHR", "OML" }; public static final String[] extensionsVEN = { "3DFX", "AMD", + "ANGLE", + "ARM", "APPLE", "ATI", "EXT", + "HI", "HP", "IBM", + "IMG", "MESA", "MESAX", "NV", + "QCOM", "SGI", "SGIS", "SGIX", "SUN", + "VIV", "WIN" }; -- cgit v1.2.3