summaryrefslogtreecommitdiffstats
path: root/src/java/com/sun
diff options
context:
space:
mode:
authorKenneth Russel <[email protected]>2009-06-15 22:42:48 +0000
committerKenneth Russel <[email protected]>2009-06-15 22:42:48 +0000
commit62444f682ec7a1a279d0f63af8848a8494ad9977 (patch)
tree76c6f19846040733fb2e7fe6dccab7eb0a843543 /src/java/com/sun
parent683dad39d72b99794096f5dbfdc2e70f443f2cf6 (diff)
Copied JOGL_2_SANDBOX r145 on to trunk; JOGL_2_SANDBOX branch is now closed
git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/../svn-server-sync/gluegen/trunk@147 a78bb65f-1512-4460-ba86-f6dc96a7bf27
Diffstat (limited to 'src/java/com/sun')
-rw-r--r--src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java1104
-rw-r--r--src/java/com/sun/gluegen/opengl/BuildStaticGLInfo.java333
-rwxr-xr-xsrc/java/com/sun/gluegen/opengl/GLConfiguration.java297
-rw-r--r--src/java/com/sun/gluegen/opengl/GLEmitter.java407
-rwxr-xr-xsrc/java/com/sun/gluegen/opengl/GLJavaMethodBindingEmitter.java103
-rw-r--r--src/java/com/sun/gluegen/runtime/opengl/GLExtensionNames.java187
6 files changed, 2431 insertions, 0 deletions
diff --git a/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java b/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java
new file mode 100644
index 000000000..89176f557
--- /dev/null
+++ b/src/java/com/sun/gluegen/opengl/BuildComposablePipeline.java
@@ -0,0 +1,1104 @@
+/*
+ * Copyright (c) 2003 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.
+ *
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.gluegen.opengl;
+
+import com.sun.gluegen.*;
+
+import java.lang.reflect.*;
+import java.io.*;
+import java.util.*;
+import java.util.regex.*;
+
+public class BuildComposablePipeline
+{
+ public static final int GEN_DEBUG = 1 << 0 ; // default
+ public static final int GEN_TRACE = 1 << 1 ; // default
+ public static final int GEN_CUSTOM = 1 << 2 ;
+ public static final int GEN_PROLOG_XOR_DOWNSTREAM = 1 << 3 ;
+
+ int mode;
+ private String outputDir;
+ private String outputPackage;
+ private String outputName;
+ private Class classToComposeAround;
+ private Class classPrologOpt;
+ private Class classDownstream;
+ private String basePackage;
+ private String baseName; // does not include package!
+ private String downstreamPackage;
+ private String downstreamName; // does not include package!
+
+ // Only desktop OpenGL has immediate mode glBegin / glEnd
+ private boolean hasImmediateMode;
+
+ // Desktop OpenGL and GLES1 have GL_STACK_OVERFLOW and GL_STACK_UNDERFLOW errors
+ private boolean hasStackOverflow;
+
+ public static Class getClass(String name) {
+ Class clazz=null;
+ try {
+ clazz = Class.forName(name);
+ } catch (Exception e) {
+ throw new RuntimeException(
+ "Could not find class \"" + name + "\"", e);
+ }
+ return clazz;
+ }
+
+ public static Method getMethod(Class clazz, Method m) {
+ Method res = null;
+ try {
+ res = clazz.getMethod(m.getName(), m.getParameterTypes());
+ } catch (Exception e) { }
+ return res;
+ }
+
+ public static void main(String[] args)
+ {
+ String classToComposeAroundName = args[0];
+ Class classPrologOpt, classDownstream;
+ Class classToComposeAround = getClass(classToComposeAroundName);
+
+ String outputDir = args[1];
+ String outputPackage, outputName;
+ int mode;
+
+ if(args.length>2) {
+ String outputClazzName = args[2];
+ outputPackage = getPackageName(outputClazzName);
+ outputName = getBaseClassName(outputClazzName);
+ classPrologOpt = getClass(args[3]);
+ classDownstream = getClass(args[4]);
+ mode = GEN_CUSTOM;
+ if(args.length>5) {
+ if(args[5].equals("prolog_xor_downstream")) {
+ mode |= GEN_PROLOG_XOR_DOWNSTREAM;
+ }
+ }
+ } else {
+ outputPackage = getPackageName(classToComposeAroundName);
+ outputName = null; // TBD ..
+ classPrologOpt = null;
+ classDownstream = classToComposeAround;
+ mode = GEN_DEBUG | GEN_TRACE;
+ }
+
+ BuildComposablePipeline composer =
+ new BuildComposablePipeline(mode, outputDir, outputPackage, outputName, classToComposeAround, classPrologOpt, classDownstream);
+
+ try
+ {
+ composer.emit();
+ }
+ catch (IOException e)
+ {
+ throw new RuntimeException(
+ "Error generating composable pipeline source files", e);
+ }
+ }
+
+ protected BuildComposablePipeline(int mode, String outputDir, String outputPackage, String outputName,
+ Class classToComposeAround, Class classPrologOpt, Class classDownstream)
+ {
+ this.mode=mode;
+ this.outputDir=outputDir;
+ this.outputPackage=outputPackage;
+ this.outputName=outputName;
+ this.classToComposeAround=classToComposeAround;
+ this.classPrologOpt=classPrologOpt;
+ this.classDownstream=classDownstream;
+
+ if (! classToComposeAround.isInterface())
+ {
+ throw new IllegalArgumentException(
+ classToComposeAround.getName() + " is not an interface class");
+ }
+
+ try {
+ hasImmediateMode =
+ (classToComposeAround.getMethod("glBegin", new Class[] { Integer.TYPE }) != null);
+ } catch (Exception e) {
+ }
+
+ try {
+ hasStackOverflow =
+ (classToComposeAround.getField("GL_STACK_OVERFLOW") != null);
+ } catch (Exception e) {
+ }
+ }
+
+ /**
+ * Emit the java source code for the classes that comprise the composable
+ * pipeline.
+ */
+ public void emit() throws IOException
+ {
+ List/*<Method>*/ publicMethodsRaw = new ArrayList();
+ publicMethodsRaw.addAll(Arrays.asList(classToComposeAround.getMethods()));
+ Set/*<Method>*/ publicMethodsPlain = new HashSet();
+ for (Iterator iter=publicMethodsRaw.iterator(); iter.hasNext(); ) {
+ Method method = (Method) iter.next();
+ // Don't hook methods which aren't real GL methods,
+ // such as the synthetic "isGL2ES2" "getGL2ES2"
+ String name = method.getName();
+ boolean runHooks = name.startsWith("gl");
+ if (!name.startsWith("getGL") && !name.startsWith("isGL") && !name.equals("toString")) {
+ publicMethodsPlain.add(new PlainMethod(method, runHooks));
+ }
+ }
+
+ if(0!=(mode&GEN_DEBUG)) {
+ (new DebugPipeline(outputDir, outputPackage, classToComposeAround, classDownstream)).emit(publicMethodsPlain.iterator());
+ }
+ if(0!=(mode&GEN_TRACE)) {
+ (new TracePipeline(outputDir, outputPackage, classToComposeAround, classDownstream)).emit(publicMethodsPlain.iterator());
+ }
+ if(0!=(mode&GEN_CUSTOM)) {
+ (new CustomPipeline(mode, outputDir, outputPackage, outputName, classToComposeAround, classPrologOpt, classDownstream)).emit(publicMethodsPlain.iterator());
+ }
+ }
+
+ public static String getPackageName(String clazzName) {
+ int lastDot = clazzName.lastIndexOf('.');
+ if (lastDot == -1)
+ {
+ // no package, class is at root level
+ return null;
+ }
+ return clazzName.substring(0, lastDot);
+ }
+
+ public static String getBaseClassName(String clazzName) {
+ int lastDot = clazzName.lastIndexOf('.');
+ if (lastDot == -1)
+ {
+ // no package, class is at root level
+ return clazzName;
+ }
+ return clazzName.substring(lastDot+1);
+ }
+
+ //-------------------------------------------------------
+
+ protected class PlainMethod
+ {
+ Method m;
+ boolean runHooks;
+
+ public PlainMethod(Method m, boolean runHooks) {
+ this.m=m;
+ this.runHooks = runHooks;
+ }
+
+ public Method getWrappedMethod() { return m; }
+
+ public boolean runHooks() { return runHooks; }
+
+ public boolean equals(Object obj) {
+ if(obj instanceof PlainMethod) {
+ PlainMethod b = (PlainMethod)obj;
+ boolean res =
+ m.getName().equals(b.m.getName()) &&
+ m.getModifiers() == b.m.getModifiers() &&
+ m.getReturnType().equals(b.m.getReturnType()) &&
+ Arrays.equals( m.getParameterTypes() , b.m.getParameterTypes() ) ;
+ return res;
+ }
+ return false;
+ }
+
+ public int hashCode() {
+ int hash = m.getName().hashCode() ^ m.getModifiers() ^ m.getReturnType().hashCode();
+ Class[] args = m.getParameterTypes();
+ for(int i=0; i<args.length; i++) {
+ hash ^= args[i].hashCode();
+ }
+ return hash;
+ }
+
+ public String toString() {
+ Class[] args = m.getParameterTypes();
+ StringBuffer argsString = new StringBuffer();
+ argsString.append("(");
+ for (int i = 0; i < args.length; i++) {
+ if (i > 0)
+ argsString.append(", ");
+ argsString.append(args[i].getName());
+ }
+ argsString.append(")");
+ return m.toString() +
+ "\n\tname: " + m.getName() +
+ "\n\tmods: " + m.getModifiers() +
+ "\n\tretu: " + m.getReturnType() +
+ "\n\targs[" + args.length + "]: "+argsString.toString();
+ }
+ }
+
+ /**
+ * Emits a Java source file that represents one element of the composable
+ * pipeline.
+ */
+ protected abstract class PipelineEmitter
+ {
+ private File file;
+ protected String basePackage;
+ protected String baseName; // does not include package!
+ protected String downstreamPackage;
+ protected String downstreamName; // does not include package!
+ protected String prologPackageOpt=null;
+ protected String prologNameOpt=null; // does not include package!
+
+ protected String outputDir;
+ protected String outputPackage;
+ protected Class baseInterfaceClass;
+ protected Class prologClassOpt=null;
+ protected Class downstreamClass;
+
+ /**
+ * @param outputDir the directory into which the pipeline classes will be
+ * generated.
+ * @param baseInterfaceClassName the full class name (including package,
+ * e.g. "java.lang.String") of the interface that the pipeline wraps
+ * @exception IllegalArgumentException if classToComposeAround is not an
+ * interface.
+ */
+ public PipelineEmitter(String outputDir, String outputPackage, Class baseInterfaceClass, Class prologClassOpt, Class downstreamClass)
+ {
+ this.outputDir=outputDir;
+ this.outputPackage=outputPackage;
+ this.baseInterfaceClass=baseInterfaceClass;
+ this.prologClassOpt=prologClassOpt;
+ this.downstreamClass=downstreamClass;
+
+ basePackage = getPackageName(baseInterfaceClass.getName());
+ baseName = getBaseClassName(baseInterfaceClass.getName());
+ downstreamPackage = getPackageName(downstreamClass.getName());
+ downstreamName = getBaseClassName(downstreamClass.getName());
+ if(null!=prologClassOpt) {
+ prologPackageOpt = getPackageName(prologClassOpt.getName());
+ prologNameOpt = getBaseClassName(prologClassOpt.getName());
+ }
+ }
+
+ public void emit(Iterator/*<Method>*/ methodsToWrap) throws IOException
+ {
+ String outputClassName = getOutputName();
+ this.file = new File(outputDir + File.separatorChar + outputClassName + ".java");
+ String parentDir = file.getParent();
+ if (parentDir != null)
+ {
+ File pDirFile = new File(parentDir);
+ pDirFile.mkdirs();
+ }
+
+ PrintWriter output = new PrintWriter(new BufferedWriter(new FileWriter(file)));
+
+ HashSet clazzList = new HashSet();
+ clazzList.add(baseInterfaceClass);
+ clazzList.addAll(Arrays.asList(baseInterfaceClass.getInterfaces()));
+
+ String[] ifNames = new String[clazzList.size()];
+ {
+ int i=0;
+ for (Iterator iter=clazzList.iterator(); iter.hasNext(); ) {
+ ifNames[i++] = new String(((Class)iter.next()).getName());
+ }
+ }
+
+ clazzList.add(downstreamClass);
+ if(null!=prologClassOpt) {
+ clazzList.add(prologClassOpt);
+ }
+
+ String[] importNames = new String[clazzList.size()+2];
+ {
+ int i=0;
+ importNames[i++] = new String("java.io.*");
+ importNames[i++] = new String("javax.media.opengl.*");
+ for (Iterator iter=clazzList.iterator(); iter.hasNext(); ) {
+ importNames[i++] = new String(((Class)iter.next()).getName());
+ }
+ }
+
+ CodeGenUtils.emitJavaHeaders(output,
+ outputPackage,
+ outputClassName,
+ "com.sun.gluegen.runtime", // FIXME: should make configurable
+ true,
+ importNames,
+ new String[] { "public" },
+ ifNames,
+ null,
+ new CodeGenUtils.EmissionCallback() {
+ public void emit(PrintWriter w) { emitClassDocComment(w); }
+ }
+ );
+
+ preMethodEmissionHook(output);
+
+ constructorHook(output);
+
+ emitGLIsMethods(output);
+ emitGLGetMethods(output);
+
+ while (methodsToWrap.hasNext())
+ {
+ PlainMethod pm = (PlainMethod)methodsToWrap.next();
+ Method m = pm.getWrappedMethod();
+ emitMethodDocComment(output, m);
+ emitSignature(output, m);
+ emitBody(output, m, pm.runHooks());
+ }
+
+ postMethodEmissionHook(output);
+
+ output.println();
+ output.print(" private " + downstreamName + " " + getDownstreamObjectName() + ";");
+
+ // end the class
+ output.println();
+ output.print("} // end class ");
+ output.println(outputClassName);
+
+ output.flush();
+ output.close();
+
+ System.out.println("wrote to file: "+file); // JAU
+ }
+
+ /** Get the name of the object through which API calls should be routed. */
+ protected String getDownstreamObjectName()
+ {
+ return "downstream" + downstreamName;
+ }
+
+ /** Get the name of the object which shall be called as a prolog. */
+ protected String getPrologObjectNameOpt()
+ {
+ if(null!=prologNameOpt) {
+ return "prolog" + prologNameOpt;
+ }
+ return null;
+ }
+
+ protected void emitMethodDocComment(PrintWriter output, Method m)
+ {
+ }
+
+ protected void emitSignature(PrintWriter output, Method m)
+ {
+ output.print(" public ");
+ output.print(' ');
+ output.print(JavaType.createForClass(m.getReturnType()).getName());
+ output.print(' ');
+ output.print(m.getName());
+ output.print('(');
+ output.print(getArgListAsString(m, true, true));
+ output.println(")");
+ }
+
+ protected void emitBody(PrintWriter output, Method m, boolean runHooks)
+ {
+ output.println(" {");
+ output.print(" ");
+ Class retType = m.getReturnType();
+
+ boolean callPreDownstreamHook = runHooks && hasPreDownstreamCallHook(m);
+ boolean callPostDownstreamHook = runHooks && hasPostDownstreamCallHook(m);
+ boolean callDownstream = (null!=getMethod(downstreamClass, m)) &&
+ !( 0!=(GEN_PROLOG_XOR_DOWNSTREAM&getMode()) && callPreDownstreamHook ) ;
+ boolean hasResult = (retType != Void.TYPE);
+
+ if(!callDownstream) {
+ if(!emptyDownstreamAllowed()) {
+ throw new RuntimeException("Method "+m+" has no downstream ("+downstreamName+")");
+ }
+ }
+
+ if(!callPreDownstreamHook && !callPostDownstreamHook && !callDownstream) {
+ if(!emptyMethodAllowed()) {
+ throw new RuntimeException("Method "+m+" is empty, no downstream ("+downstreamName+") nor prolog ("+prologNameOpt+").");
+ } else {
+ output.print(" if(DEBUG) { System.out.println(\"WARNING: No prolog, no downstream, empty: \"+");
+ printFunctionCallString(output, m);
+ output.println("); } ");
+ }
+ }
+
+ if (callPreDownstreamHook) {
+ if(hasResult && !callDownstream) {
+ if(callPostDownstreamHook) {
+ output.print(" "+JavaType.createForClass(retType).getName());
+ output.print(" _res = ");
+ } else {
+ output.print(" return ");
+ }
+ }
+ preDownstreamCallHook(output, m);
+ }
+
+ if(callDownstream) {
+ if (hasResult) {
+ if(callPostDownstreamHook) {
+ output.print(" "+JavaType.createForClass(retType).getName());
+ output.print(" _res = ");
+ } else {
+ output.print(" return ");
+ }
+ }
+ output.print(getDownstreamObjectName());
+ output.print('.');
+ output.print(m.getName());
+ output.print('(');
+ output.print(getArgListAsString(m, false, true));
+ output.println(");");
+ }
+
+ if (callPostDownstreamHook) {
+ postDownstreamCallHook(output, m);
+ }
+
+ if (hasResult && callDownstream && callPostDownstreamHook) {
+ output.println(" return _res;");
+ }
+ output.println(" }");
+
+ }
+
+ protected String getArgListAsString(Method m, boolean includeArgTypes, boolean includeArgNames)
+ {
+ StringBuffer buf = new StringBuffer(256);
+ if (!includeArgNames && !includeArgTypes)
+ {
+ throw new IllegalArgumentException(
+ "Cannot generate arglist without both arg types and arg names");
+ }
+
+ Class[] argTypes = m.getParameterTypes();
+ for (int i = 0; i < argTypes.length; ++i)
+ {
+ if (includeArgTypes)
+ {
+ buf.append(JavaType.createForClass(argTypes[i]).getName());
+ buf.append(' ');
+ }
+
+ if (includeArgNames)
+ {
+ buf.append("arg");
+ buf.append(i);
+ }
+ if (i < argTypes.length-1) { buf.append(','); }
+ }
+
+ return buf.toString();
+ }
+
+ /** The name of the class around which this pipeline is being
+ * composed. E.g., if this pipeline was constructed with
+ * "java.util.Set" as the baseInterfaceClassName, then this method will
+ * return "Set".
+ */
+ protected String getBaseInterfaceName()
+ {
+ return baseName;
+ }
+
+ /** Get the output name for this pipeline class. */
+ protected abstract String getOutputName();
+
+ /**
+ * Called after the class headers have been generated, but before any
+ * method wrappers have been generated.
+ */
+ protected void preMethodEmissionHook(PrintWriter output) {
+ output.println(" public static final boolean DEBUG = com.sun.opengl.impl.Debug.debug(\""+getOutputName()+"\");");
+ }
+
+ /**
+ * Emits the constructor for the pipeline; called after the preMethodEmissionHook.
+ */
+ protected abstract void constructorHook(PrintWriter output);
+
+ /**
+ * Called after the method wrappers have been generated, but before the
+ * closing parenthesis of the class is emitted.
+ */
+ protected void postMethodEmissionHook(PrintWriter output) {
+ output.println( " public String toString() {");
+ output.println( " StringBuffer sb = new StringBuffer();");
+ output.println( " sb.append(\""+getOutputName()+" [ implementing "+baseInterfaceClass.getName()+",\\n\\t\");");
+ if(null!=prologClassOpt) {
+ output.println( " sb.append(\" prolog: \"+"+getPrologObjectNameOpt()+".toString()+\",\\n\\t\");");
+ }
+ output.println( " sb.append(\" downstream: \"+"+getDownstreamObjectName()+".toString()+\"\\n\\t]\");");
+ output.println( " return sb.toString();");
+ output.println( " }");
+ }
+
+ /**
+ * Called before the pipeline routes the call to the downstream object.
+ */
+ protected abstract void preDownstreamCallHook(PrintWriter output, Method m);
+ protected abstract boolean hasPreDownstreamCallHook(Method m);
+
+ /**
+ * Called after the pipeline has routed the call to the downstream object,
+ * but before the calling function exits or returns a value.
+ */
+ protected abstract void postDownstreamCallHook(PrintWriter output, Method m);
+
+ protected abstract boolean hasPostDownstreamCallHook(Method m);
+
+ protected abstract int getMode();
+ protected abstract boolean emptyMethodAllowed();
+ protected abstract boolean emptyDownstreamAllowed();
+
+ /** Emit a Javadoc comment for this pipeline class. */
+ protected abstract void emitClassDocComment(PrintWriter output);
+
+ /**
+ * Emits one of the isGL* methods.
+ */
+ protected void emitGLIsMethod(PrintWriter output, String type) {
+ output.println(" public boolean is" + type + "() {");
+ Class clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
+ if (clazz.isAssignableFrom(baseInterfaceClass)) {
+ output.println(" return true;");
+ } else {
+ output.println(" return false;");
+ }
+ output.println(" }");
+ }
+
+ /**
+ * Emits all of the isGL* methods.
+ */
+ protected void emitGLIsMethods(PrintWriter output) {
+ emitGLIsMethod(output, "GL");
+ emitGLIsMethod(output, "GL3");
+ emitGLIsMethod(output, "GL2");
+ emitGLIsMethod(output, "GLES1");
+ emitGLIsMethod(output, "GLES2");
+ emitGLIsMethod(output, "GL2ES1");
+ emitGLIsMethod(output, "GL2ES2");
+ output.println(" public boolean isGLES() {");
+ output.println(" return isGLES2() || isGLES1();");
+ output.println(" }");
+ }
+ /**
+ * Emits one of the getGL* methods.
+ */
+ protected void emitGLGetMethod(PrintWriter output, String type) {
+ output.println(" public javax.media.opengl." + type + " get" + type + "() {");
+ Class clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
+ if (clazz.isAssignableFrom(baseInterfaceClass)) {
+ output.println(" return this;");
+ } else {
+ output.println(" throw new GLException(\"Not a " + type + " implementation\");");
+ }
+ output.println(" }");
+ }
+
+ /**
+ * Emits all of the getGL* methods.
+ */
+ protected void emitGLGetMethods(PrintWriter output) {
+ emitGLGetMethod(output, "GL");
+ emitGLGetMethod(output, "GL3");
+ emitGLGetMethod(output, "GL2");
+ emitGLGetMethod(output, "GLES1");
+ emitGLGetMethod(output, "GLES2");
+ emitGLGetMethod(output, "GL2ES1");
+ emitGLGetMethod(output, "GL2ES2");
+ output.println(" public GLProfile getGLProfile() {");
+ output.println(" return "+getDownstreamObjectName()+".getGLProfile();");
+ output.println(" }");
+ }
+ } // end class PipelineEmitter
+
+ //-------------------------------------------------------
+
+ protected class CustomPipeline extends PipelineEmitter
+ {
+ String className;
+ int mode;
+
+ public CustomPipeline(int mode, String outputDir, String outputPackage, String outputName, Class baseInterfaceClass, Class prologClassOpt, Class downstreamClass)
+ {
+ super(outputDir, outputPackage, baseInterfaceClass, prologClassOpt, downstreamClass);
+ className = outputName;
+ this.mode = mode;
+ }
+
+ protected String getOutputName()
+ {
+ return className;
+ }
+
+ protected int getMode() { return mode; }
+
+ protected boolean emptyMethodAllowed() {
+ return true;
+ }
+ protected boolean emptyDownstreamAllowed() {
+ return true;
+ }
+
+ protected void preMethodEmissionHook(PrintWriter output)
+ {
+ super.preMethodEmissionHook(output);
+ }
+
+ protected void constructorHook(PrintWriter output) {
+ output.print( " public " + getOutputName() + "(" );
+ output.print( downstreamName + " " + getDownstreamObjectName() );
+ if(null!=prologNameOpt) {
+ output.println( ", " + prologNameOpt + " " + getPrologObjectNameOpt() + ")");
+ } else {
+ output.println(")");
+ }
+ output.println(" {");
+ output.println(" if (" + getDownstreamObjectName() + " == null) {");
+ output.println(" throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
+ output.println(" }");
+ output.print( " this." + getDownstreamObjectName());
+ output.println(" = " + getDownstreamObjectName() + ";");
+ if(null!=prologNameOpt) {
+ output.print( " this." + getPrologObjectNameOpt());
+ output.println(" = " + getPrologObjectNameOpt() + ";");
+ }
+ output.println(" }");
+ output.println();
+ }
+
+ protected void postMethodEmissionHook(PrintWriter output)
+ {
+ super.postMethodEmissionHook(output);
+ if(null!=prologNameOpt) {
+ output.print(" private " + prologNameOpt + " " + getPrologObjectNameOpt() + ";");
+ }
+ }
+
+ protected void emitClassDocComment(PrintWriter output)
+ {
+ output.println("/**");
+ output.println(" * Composable pipeline {@link "+outputPackage+"."+outputName+"}, implementing the interface");
+ output.println(" * {@link "+baseInterfaceClass.getName()+"}");
+ output.println(" * <p>");
+ output.println(" * Each method follows the call graph <ul>");
+ if(null!=prologClassOpt) {
+ output.println(" * <li> call <em>prolog</em> {@link "+prologClassOpt.getName()+"} if available");
+ }
+ output.println(" * <li> call <em>downstream</em> {@link "+downstreamClass.getName()+"} if available");
+ if(null!=prologClassOpt && 0!=(GEN_PROLOG_XOR_DOWNSTREAM&getMode())) {
+ output.println(" * <strong>and</strong> if no call to {@link "+prologClassOpt.getName()+"} is made");
+ }
+ output.println(" * </ul><p>");
+ output.println(" * ");
+ output.println(" * <ul>");
+ output.println(" * <li> <em>Interface</em> {@link "+baseInterfaceClass.getName()+"}");
+ if(null!=prologClassOpt) {
+ output.println(" * <li> <em>Prolog</em> {@link "+prologClassOpt.getName()+"}");
+ }
+ output.println(" * <li> <em>Downstream</em> {@link "+downstreamClass.getName()+"}");
+ output.println(" * </ul><p>");
+ output.println(" * Sample code which installs this pipeline: </P>");
+ output.println(" * ");
+ output.println("<PRE>");
+ if(null!=prologNameOpt) {
+ output.println(" drawable.setGL( new "+className+"( drawable.getGL().getGL2ES2(), new "+prologNameOpt+"( drawable.getGL().getGL2ES2() ) ) );");
+ } else {
+ output.println(" drawable.setGL( new "+className+"( drawable.getGL().getGL2ES2() ) );");
+ }
+ output.println("</PRE>");
+ output.println("*/");
+ }
+
+ protected boolean hasPreDownstreamCallHook(Method m) {
+ return null!=getMethod(prologClassOpt, m);
+ }
+
+ protected void preDownstreamCallHook(PrintWriter output, Method m)
+ {
+ if(null!=prologNameOpt) {
+ output.print(getPrologObjectNameOpt());
+ output.print('.');
+ output.print(m.getName());
+ output.print('(');
+ output.print(getArgListAsString(m, false, true));
+ output.println(");");
+ }
+ }
+
+ protected boolean hasPostDownstreamCallHook(Method m) {
+ return false;
+ }
+
+ protected void postDownstreamCallHook(PrintWriter output, Method m)
+ {
+ }
+
+ } // end class CustomPipeline
+
+ protected class DebugPipeline extends PipelineEmitter
+ {
+ String className;
+ public DebugPipeline(String outputDir, String outputPackage, Class baseInterfaceClass, Class downstreamClass)
+ {
+ super(outputDir, outputPackage, baseInterfaceClass, null, downstreamClass);
+ className = "Debug" + getBaseInterfaceName();
+ }
+
+ protected String getOutputName()
+ {
+ return className;
+ }
+
+ protected int getMode() { return 0; }
+
+ protected boolean emptyMethodAllowed() {
+ return false;
+ }
+ protected boolean emptyDownstreamAllowed() {
+ return false;
+ }
+
+ protected void preMethodEmissionHook(PrintWriter output)
+ {
+ super.preMethodEmissionHook(output);
+ }
+
+ protected void constructorHook(PrintWriter output) {
+ output.print( " public " + getOutputName() + "(" );
+ output.println( downstreamName + " " + getDownstreamObjectName() + ")");
+ output.println(" {");
+ output.println(" if (" + getDownstreamObjectName() + " == null) {");
+ output.println(" throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
+ output.println(" }");
+ output.print( " this." + getDownstreamObjectName());
+ output.println(" = " + getDownstreamObjectName() + ";");
+ if(null!=prologNameOpt) {
+ output.print( " this." + getPrologObjectNameOpt());
+ output.println(" = " + getPrologObjectNameOpt() + ";");
+ }
+ output.println(" // Fetch GLContext object for better error checking (if possible)");
+ output.println(" _context = " + getDownstreamObjectName() + ".getContext();");
+ output.println(" }");
+ output.println();
+ }
+
+ protected void postMethodEmissionHook(PrintWriter output)
+ {
+ super.postMethodEmissionHook(output);
+ output.println(" private void checkGLGetError(String caller)");
+ output.println(" {");
+ if (hasImmediateMode) {
+ output.println(" if (insideBeginEndPair) {");
+ output.println(" return;");
+ output.println(" }");
+ output.println();
+ }
+ output.println(" // Debug code to make sure the pipeline is working; leave commented out unless testing this class");
+ output.println(" //System.err.println(\"Checking for GL errors " +
+ "after call to \" + caller);");
+ output.println();
+ output.println(" int err = " +
+ getDownstreamObjectName() +
+ ".glGetError();");
+ output.println(" if (err == GL_NO_ERROR) { return; }");
+ output.println();
+ output.println(" StringBuffer buf = new StringBuffer(Thread.currentThread()+");
+ output.println(" \" glGetError() returned the following error codes " +
+ "after a call to \" + caller + \": \");");
+ output.println();
+ output.println(" // Loop repeatedly to allow for distributed GL implementations,");
+ output.println(" // as detailed in the glGetError() specification");
+ output.println(" int recursionDepth = 10;");
+ output.println(" do {");
+ output.println(" switch (err) {");
+ output.println(" case GL_INVALID_ENUM: buf.append(\"GL_INVALID_ENUM \"); break;");
+ output.println(" case GL_INVALID_VALUE: buf.append(\"GL_INVALID_VALUE \"); break;");
+ output.println(" case GL_INVALID_OPERATION: buf.append(\"GL_INVALID_OPERATION \"); break;");
+ if (hasStackOverflow) {
+ output.println(" case GL_STACK_OVERFLOW: buf.append(\"GL_STACK_OVERFLOW \"); break;");
+ output.println(" case GL_STACK_UNDERFLOW: buf.append(\"GL_STACK_UNDERFLOW \"); break;");
+ }
+ output.println(" case GL_OUT_OF_MEMORY: buf.append(\"GL_OUT_OF_MEMORY \"); break;");
+ output.println(" case GL_NO_ERROR: throw new InternalError(\"Should not be treating GL_NO_ERROR as error\");");
+ output.println(" default: buf.append(\"Unknown glGetError() return value: \");");
+ output.println(" }");
+ output.println(" buf.append(\"( \" + err + \" 0x\"+Integer.toHexString(err).toUpperCase() + \"), \");");
+ output.println(" } while ((--recursionDepth >= 0) && (err = " +
+ getDownstreamObjectName() +
+ ".glGetError()) != GL_NO_ERROR);");
+ output.println(" throw new GLException(buf.toString());");
+ output.println(" }");
+ if (hasImmediateMode) {
+ output.println(" /** True if the pipeline is inside a glBegin/glEnd pair.*/");
+ output.println(" private boolean insideBeginEndPair = false;");
+ output.println();
+ }
+ output.println(" private void checkContext() {");
+ output.println(" GLContext currentContext = GLContext.getCurrent();");
+ output.println(" if (currentContext == null) {");
+ output.println(" throw new GLException(\"No OpenGL context is current on this thread\");");
+ output.println(" }");
+ output.println(" if ((_context != null) && (_context != currentContext)) {");
+ output.println(" throw new GLException(\"This GL object is being incorrectly used with a different GLContext than that which created it\");");
+ output.println(" }");
+ output.println(" }");
+ output.println(" private GLContext _context;");
+ }
+
+ protected void emitClassDocComment(PrintWriter output)
+ {
+ output.println("/** <P> Composable pipeline which wraps an underlying {@link GL} implementation,");
+ output.println(" providing error checking after each OpenGL method call. If an error occurs,");
+ output.println(" causes a {@link GLException} to be thrown at exactly the point of failure.");
+ output.println(" Sample code which installs this pipeline: </P>");
+ output.println();
+ output.println("<PRE>");
+ output.println(" drawable.setGL(new DebugGL(drawable.getGL()));");
+ output.println("</PRE>");
+ output.println("*/");
+ }
+
+ protected boolean hasPreDownstreamCallHook(Method m) {
+ return true;
+ }
+
+ protected void preDownstreamCallHook(PrintWriter output, Method m)
+ {
+ output.println(" checkContext();");
+ }
+
+ protected boolean hasPostDownstreamCallHook(Method m) {
+ return true;
+ }
+
+ protected void postDownstreamCallHook(PrintWriter output, Method m)
+ {
+ if (m.getName().equals("glBegin"))
+ {
+ output.println(" insideBeginEndPair = true;");
+ output.println(" // NOTE: can't check glGetError(); it's not allowed inside glBegin/glEnd pair");
+ }
+ else
+ {
+ if (m.getName().equals("glEnd"))
+ {
+ output.println(" insideBeginEndPair = false;");
+ }
+
+ output.println(" String txt = new String(\""+ m.getName() + "(\" +");
+ Class[] params = m.getParameterTypes() ;
+ for(int i=0; params!=null && i<params.length; i++) {
+ if(params[i].equals(int.class)) {
+ output.println(" \"<"+params[i].getName()+"> 0x\"+Integer.toHexString(arg"+i+").toUpperCase() +");
+ } else {
+ output.println(" \"<"+params[i].getName()+">\" +");
+ }
+ if(i<params.length-1) {
+ output.println(" \", \" +");
+ }
+ }
+ output.println(" \")\");");
+ // calls to glGetError() are only allowed outside of glBegin/glEnd pairs
+ output.println(" checkGLGetError( txt );");
+ }
+ }
+
+ } // end class DebugPipeline
+
+ //-------------------------------------------------------
+
+ protected class TracePipeline extends PipelineEmitter
+ {
+ String className;
+ public TracePipeline(String outputDir, String outputPackage, Class baseInterfaceClass, Class downstreamClass)
+ {
+ super(outputDir, outputPackage, baseInterfaceClass, null, downstreamClass);
+ className = "Trace" + getBaseInterfaceName();
+ }
+
+ protected String getOutputName()
+ {
+ return className;
+ }
+
+ protected int getMode() { return 0; }
+
+ protected boolean emptyMethodAllowed() {
+ return false;
+ }
+ protected boolean emptyDownstreamAllowed() {
+ return false;
+ }
+
+ protected void preMethodEmissionHook(PrintWriter output)
+ {
+ super.preMethodEmissionHook(output);
+ }
+
+ protected void constructorHook(PrintWriter output) {
+ output.print( " public " + getOutputName() + "(" );
+ output.println( downstreamName + " " + getDownstreamObjectName() + ", PrintStream " + getOutputStreamName() + ")");
+ output.println(" {");
+ output.println(" if (" + getDownstreamObjectName() + " == null) {");
+ output.println(" throw new IllegalArgumentException(\"null " + getDownstreamObjectName() + "\");");
+ output.println(" }");
+ output.print( " this." + getDownstreamObjectName());
+ output.println(" = " + getDownstreamObjectName() + ";");
+ output.print( " this." + getOutputStreamName());
+ output.println(" = " + getOutputStreamName() + ";");
+ output.println(" }");
+ output.println();
+ }
+
+ protected void postMethodEmissionHook(PrintWriter output)
+ {
+ super.postMethodEmissionHook(output);
+ output.println("private PrintStream " + getOutputStreamName() + ";");
+ output.println("private int indent = 0;");
+ output.println("protected String dumpArray(Object obj)");
+ output.println("{");
+ output.println(" if (obj == null) return \"[null]\";");
+ output.println(" StringBuffer sb = new StringBuffer(\"[\");");
+ output.println(" int len = java.lang.reflect.Array.getLength(obj);");
+ output.println(" int count = Math.min(len,16);");
+ output.println(" for ( int i =0; i < count; i++ ) {");
+ output.println(" sb.append(java.lang.reflect.Array.get(obj,i));");
+ output.println(" if (i < count-1)");
+ output.println(" sb.append(',');");
+ output.println(" }");
+ output.println(" if ( len > 16 )");
+ output.println(" sb.append(\"...\").append(len);");
+ output.println(" sb.append(']');");
+ output.println(" return sb.toString();");
+ output.println("}");
+ output.println("protected void print(String str)");
+ output.println("{");
+ output.println(" "+getOutputStreamName()+".print(str);");
+ output.println("}");
+ output.println("protected void println(String str)");
+ output.println("{");
+ output.println(" "+getOutputStreamName()+".println(str);");
+ output.println("}");
+ output.println("protected void printIndent()");
+ output.println("{");
+ output.println(" for( int i =0; i < indent; i++) {"+getOutputStreamName()+".print(' ');}");
+ output.println("}");
+ }
+ protected void emitClassDocComment(PrintWriter output)
+ {
+ output.println("/** <P> Composable pipeline which wraps an underlying {@link GL} implementation,");
+ output.println(" providing tracing information to a user-specified {@link java.io.PrintStream}");
+ output.println(" before and after each OpenGL method call. Sample code which installs this pipeline: </P>");
+ output.println();
+ output.println("<PRE>");
+ output.println(" drawable.setGL(new TraceGL(drawable.getGL(), System.err));");
+ output.println("</PRE>");
+ output.println("*/");
+ }
+
+ protected boolean hasPreDownstreamCallHook(Method m) {
+ return true;
+ }
+
+ protected void preDownstreamCallHook(PrintWriter output, Method m)
+ {
+ if ( m.getName().equals("glEnd") || m.getName().equals("glEndList"))
+ {
+ output.println("indent-=2;");
+ output.println(" printIndent();");
+ }
+ else
+ {
+ output.println("printIndent();");
+ }
+
+ output.print(" println(");
+ printFunctionCallString(output, m);
+ output.println(");");
+ }
+
+ protected boolean hasPostDownstreamCallHook(Method m) {
+ return true;
+ }
+
+ protected void postDownstreamCallHook(PrintWriter output, Method m)
+ {
+ Class ret = m.getReturnType();
+ if ( ret != Void.TYPE )
+ {
+ output.println(" println(\" = \"+_res);");
+ }
+ else
+ {
+ output.println(" println(\"\");");
+ }
+ }
+
+ private String getOutputStreamName() {
+ return "stream";
+ }
+
+ } // end class TracePipeline
+
+ public static final void printFunctionCallString(PrintWriter output, Method m) {
+ Class[] params = m.getParameterTypes();
+ output.print(" \"" + m.getName() + "(\"");
+ for ( int i =0; i < params.length; i++ )
+ {
+ if ( params[i].isArray() ) {
+ output.print("+\"<"+params[i].getName()+">\"");
+ } else if(params[i].equals(int.class)) {
+ output.print("+\"<"+params[i].getName()+"> 0x\"+Integer.toHexString(arg"+i+").toUpperCase()");
+ } else {
+ output.print("+\"<"+params[i].getName()+">\"+arg"+i);
+ }
+ if ( i < params.length-1) {
+ output.print("+\",\"");
+ }
+ }
+ output.print("+\")\"");
+ }
+}
diff --git a/src/java/com/sun/gluegen/opengl/BuildStaticGLInfo.java b/src/java/com/sun/gluegen/opengl/BuildStaticGLInfo.java
new file mode 100644
index 000000000..4226f4612
--- /dev/null
+++ b/src/java/com/sun/gluegen/opengl/BuildStaticGLInfo.java
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) 2003 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.
+ *
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.gluegen.opengl;
+
+import java.io.*;
+import java.util.*;
+import java.util.regex.*;
+
+ /**
+ * Builds the StaticGLInfo class from the OpenGL header files (i.e., gl.h
+ * and glext.h) whose paths were passed as arguments to {@link
+ * #main(String[])}.
+ *
+ * It relies upon the assumption that a function's membership is scoped by
+ * preprocessor blocks in the header files that match the following pattern:
+ * <br>
+ *
+ * <pre>
+ *
+ * #ifndef GL_XXXX
+ * GLAPI <returnType> <APIENTRY|GLAPIENTRY> glFuncName(<params>)
+ * #endif GL_XXXX
+ *
+ * </pre>
+ *
+ * For example, if it parses the following data:
+ *
+ * <pre>
+ *
+ * #ifndef GL_VERSION_1_3
+ * GLAPI void APIENTRY glActiveTexture (GLenum);
+ * GLAPI void APIENTRY glMultiTexCoord1dv (GLenum, const GLdouble *);
+ * GLAPI void <APIENTRY|GLAPIENTRY> glFuncName(<params>)
+ * #endif GL_VERSION_1_3
+ *
+ * #ifndef GL_ARB_texture_compression
+ * GLAPI void APIENTRY glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+ * GLAPI void APIENTRY glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+ * #endif
+ *
+ * </pre>
+ *
+ * It will associate
+ * <code> glActiveTexture </code> and
+ * <code> glMultiTexCoord1dv </code>
+ * with the symbol
+ * <code> GL_VERSION_1_3 </code>,
+ * and associate
+ * <code> glCompressedTexImage2DARB </code> and
+ * <code> glCompressedTexImage3DARB </code>
+ * with the symbol
+ * <code> GL_ARB_texture_compression </code>.
+ * */
+public class BuildStaticGLInfo
+{
+ // Handles function pointer
+ protected static Pattern funcPattern =
+ Pattern.compile("^(GLAPI|GL_API|GL_APICALL|EGLAPI|extern)?(\\s*)(\\w+)(\\*)?(\\s+)(GLAPIENTRY|GL_APIENTRY|APIENTRY|EGLAPIENTRY|WINAPI)?(\\s*)([ew]?gl\\w+)\\s?(\\(.*)");
+ protected static Pattern associationPattern =
+ Pattern.compile("\\#ifndef ([EW]?GL[X]?_[A-Za-z0-9_]+)");
+ protected static Pattern definePattern =
+ Pattern.compile("\\#define ([EW]?GL[X]?_[A-Za-z0-9_]+)\\s*([A-Za-z0-9_]+)");
+ // Maps function / #define names to the names of the extensions they're declared in
+ protected Map declarationToExtensionMap = new HashMap();
+ // Maps extension names to Set of identifiers (both #defines and
+ // function names) this extension declares
+ protected Map/*<String, Set<String>*/ extensionToDeclarationMap = new HashMap();
+
+ /**
+ * The first argument is the package to which the StaticGLInfo class
+ * belongs, the second is the path to the directory in which that package's
+ * classes reside, and the remaining arguments are paths to the C header
+ * files that should be parsed
+ */
+ public static void main(String[] args) throws IOException
+ {
+ if (args.length > 0 && args[0].equals("-test")) {
+ BuildStaticGLInfo builder = new BuildStaticGLInfo();
+ String[] newArgs = new String[args.length - 1];
+ System.arraycopy(args, 1, newArgs, 0, args.length - 1);
+ builder.parse(newArgs);
+ builder.dump();
+ System.exit(0);
+ }
+
+ String packageName = args[0];
+ String packageDir = args[1];
+
+ String[] cHeaderFilePaths = new String[args.length-2];
+ System.arraycopy(args, 2, cHeaderFilePaths, 0, cHeaderFilePaths.length);
+
+ BuildStaticGLInfo builder = new BuildStaticGLInfo();
+ try {
+ builder.parse(cHeaderFilePaths);
+
+ File file = new File(packageDir + File.separatorChar + "StaticGLInfo.java");
+ String parentDir = file.getParent();
+ if (parentDir != null) {
+ File pDirFile = new File(parentDir);
+ pDirFile.mkdirs();
+ }
+
+ PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(file)));
+ builder.emitJavaCode(writer, packageName);
+
+ writer.flush();
+ writer.close();
+ }
+ catch (Exception e)
+ {
+ StringBuffer buf = new StringBuffer("{ ");
+ for (int i = 0; i < cHeaderFilePaths.length; ++i)
+ {
+ buf.append(cHeaderFilePaths[i]);
+ buf.append(" ");
+ }
+ buf.append('}');
+ throw new RuntimeException(
+ "Error building StaticGLInfo.java from " + buf.toString(), e);
+ }
+ }
+
+
+ /** Parses the supplied C header files and adds the function
+ associations contained therein to the internal map. */
+ public void parse(String[] cHeaderFilePaths) throws IOException {
+ for (int i = 0; i < cHeaderFilePaths.length; i++) {
+ parse(cHeaderFilePaths[i]);
+ }
+ }
+
+ /** Parses the supplied C header file and adds the function
+ associations contained therein to the internal map. */
+ public void parse(String cHeaderFilePath) throws IOException {
+ BufferedReader reader = new BufferedReader(new FileReader(cHeaderFilePath));
+ String line, activeAssociation = null;
+ Matcher m = null;
+ while ((line = reader.readLine()) != null) {
+ // see if we're inside a #ifndef GL_XXX block and matching a function
+ if (activeAssociation != null) {
+ String identifier = null;
+ if ((m = funcPattern.matcher(line)).matches()) {
+ identifier = m.group(8);
+ } else if ((m = definePattern.matcher(line)).matches()) {
+ identifier = m.group(1);
+ } else if (line.startsWith("#endif")) {
+ activeAssociation = null;
+ }
+ if ((identifier != null) &&
+ (activeAssociation != null) &&
+ // Handles #ifndef GL_... #define GL_...
+ !identifier.equals(activeAssociation)) {
+ addAssociation(identifier, activeAssociation);
+ // System.err.println(" ADDING ASSOCIATION: " + identifier + " " + activeAssociation);
+ }
+ } else if ((m = associationPattern.matcher(line)).matches()) {
+ // found a new #ifndef GL_XXX block
+ activeAssociation = m.group(1);
+
+ // System.err.println("FOUND NEW ASSOCIATION BLOCK: " + activeAssociation);
+ }
+ }
+ reader.close();
+ }
+
+ public void dump() {
+ for (Iterator i1 = extensionToDeclarationMap.keySet().iterator(); i1.hasNext(); ) {
+ String name = (String) i1.next();
+ Set decls = (Set) extensionToDeclarationMap.get(name);
+ System.out.println(name + ":");
+ List l = new ArrayList();
+ l.addAll(decls);
+ Collections.sort(l);
+ for (Iterator i2 = l.iterator(); i2.hasNext(); ) {
+ System.out.println(" " + (String) i2.next());
+ }
+ }
+ }
+
+ public String getExtension(String identifier) {
+ return (String) declarationToExtensionMap.get(identifier);
+ }
+
+ public Set/*<String>*/ getDeclarations(String extension) {
+ return (Set) extensionToDeclarationMap.get(extension);
+ }
+
+ public Set/*<String>*/ getExtensions() {
+ return extensionToDeclarationMap.keySet();
+ }
+
+ public void emitJavaCode(PrintWriter output, String packageName) {
+ output.println("package " + packageName + ";");
+ output.println();
+ output.println("import java.util.*;");
+ output.println();
+ output.println("public final class StaticGLInfo");
+ output.println("{");
+
+ output.println(" // maps function names to the extension string or OpenGL");
+ output.println(" // specification version string to which they correspond.");
+ output.println(" private static HashMap funcToAssocMap;");
+ output.println();
+
+ output.println(" /**");
+ output.println(" * Returns the OpenGL extension string or GL_VERSION string with which the");
+ output.println(" * given function is associated. <P>");
+ output.println(" *");
+ output.println(" * If the");
+ output.println(" * function is part of the OpenGL core, the returned value will be");
+ output.println(" * GL_VERSION_XXX where XXX represents the OpenGL version of which the");
+ output.println(" * function is a member (XXX will be of the form \"A\" or \"A_B\" or \"A_B_C\";");
+ output.println(" * e.g., GL_VERSION_1_2_1 for OpenGL version 1.2.1).");
+ output.println(" *");
+ output.println(" * If the function is an extension function, the returned value will the");
+ output.println(" * OpenGL extension string for the extension to which the function");
+ output.println(" * corresponds. For example, if glLoadTransposeMatrixfARB is the argument,");
+ output.println(" * GL_ARB_transpose_matrix will be the value returned.");
+ output.println(" * Please see http://oss.sgi.com/projects/ogl-sample/registry/index.html for");
+ output.println(" * a list of extension names and the functions they expose.");
+ output.println(" *");
+ output.println(" * If the function specified is not part of any known OpenGL core version or");
+ output.println(" * extension, then NULL will be returned.");
+ output.println(" */");
+ output.println(" public static String getFunctionAssociation(String glFunctionName)");
+ output.println(" {");
+ output.println(" String mappedName = null;");
+ output.println(" int funcNamePermNum = com.sun.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutationNumber(glFunctionName);");
+ output.println(" for(int i = 0; null==mappedName && i < funcNamePermNum; i++) {");
+ output.println(" String tmp = com.sun.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutation(glFunctionName, i);");
+ output.println(" try {");
+ output.println(" mappedName = (String)funcToAssocMap.get(tmp);");
+ output.println(" } catch (Exception e) { }");
+ output.println(" }");
+ output.println(" return mappedName;");
+ output.println(" }");
+ output.println();
+
+ output.println(" static");
+ output.println(" {");
+
+ // Compute max capacity
+ int maxCapacity = 0;
+ for (Iterator iter = declarationToExtensionMap.keySet().iterator(); iter.hasNext(); ) {
+ String name = (String) iter.next();
+ if (!name.startsWith("GL")) {
+ ++maxCapacity;
+ }
+ }
+
+ output.println(" funcToAssocMap = new HashMap(" + maxCapacity + "); // approximate max capacity");
+ output.println(" String group;");
+ ArrayList sets = new ArrayList(extensionToDeclarationMap.keySet());
+ Collections.sort(sets);
+ for (Iterator iter = sets.iterator(); iter.hasNext(); ) {
+ String groupName = (String) iter.next();
+ Set funcs = (Set) extensionToDeclarationMap.get(groupName);
+ List l = new ArrayList();
+ l.addAll(funcs);
+ Collections.sort(l);
+ Iterator funcIter = l.iterator();
+ boolean printedHeader = false;
+ while (funcIter.hasNext()) {
+ String funcName = (String)funcIter.next();
+ if (!funcName.startsWith("GL")) {
+ if (!printedHeader) {
+ output.println();
+ output.println(" //----------------------------------------------------------------");
+ output.println(" // " + groupName);
+ output.println(" //----------------------------------------------------------------");
+ output.println(" group = \"" + groupName + "\";");
+ printedHeader = true;
+ }
+
+ output.println(" funcToAssocMap.put(\"" + funcName + "\", group);");
+ }
+ }
+ }
+ output.println(" }");
+ output.println("} // end class StaticGLInfo");
+ }
+
+ //----------------------------------------------------------------------
+ // Internals only below this point
+ //
+
+ protected void addAssociation(String identifier, String association) {
+ declarationToExtensionMap.put(identifier, association);
+ Set/*<String>*/ identifiers = (Set) extensionToDeclarationMap.get(association);
+ if (identifiers == null) {
+ identifiers = new HashSet/*<String>*/();
+ extensionToDeclarationMap.put(association, identifiers);
+ }
+ identifiers.add(identifier);
+ }
+}
diff --git a/src/java/com/sun/gluegen/opengl/GLConfiguration.java b/src/java/com/sun/gluegen/opengl/GLConfiguration.java
new file mode 100755
index 000000000..3013848dc
--- /dev/null
+++ b/src/java/com/sun/gluegen/opengl/GLConfiguration.java
@@ -0,0 +1,297 @@
+/*
+ * 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.
+ *
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.gluegen.opengl;
+
+import java.io.*;
+import java.util.*;
+
+import com.sun.gluegen.*;
+import com.sun.gluegen.procaddress.*;
+import com.sun.gluegen.runtime.opengl.GLExtensionNames;
+
+public class GLConfiguration extends ProcAddressConfiguration {
+ // The following data members support ignoring an entire extension at a time
+ private List/*<String>*/ glHeaders = new ArrayList();
+ private Set/*<String>*/ ignoredExtensions = new HashSet();
+ private Set/*<String>*/ extensionsRenamedIntoCore = new HashSet();
+ private BuildStaticGLInfo glInfo;
+ // Maps function names to the kind of buffer object it deals with
+ private Map/*<String,GLEmitter.BufferObjectKind>*/ bufferObjectKinds = new HashMap();
+ private GLEmitter emitter;
+ private Set/*String*/ dropUniqVendorExtensions = new HashSet();
+ // This directive is off by default but can help automatically
+ // indicate which extensions have been folded into the core OpenGL
+ // namespace, and if not, then why not
+ private boolean autoUnifyExtensions;
+
+ public GLConfiguration(GLEmitter emitter) {
+ super();
+ this.emitter = emitter;
+ try {
+ setProcAddressNameExpr("PFN $UPPERCASE({0}) PROC");
+ } catch (NoSuchElementException e) {
+ throw new RuntimeException("Error configuring ProcAddressNameExpr", e);
+ }
+ }
+
+ protected void dispatch(String cmd, StringTokenizer tok, File file, String filename, int lineNo) throws IOException {
+ if (cmd.equalsIgnoreCase("IgnoreExtension"))
+ {
+ String sym = readString("IgnoreExtension", tok, filename, lineNo);
+ ignoredExtensions.add(sym);
+ }
+ else if (cmd.equalsIgnoreCase("RenameExtensionIntoCore"))
+ {
+ String sym = readString("RenameExtensionIntoCore", tok, filename, lineNo);
+ extensionsRenamedIntoCore.add(sym);
+ }
+ else if (cmd.equalsIgnoreCase("AutoUnifyExtensions"))
+ {
+ autoUnifyExtensions = readBoolean("AutoUnifyExtensions", tok, filename, lineNo).booleanValue();
+ }
+ else if (cmd.equalsIgnoreCase("GLHeader"))
+ {
+ String sym = readString("GLHeader", tok, filename, lineNo);
+ glHeaders.add(sym);
+ }
+ else if (cmd.equalsIgnoreCase("BufferObjectKind"))
+ {
+ readBufferObjectKind(tok, filename, lineNo);
+ }
+ else if (cmd.equalsIgnoreCase("DropUniqVendorExtensions"))
+ {
+ String sym = readString("DropUniqVendorExtensions", tok, filename, lineNo);
+ dropUniqVendorExtensions.add(sym);
+ }
+ else
+ {
+ super.dispatch(cmd,tok,file,filename,lineNo);
+ }
+ }
+
+ protected void readBufferObjectKind(StringTokenizer tok, String filename, int lineNo) {
+ try {
+ String kindString = tok.nextToken();
+ GLEmitter.BufferObjectKind kind = null;
+ String target = tok.nextToken();
+ if (kindString.equalsIgnoreCase("UnpackPixel")) {
+ kind = GLEmitter.BufferObjectKind.UNPACK_PIXEL;
+ } else if (kindString.equalsIgnoreCase("PackPixel")) {
+ kind = GLEmitter.BufferObjectKind.PACK_PIXEL;
+ } else if (kindString.equalsIgnoreCase("Array")) {
+ kind = GLEmitter.BufferObjectKind.ARRAY;
+ } else if (kindString.equalsIgnoreCase("Element")) {
+ kind = GLEmitter.BufferObjectKind.ELEMENT;
+ } else {
+ throw new RuntimeException("Error parsing \"BufferObjectKind\" command at line " + lineNo +
+ " in file \"" + filename + "\": illegal BufferObjectKind \"" +
+ kindString + "\", expected one of UnpackPixel, PackPixel, Array, or Element");
+ }
+
+ bufferObjectKinds.put(target, kind);
+ } catch (NoSuchElementException e) {
+ throw new RuntimeException("Error parsing \"BufferObjectKind\" command at line " + lineNo +
+ " in file \"" + filename + "\"", e);
+ }
+ }
+
+ /** Overrides javaPrologueForMethod in superclass and
+ automatically generates prologue code for functions associated
+ with buffer objects. */
+ public List/*<String>*/ javaPrologueForMethod(MethodBinding binding,
+ boolean forImplementingMethodCall,
+ boolean eraseBufferAndArrayTypes) {
+ List/*<String>*/ res = super.javaPrologueForMethod(binding,
+ forImplementingMethodCall,
+ eraseBufferAndArrayTypes);
+ GLEmitter.BufferObjectKind kind = getBufferObjectKind(binding.getName());
+ if (kind != null) {
+ // Need to generate appropriate prologue based on both buffer
+ // object kind and whether this variant of the MethodBinding
+ // is the one accepting a "long" as argument
+ //
+ // NOTE we MUST NOT mutate the array returned from the super
+ // call!
+ ArrayList res2 = new ArrayList();
+ if (res != null) {
+ res2.addAll(res);
+ }
+ res = res2;
+
+ String prologue = "check";
+
+ if (kind == GLEmitter.BufferObjectKind.UNPACK_PIXEL) {
+ prologue = prologue + "UnpackPBO";
+ } else if (kind == GLEmitter.BufferObjectKind.PACK_PIXEL) {
+ prologue = prologue + "PackPBO";
+ } else if (kind == GLEmitter.BufferObjectKind.ARRAY) {
+ prologue = prologue + "ArrayVBO";
+ } else if (kind == GLEmitter.BufferObjectKind.ELEMENT) {
+ prologue = prologue + "ElementVBO";
+ } else {
+ throw new RuntimeException("Unknown BufferObjectKind " + kind);
+ }
+
+ if (emitter.isBufferObjectMethodBinding(binding)) {
+ prologue = prologue + "Enabled";
+ } else {
+ prologue = prologue + "Disabled";
+ }
+
+ prologue = prologue + "(true);";
+
+ res.add(0, prologue);
+
+ // Must also filter out bogus rangeCheck directives for VBO/PBO
+ // variants
+ if (emitter.isBufferObjectMethodBinding(binding)) {
+ for (Iterator iter = res.iterator(); iter.hasNext(); ) {
+ String line = (String) iter.next();
+ if (line.indexOf("BufferFactory.rangeCheck") >= 0) {
+ iter.remove();
+ }
+ }
+ }
+ }
+
+ return res;
+ }
+
+ public void dumpIgnores() {
+ System.err.println("GL Ignored extensions: ");
+ for (Iterator iter = ignoredExtensions.iterator(); iter.hasNext(); ) {
+ System.err.println("\t"+(String)iter.next());
+ }
+ super.dumpIgnores();
+ }
+
+ protected boolean shouldIgnoreExtension(String symbol, boolean criteria) {
+ if (criteria && glInfo != null) {
+ String extension = glInfo.getExtension(symbol);
+ if (extension != null &&
+ ignoredExtensions.contains(extension)) {
+ return true;
+ }
+ boolean isGLFunc = GLExtensionNames.isGLFunction(symbol);
+ boolean isGLEnum = GLExtensionNames.isGLEnumeration(symbol);
+ if(isGLFunc || isGLEnum) {
+ if(GLExtensionNames.isExtensionVEN(symbol, isGLFunc)) {
+ String extSuffix = GLExtensionNames.getExtensionSuffix(symbol, isGLFunc);
+ if( getDropUniqVendorExtensions(extSuffix) ) {
+ if(DEBUG_IGNORES) {
+ System.err.println("Ignore UniqVendorEXT: "+symbol);
+ }
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ public boolean shouldIgnoreInInterface(String symbol) {
+ return shouldIgnoreInInterface(symbol, true);
+ }
+
+ public boolean shouldIgnoreInInterface(String symbol, boolean checkEXT) {
+ return shouldIgnoreExtension(symbol, checkEXT) || super.shouldIgnoreInInterface(symbol);
+ }
+
+ public boolean shouldIgnoreInImpl(String symbol) {
+ return shouldIgnoreInImpl(symbol, true);
+ }
+
+ public boolean shouldIgnoreInImpl(String symbol, boolean checkEXT) {
+ return shouldIgnoreExtension(symbol, checkEXT) || super.shouldIgnoreInImpl(symbol);
+ }
+
+ /** Should we automatically ignore extensions that have already been
+ fully subsumed into the OpenGL core namespace, and if they have
+ not been, indicate which definition is not already in the core? */
+ public boolean getAutoUnifyExtensions() {
+ return autoUnifyExtensions;
+ }
+
+ /** shall the non unified (uniq) vendor extensions be dropped ? */
+ public boolean getDropUniqVendorExtensions(String extName) {
+ return dropUniqVendorExtensions.contains(extName);
+ }
+
+ /** Returns the kind of buffer object this function deals with, or
+ null if none. */
+ public GLEmitter.BufferObjectKind getBufferObjectKind(String name) {
+ return (GLEmitter.BufferObjectKind) bufferObjectKinds.get(name);
+ }
+
+ public boolean isBufferObjectFunction(String name) {
+ return (getBufferObjectKind(name) != null);
+ }
+
+ /** Parses any GL headers specified in the configuration file for
+ the purpose of being able to ignore an extension at a time. */
+ public void parseGLHeaders(GlueEmitterControls controls) throws IOException {
+ if (!glHeaders.isEmpty()) {
+ glInfo = new BuildStaticGLInfo();
+ for (Iterator iter = glHeaders.iterator(); iter.hasNext(); ) {
+ String file = (String) iter.next();
+ String fullPath = controls.findHeaderFile(file);
+ if (fullPath == null) {
+ throw new IOException("Unable to locate header file \"" + file + "\"");
+ }
+ glInfo.parse(fullPath);
+ }
+ }
+ }
+
+ /** Returns the information about the association between #defines,
+ function symbols and the OpenGL extensions they are defined
+ in. */
+ public BuildStaticGLInfo getGLInfo() {
+ return glInfo;
+ }
+
+ /** Returns the OpenGL extensions that should have all of their
+ constant definitions and functions renamed into the core
+ namespace; for example, glGenFramebuffersEXT to
+ glGenFramebuffers and GL_FRAMEBUFFER_EXT to GL_FRAMEBUFFER. */
+ public Set/*<String>*/ getExtensionsRenamedIntoCore() {
+ return extensionsRenamedIntoCore;
+ }
+}
diff --git a/src/java/com/sun/gluegen/opengl/GLEmitter.java b/src/java/com/sun/gluegen/opengl/GLEmitter.java
new file mode 100644
index 000000000..fff9d7e94
--- /dev/null
+++ b/src/java/com/sun/gluegen/opengl/GLEmitter.java
@@ -0,0 +1,407 @@
+/*
+ * 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.
+ *
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.gluegen.opengl;
+
+import java.io.*;
+import java.text.MessageFormat;
+import java.util.*;
+import com.sun.gluegen.*;
+import com.sun.gluegen.cgram.types.*;
+import com.sun.gluegen.procaddress.*;
+import com.sun.gluegen.runtime.*;
+import com.sun.gluegen.runtime.opengl.GLExtensionNames;
+
+/**
+ * A subclass of ProcAddressEmitter with special OpenGL-specific
+ * configuration abilities.
+ */
+public class GLEmitter extends ProcAddressEmitter
+{
+ // Keeps track of which MethodBindings were created for handling
+ // Buffer Object variants. Used as a Set rather than a Map.
+ private Map/*<MethodBinding>*/ bufferObjectMethodBindings = new IdentityHashMap();
+
+ static class BufferObjectKind {
+ private BufferObjectKind() {}
+
+ static final BufferObjectKind UNPACK_PIXEL = new BufferObjectKind();
+ static final BufferObjectKind PACK_PIXEL = new BufferObjectKind();
+ static final BufferObjectKind ARRAY = new BufferObjectKind();
+ static final BufferObjectKind ELEMENT = new BufferObjectKind();
+ }
+
+ public void beginEmission(GlueEmitterControls controls) throws IOException
+ {
+ getGLConfig().parseGLHeaders(controls);
+ renameExtensionsIntoCore();
+ if (getGLConfig().getAutoUnifyExtensions()) {
+ unifyExtensions(controls);
+ }
+ super.beginEmission(controls);
+ }
+
+ protected void renameExtensionsIntoCore() {
+ // This method handles renaming of entire extensions into the
+ // OpenGL core namespace. For example, it is used to move certain
+ // OpenGL ES (OES) extensions into the core namespace which are
+ // already in the core namespace in desktop OpenGL. It builds upon
+ // renaming mechanisms that are built elsewhere.
+
+ GLConfiguration config = getGLConfig();
+ BuildStaticGLInfo glInfo = config.getGLInfo();
+ for (Iterator iter = config.getExtensionsRenamedIntoCore().iterator();
+ iter.hasNext(); ) {
+ String extension = (String) iter.next();
+ Set/*<String>*/ declarations = glInfo.getDeclarations(extension);
+ if (declarations != null) {
+ for (Iterator i2 = declarations.iterator(); i2.hasNext(); ) {
+ String decl = (String) i2.next();
+ boolean isGLFunction = GLExtensionNames.isGLFunction(decl);
+ boolean isGLEnumeration = false;
+ if (!isGLFunction) {
+ isGLEnumeration = GLExtensionNames.isGLEnumeration(decl);
+ }
+ if (isGLFunction || isGLEnumeration) {
+ String renamed = GLExtensionNames.normalize(decl, isGLFunction);
+ if(!renamed.equals(decl)) {
+ config.addJavaSymbolRename(decl, renamed);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ class ExtensionUnifier implements SymbolFilter {
+ private List/*<ConstantDefinition>*/ constants;
+ private List/*<FunctionSymbol>*/ functions;
+
+ public void filterSymbols(List/*<ConstantDefinition>*/ constants,
+ List/*<FunctionSymbol>*/ functions) {
+ this.constants = constants;
+ this.functions = functions;
+ doWork();
+ }
+
+ public List/*<ConstantDefinition>*/ getConstants() {
+ return constants;
+ }
+
+ public List/*<FunctionSymbol>*/ getFunctions() {
+ return functions;
+ }
+
+ private void doWork() {
+ BuildStaticGLInfo glInfo = getGLConfig().getGLInfo();
+ if (glInfo == null) {
+ return;
+ }
+ // Try to retain a "good" ordering for these symbols
+ Map/*<String, ConstantDefinition>*/ constantMap = new LinkedHashMap();
+ Map/*<String, FunctionSymbol>*/ functionMap = new LinkedHashMap();
+ for (Iterator iter = constants.iterator(); iter.hasNext(); ) {
+ ConstantDefinition def = (ConstantDefinition) iter.next();
+ constantMap.put(def.getName(), def);
+ }
+ for (Iterator iter = functions.iterator(); iter.hasNext(); ) {
+ FunctionSymbol sym = (FunctionSymbol) iter.next();
+ functionMap.put(sym.getName(), sym);
+ }
+ // Go through all of the declared extensions.
+ // For each extension, look at its #define and function symbols.
+ // If we find all of the extension's symbols in the core API under
+ // non-ARB (or whatever is the suffix) names, then remove this extension
+ // from the public API. If it turns out that we are running on hardware
+ // that doesn't support the core version of these APIs, the runtime
+ // will take care of looking up the extension version of these entry
+ // points.
+ Set/*<String>*/ extensionNames = glInfo.getExtensions();
+ for (Iterator iter1 = extensionNames.iterator(); iter1.hasNext(); ) {
+ String extension = (String) iter1.next();
+ Set/*<String>*/ declarations = glInfo.getDeclarations(extension);
+ boolean isExtension = true;
+ boolean shouldUnify = true;
+ String cause = null;
+ for (Iterator iter2 = declarations.iterator(); iter2.hasNext(); ) {
+ String decl = (String) iter2.next();
+ boolean isFunc = !decl.startsWith("GL_");
+ if (!GLExtensionNames.isExtension(decl, isFunc)) {
+ isExtension = false;
+ break;
+ }
+ // See whether we're emitting glue code for this
+ // entry point or definition at all
+ if (isFunc) {
+ if (!functionMap.containsKey(decl)) {
+ isExtension = false;
+ break;
+ }
+ } else {
+ if (!constantMap.containsKey(decl)) {
+ isExtension = false;
+ break;
+ }
+ }
+ cause = decl;
+ String unifiedName = GLExtensionNames.normalize(decl, isFunc);
+ // NOTE that we look up the unified name in the
+ // BuildStaticGLInfo's notion of the APIs -- since
+ // we might not be emitting glue code for the
+ // headers that actually contain the core entry
+ // point. Think of the case where we are parsing the
+ // GLES2 gl2.h, which contains certain desktop
+ // OpenGL extensions that have been moved into the
+ // core, but later generating the implementing glue
+ // code (not the interface) for the desktop gl.h /
+ // glext.h.
+ shouldUnify = (glInfo.getExtension(unifiedName) != null);
+ // if (isFunc) {
+ // shouldUnify = functionMap.containsKey(unifiedName);
+ // } else {
+ // shouldUnify = constantMap.containsKey(unifiedName);
+ // }
+ if (!shouldUnify) {
+ break;
+ }
+ }
+ if (isExtension) {
+ if (shouldUnify) {
+ for (Iterator iter2 = declarations.iterator(); iter2.hasNext(); ) {
+ String decl = (String) iter2.next();
+ boolean isFunc = !decl.startsWith("GL_");
+ if (isFunc) {
+ functionMap.remove(decl);
+ } else {
+ constantMap.remove(decl);
+ }
+ }
+ System.err.println("INFO: unified extension " + extension + " into core API");
+ } else {
+ System.err.println("INFO: didn't unify extension " + extension + " into core API because of " + cause);
+ }
+ }
+ }
+ constants = new ArrayList();
+ for (Iterator iter = constantMap.keySet().iterator(); iter.hasNext(); ) {
+ constants.add(constantMap.get(iter.next()));
+ }
+ functions = new ArrayList();
+ for (Iterator iter = functionMap.keySet().iterator(); iter.hasNext(); ) {
+ functions.add(functionMap.get(iter.next()));
+ }
+ }
+ }
+
+ private void unifyExtensions(GlueEmitterControls controls) {
+ controls.runSymbolFilter(new ExtensionUnifier());
+ }
+
+ protected JavaConfiguration createConfig() {
+ return new GLConfiguration(this);
+ }
+
+ /** In order to implement Buffer Object variants of certain
+ functions we generate another MethodBinding which maps the void*
+ argument to a Java long. The generation of emitters then takes
+ place as usual. We do however need to keep track of the modified
+ MethodBinding object so that we can also modify the emitters
+ later to inform them that their argument has changed. We might
+ want to push this functionality down into the MethodBinding
+ (i.e., mutators for argument names). We also would need to
+ inform the CMethodBindingEmitter that it is overloaded in this
+ case (though we default to true currently). */
+ protected List/*<MethodBinding>*/ expandMethodBinding(MethodBinding binding) {
+ List/*<MethodBinding>*/ bindings = super.expandMethodBinding(binding);
+
+ if (!getGLConfig().isBufferObjectFunction(binding.getName())) {
+ return bindings;
+ }
+
+ List/*<MethodBinding>*/ newBindings = new ArrayList();
+ newBindings.addAll(bindings);
+
+ // Need to expand each one of the generated bindings to take a
+ // Java long instead of a Buffer for each void* argument
+ for (Iterator iter = bindings.iterator(); iter.hasNext(); ) {
+ MethodBinding cur = (MethodBinding) iter.next();
+
+ // Some of these routines (glBitmap) take strongly-typed
+ // primitive pointers as arguments which are expanded into
+ // non-void* arguments
+ // This test (rather than !signatureUsesNIO) is used to catch
+ // more unexpected situations
+ if (cur.signatureUsesJavaPrimitiveArrays()) {
+ continue;
+ }
+
+ MethodBinding result = cur;
+ for (int i = 0; i < cur.getNumArguments(); i++) {
+ if (cur.getJavaArgumentType(i).isNIOBuffer()) {
+ result = result.replaceJavaArgumentType(i, JavaType.createForClass(Long.TYPE));
+ }
+ }
+
+ if (result == cur) {
+ throw new RuntimeException("Error: didn't find any void* arguments for BufferObject function " +
+ binding.getName());
+ }
+
+ newBindings.add(result);
+ // Now need to flag this MethodBinding so that we generate the
+ // correct flags in the emitters later
+ bufferObjectMethodBindings.put(result, result);
+ }
+
+ return newBindings;
+ }
+
+ protected boolean needsModifiedEmitters(FunctionSymbol sym) {
+ if ((!needsProcAddressWrapper(sym) && !needsBufferObjectVariant(sym)) ||
+ getConfig().isUnimplemented(sym.getName())) {
+ return false;
+ }
+
+ return true;
+ }
+
+ public boolean isBufferObjectMethodBinding(MethodBinding binding) {
+ return bufferObjectMethodBindings.containsKey(binding);
+ }
+
+ //----------------------------------------------------------------------
+ // Internals only below this point
+ //
+
+ protected void generateModifiedEmitters(JavaMethodBindingEmitter baseJavaEmitter, List emitters) {
+ List superEmitters = new ArrayList();
+ super.generateModifiedEmitters(baseJavaEmitter, superEmitters);
+
+ // See whether this is one of the Buffer Object variants
+ boolean bufferObjectVariant = bufferObjectMethodBindings.containsKey(baseJavaEmitter.getBinding());
+
+ for (Iterator iter = superEmitters.iterator(); iter.hasNext(); ) {
+ JavaMethodBindingEmitter emitter = (JavaMethodBindingEmitter) iter.next();
+ if (emitter instanceof ProcAddressJavaMethodBindingEmitter) {
+ emitters.add(new GLJavaMethodBindingEmitter((ProcAddressJavaMethodBindingEmitter) emitter, this, bufferObjectVariant));
+ } else {
+ emitters.add(emitter);
+ }
+ }
+ }
+
+ protected boolean needsBufferObjectVariant(FunctionSymbol sym) {
+ return getGLConfig().isBufferObjectFunction(sym.getName());
+ }
+
+ protected GLConfiguration getGLConfig() {
+ return (GLConfiguration) getConfig();
+ }
+
+ protected void endProcAddressTable() throws Exception
+ {
+ PrintWriter w = tableWriter;
+
+ w.println(" /**");
+ w.println(" * This is a convenience method to get (by name) the native function");
+ w.println(" * pointer for a given function. It lets you avoid having to");
+ w.println(" * manually compute the &quot;" + PROCADDRESS_VAR_PREFIX + " + ");
+ w.println(" * &lt;functionName&gt;&quot; member variable name and look it up via");
+ w.println(" * reflection; it also will throw an exception if you try to get the");
+ w.println(" * address of an unknown function, or one that is statically linked");
+ w.println(" * and therefore does not have a function pointer in this table.");
+ w.println(" *");
+ w.println(" * @throws RuntimeException if the function pointer was not found in");
+ w.println(" * this table, either because the function was unknown or because");
+ w.println(" * it was statically linked.");
+ w.println(" */");
+ w.println(" public long getAddressFor(String functionNameUsr) {");
+ w.println(" String functionNameBase = com.sun.gluegen.runtime.opengl.GLExtensionNames.normalizeVEN(com.sun.gluegen.runtime.opengl.GLExtensionNames.normalizeARB(functionNameUsr, true), true);");
+ w.println(" String addressFieldNameBase = " + getProcAddressConfig().gluegenRuntimePackage() + ".ProcAddressHelper.PROCADDRESS_VAR_PREFIX + functionNameBase;");
+ w.println(" java.lang.reflect.Field addressField = null;");
+ w.println(" int funcNamePermNum = com.sun.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutationNumber(functionNameBase);");
+ w.println(" for(int i = 0; null==addressField && i < funcNamePermNum; i++) {");
+ w.println(" String addressFieldName = com.sun.gluegen.runtime.opengl.GLExtensionNames.getFuncNamePermutation(addressFieldNameBase, i);");
+ w.println(" try {");
+ w.println(" addressField = getClass().getField(addressFieldName);");
+ w.println(" } catch (Exception e) { }");
+ 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");
+ w.println(" throw new RuntimeException(");
+ w.println(" \"WARNING: Address field query failed for \\\"\" + functionNameBase + \"\\\"/\\\"\" + functionNameUsr +");
+ w.println(" \"\\\"; it's either statically linked or address field is not a known \" +");
+ w.println(" \"function\");");
+ w.println(" } ");
+ w.println(" try {");
+ w.println(" return addressField.getLong(this);");
+ w.println(" } catch (Exception e) {");
+ w.println(" throw new RuntimeException(");
+ w.println(" \"WARNING: Address query failed for \\\"\" + functionNameBase + \"\\\"/\\\"\" + functionNameUsr +");
+ w.println(" \"\\\"; it's either statically linked or is not a known \" +");
+ w.println(" \"function\", e);");
+ w.println(" }");
+ w.println(" }");
+
+ w.println("} // end of class " + tableClassName);
+ w.flush();
+ w.close();
+ }
+
+ protected void emitProcAddressTableEntryForSymbol(FunctionSymbol cFunc)
+ {
+ emitProcAddressTableEntryForString(cFunc.getName());
+ }
+
+ protected void emitProcAddressTableEntryForString(String str)
+ {
+ // Deal gracefully with forced proc address generation in the face
+ // of having the function pointer typedef in the header file too
+ if (emittedTableEntries.contains(str))
+ return;
+ emittedTableEntries.add(str);
+ tableWriter.print(" public long ");
+ tableWriter.print(PROCADDRESS_VAR_PREFIX);
+ tableWriter.print(str);
+ tableWriter.println(";");
+ }
+
+}
diff --git a/src/java/com/sun/gluegen/opengl/GLJavaMethodBindingEmitter.java b/src/java/com/sun/gluegen/opengl/GLJavaMethodBindingEmitter.java
new file mode 100755
index 000000000..c6a030935
--- /dev/null
+++ b/src/java/com/sun/gluegen/opengl/GLJavaMethodBindingEmitter.java
@@ -0,0 +1,103 @@
+/*
+ * 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.
+ *
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.sun.gluegen.opengl;
+
+import java.io.*;
+import java.util.*;
+import com.sun.gluegen.*;
+import com.sun.gluegen.cgram.types.*;
+import com.sun.gluegen.procaddress.*;
+
+/** A specialization of the proc address emitter which knows how to
+ change argument names to take into account Vertex Buffer Object /
+ Pixel Buffer Object variants. */
+
+public class GLJavaMethodBindingEmitter extends ProcAddressJavaMethodBindingEmitter {
+ protected boolean bufferObjectVariant;
+ protected GLEmitter glEmitter;
+
+ public GLJavaMethodBindingEmitter(JavaMethodBindingEmitter methodToWrap,
+ boolean callThroughProcAddress,
+ String getProcAddressTableExpr,
+ boolean changeNameAndArguments,
+ boolean bufferObjectVariant,
+ GLEmitter emitter) {
+ super(methodToWrap,
+ callThroughProcAddress,
+ getProcAddressTableExpr,
+ changeNameAndArguments,
+ emitter);
+ this.bufferObjectVariant = bufferObjectVariant;
+ this.glEmitter=emitter;
+ }
+
+ public GLJavaMethodBindingEmitter(ProcAddressJavaMethodBindingEmitter methodToWrap,
+ GLEmitter emitter,
+ boolean bufferObjectVariant) {
+ super(methodToWrap);
+ this.bufferObjectVariant = bufferObjectVariant;
+ this.glEmitter=emitter;
+ }
+
+ public GLJavaMethodBindingEmitter(GLJavaMethodBindingEmitter methodToWrap) {
+ this(methodToWrap, methodToWrap.glEmitter, methodToWrap.bufferObjectVariant);
+ }
+
+ protected String getArgumentName(int i) {
+ String name = super.getArgumentName(i);
+
+ if (!bufferObjectVariant) {
+ return name;
+ }
+
+ // Emitters for VBO/PBO-related routines change the outgoing
+ // argument name for the buffer
+ if (binding.getJavaArgumentType(i).isLong()) {
+ Type cType = binding.getCArgumentType(i);
+ if (cType.isPointer() &&
+ (cType.asPointer().getTargetType().isVoid() ||
+ cType.asPointer().getTargetType().isPrimitive())) {
+ return name + "_buffer_offset";
+ }
+ }
+
+ return name;
+ }
+}
diff --git a/src/java/com/sun/gluegen/runtime/opengl/GLExtensionNames.java b/src/java/com/sun/gluegen/runtime/opengl/GLExtensionNames.java
new file mode 100644
index 000000000..3c6f6002a
--- /dev/null
+++ b/src/java/com/sun/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.sun.gluegen.runtime.opengl;
+
+import java.util.*;
+import com.sun.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<extensionsARB.length) {
+ return name+extensionsARB[i];
+ }
+ // VEN
+ i-=extensionsARB.length;
+ return name+extensionsVEN[i];
+ }
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-29 20:16:09 +0000