From d49fd968963909f181423eae46c613189468fac3 Mon Sep 17 00:00:00 2001
From: djp <djp@dev.java.net>
Date: Sun, 8 Jun 2003 19:27:01 +0000
Subject: Initial revision
git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@3 232f8b59-042b-4e1e-8c03-345bb8c30851
---
src/net/java/games/gluegen/opengl/GLEmitter.java | 330 +++++++++++++++++++++++
1 file changed, 330 insertions(+)
create mode 100644 src/net/java/games/gluegen/opengl/GLEmitter.java
(limited to 'src/net/java/games/gluegen/opengl/GLEmitter.java')
diff --git a/src/net/java/games/gluegen/opengl/GLEmitter.java b/src/net/java/games/gluegen/opengl/GLEmitter.java
new file mode 100644
index 000000000..27cc07e2c
--- /dev/null
+++ b/src/net/java/games/gluegen/opengl/GLEmitter.java
@@ -0,0 +1,330 @@
+/*
+ * 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
+ * MIDROSYSTEMS, 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 net.java.games.gluegen.opengl;
+
+import java.io.*;
+import java.text.MessageFormat;
+import java.util.*;
+import net.java.games.gluegen.*;
+import net.java.games.gluegen.cgram.types.*;
+
+/**
+ * A subclass of JavaEmitter that modifies the normal emission of C and Java
+ * code in order to allow a high-performance, cross-platform binding of Java
+ * to OpenGL.
+ */
+public class GLEmitter extends JavaEmitter
+{
+ public static final String PROCADDRESS_VAR_PREFIX = "_addressof_";
+ protected static final String WRAP_PREFIX = "dispatch_";
+ private TypeDictionary typedefDictionary;
+ private PrintWriter tableWriter;
+ private String tableClassName = "ProcAddressTable";
+ private int numProcAddressEntries;
+
+ public void beginFunctions(TypeDictionary typedefDictionary,
+ TypeDictionary structDictionary,
+ Map canonMap) throws Exception
+ {
+ this.typedefDictionary = typedefDictionary;
+
+ if (getConfig().emitImpl()) {
+ cWriter().println("#include <assert.h> /* this include emitted by GLEmitter.java */");
+ cWriter().println();
+ }
+
+ if (((GLConfiguration)getConfig()).emitProcAddressTable())
+ {
+ beginGLProcAddressTable();
+ }
+ super.beginFunctions(typedefDictionary, structDictionary, canonMap);
+ }
+
+ public void endFunctions() throws Exception
+ {
+ if (((GLConfiguration)getConfig()).emitProcAddressTable())
+ {
+ endGLProcAddressTable();
+ }
+ super.endFunctions();
+ }
+
+ public void beginStructs(TypeDictionary typedefDictionary,
+ TypeDictionary structDictionary,
+ Map canonMap) throws Exception {
+ super.beginStructs(typedefDictionary, structDictionary, canonMap);
+ }
+
+ protected JavaConfiguration createConfig() {
+ return new GLConfiguration();
+ }
+
+ protected Iterator generateMethodBindingEmitters(FunctionSymbol sym) throws Exception
+ {
+ Iterator defaultEmitters = super.generateMethodBindingEmitters(sym);
+
+ // if the superclass didn't generate any bindings for the symbol, let's
+ // honor that (for example, the superclass might have caught an Ignore
+ // direction that matched the symbol's name).
+ if (!defaultEmitters.hasNext())
+ {
+ return defaultEmitters;
+ }
+
+ // Don't do anything special if this symbol doesn't require passing of
+ // Opengl procedure addresses in order to function correctly.
+ if (!needsProcAddressWrapper(sym) || getConfig().isUnimplemented(sym.getName()))
+ {
+ return defaultEmitters;
+ }
+
+ // 9 is default # expanded bindings for void*
+ ArrayList modifiedEmitters = new ArrayList(9);
+
+ if (((GLConfiguration)getConfig()).emitProcAddressTable())
+ {
+ // emit an entry in the GL proc address table for this method.
+ emitGLProcAddressTableEntryForSymbol(sym);
+ }
+
+ while (defaultEmitters.hasNext())
+ {
+ FunctionEmitter emitter = (FunctionEmitter)defaultEmitters.next();
+ if (emitter instanceof JavaMethodBindingEmitter)
+ {
+ JavaMethodBindingEmitter newEmitter =
+ generateModifiedEmitter((JavaMethodBindingEmitter)emitter);
+ if (newEmitter != null) {
+ modifiedEmitters.add(newEmitter);
+ }
+ }
+ else if (emitter instanceof CMethodBindingEmitter)
+ {
+ modifiedEmitters.add(
+ generateModifiedEmitter((CMethodBindingEmitter)emitter));
+ }
+ else
+ {
+ throw new RuntimeException("Unexpected emitter type: " +
+ emitter.getClass().getName());
+ }
+ }
+
+ return modifiedEmitters.iterator();
+ }
+
+ /**
+ * Returns the name of the typedef for a pointer to the GL function
+ * represented by the argument. For example, if the argument is the function
+ * "glFuncName", the value returned will be "PFNGLFUNCNAMEPROC". This
+ * returns a valid string regardless of whether or not the typedef is
+ * actually defined.
+ */
+ static String getGLFunctionPointerTypedefName(FunctionSymbol sym)
+ {
+ String symName = sym.getName();
+ StringBuffer buf = new StringBuffer(symName.length() + 8);
+ buf.append("PFN");
+ buf.append(symName.toUpperCase());
+ buf.append("PROC");
+ return buf.toString();
+ }
+
+ //----------------------------------------------------------------------
+ // Internals only below this point
+ //
+
+ private JavaMethodBindingEmitter generateModifiedEmitter(JavaMethodBindingEmitter baseJavaEmitter)
+ {
+ if (!(baseJavaEmitter instanceof JavaMethodBindingImplEmitter)) {
+ // We only want to wrap the native entry point in the implementation
+ // class, not the public interface in the interface class.
+ //
+ // If the superclass has generated a "0" emitter for this routine because
+ // it needs argument conversion or similar, filter that out since we will
+ // be providing such an emitter ourselves. Otherwise return the emitter
+ // unmodified.
+ if (baseJavaEmitter.isForNIOBufferBaseRoutine())
+ return null;
+ return baseJavaEmitter;
+ }
+ return new JavaGLPAWrapperEmitter(baseJavaEmitter);
+ }
+
+ private CMethodBindingEmitter generateModifiedEmitter(CMethodBindingEmitter baseCEmitter)
+ {
+ // The C-side JNI binding for this particular function will have an
+ // extra final argument, which is the address (the OpenGL procedure
+ // address) of the function it needs to call
+ CGLPAWrapperEmitter res = new CGLPAWrapperEmitter(baseCEmitter);
+ MessageFormat exp = baseCEmitter.getReturnValueCapacityExpression();
+ if (exp != null) {
+ res.setReturnValueCapacityExpression(exp);
+ }
+ return res;
+ }
+
+ private boolean needsProcAddressWrapper(FunctionSymbol sym)
+ {
+ String symName = sym.getName();
+
+ // We should only wrap the GL symbol if its function pointer typedef has
+ // been defined (most likely in glext.h).
+ String funcPointerTypedefName = getGLFunctionPointerTypedefName(sym);
+ boolean shouldWrap = typedefDictionary.containsKey(funcPointerTypedefName);
+ //System.err.println(funcPointerTypedefName + " defined: " + shouldWrap);
+
+ if (!shouldWrap)
+ {
+ //System.err.println("WARNING (GL): *not* run-time linking: " + sym +
+ // "(" + funcPointerTypedefName + " undefined)");
+ }
+ return shouldWrap;
+ }
+
+ private void beginGLProcAddressTable() throws Exception
+ {
+ String implPackageName = getImplPackageName();
+ String jImplRoot =
+ getJavaOutputDir() + File.separator +
+ CodeGenUtils.packageAsPath(implPackageName);
+
+ // HACK: until we have a way to make the impl dir different from the
+ // WindowsGLImpl dir and the interface dir
+ //tableWriter = openFile(jImplRoot + File.separator + tableClassName + ".java");
+ File tmpFile = new File(jImplRoot);
+ tmpFile = tmpFile.getParentFile();
+ tmpFile = new File(tmpFile, tableClassName + ".java");
+ tableWriter = openFile(tmpFile.getPath());
+ // tableWriter = openFile(jImplRoot + File.separator + ".." + File.separator + tableClassName + ".java");
+
+ CodeGenUtils.emitAutogeneratedWarning(tableWriter, this);
+
+ // HACK: until we have a way to make the impl dir different from the
+ // WindowsGLImpl dir and the interface dir
+ //tableWriter.println("package " + implPackageName + ";");
+ tableWriter.println("package " + getJavaPackageName() + ".impl;");
+ tableWriter.println();
+ tableWriter.println("/**");
+ tableWriter.println(" * This table is a cache of the native pointers to OpenGL extension");
+ tableWriter.println(" * functions, to be used for run-time linking of these extensions. ");
+ tableWriter.println(" * These pointers are obtained by the OpenGL context via a ");
+ tableWriter.println(" * platform-specific function (e.g., wglGetProcAddress() on Win32,");
+ tableWriter.println(" * glXGetProcAddress() on X11, etc). If the member variable ");
+ tableWriter.println(" * " + PROCADDRESS_VAR_PREFIX + "glFuncName is non-zero then function");
+ tableWriter.println(" * \"glFuncName\" can be called through the associated GLContext; ");
+ tableWriter.println(" * if it is 0, then the extension is not available and cannot be called.");
+ tableWriter.println(" */");
+ tableWriter.println("public class " + tableClassName);
+ tableWriter.println("{");
+ numProcAddressEntries = 0;
+ }
+
+ private void endGLProcAddressTable() throws Exception
+ {
+ PrintWriter w = tableWriter;
+ w.print(" protected static long __PROCADDRESSINDEX__LASTINDEX = ");
+ w.print(numProcAddressEntries-1);
+ w.println(';');
+
+ w.println();
+ w.println(" /**");
+ w.println(" * This is a convenience method to get (by name) the native function ");
+ w.println(" * pointer for a given extension function. It lets you avoid ");
+ w.println(" * having to manually compute the " + PROCADDRESS_VAR_PREFIX + "<glFunctionName>");
+ w.println(" * member variable name and look it up via reflection; it also");
+ w.println(" * will throw an exception if you try to get the address of an");
+ w.println(" * unknown GL extension, or one that is statically linked ");
+ w.println(" * and therefore does not have a valid GL procedure address. ");
+ w.println(" */");
+ w.println(" public long getAddressFor(String glFunctionName) {");
+ w.println(" String addressFieldName = net.java.games.gluegen.opengl.GLEmitter.PROCADDRESS_VAR_PREFIX + glFunctionName;");
+ w.println(" try { ");
+ w.println(" java.lang.reflect.Field addressField = this.getClass().getField(addressFieldName);");
+ w.println(" return addressField.getLong(this);");
+ w.println(" } catch (Exception e) {");
+ w.println(" // The user is calling a bogus function or one which is not runtime");
+ w.println(" // linked (extensions and core post-OpenGL 1.1 functions are runtime linked)");
+ w.println(" if (!FunctionAvailabilityCache.isPartOfGLCore(\"1.1\", glFunctionName)) ");
+ w.println(" {");
+ w.println(" throw new RuntimeException(" );
+ w.println(" \"WARNING: Address query failed for \\\"\" + glFunctionName +");
+ w.println(" \"\\\"; either it's not runtime linked or it is not a known \" +");
+ w.println(" \"OpenGL function\", e);");
+ w.println(" }");
+ w.println(" } ");
+ w.println(" assert(false); // should never get this far");
+ w.println(" return 0;");
+ w.println(" }");
+
+ w.println("} // end of class " + tableClassName);
+ w.flush();
+ w.close();
+ }
+
+ private void emitGLProcAddressTableEntryForSymbol(FunctionSymbol cFunc)
+ {
+ tableWriter.print(" public static long ");
+ tableWriter.print(PROCADDRESS_VAR_PREFIX);
+ tableWriter.print(cFunc.getName());
+ tableWriter.println(";");
+ ++numProcAddressEntries;
+ }
+
+ protected static class GLConfiguration extends JavaConfiguration
+ {
+ private boolean emitProcAddressTable = false;
+
+ protected void dispatch(String cmd, StringTokenizer tok, File file, String filename, int lineNo) throws IOException {
+ if (cmd.equalsIgnoreCase("EmitProcAddressTable"))
+ {
+ emitProcAddressTable =
+ readBoolean("EmitProcAddressTable", tok, filename, lineNo).booleanValue();
+ }
+ else
+ {
+ super.dispatch(cmd,tok,file,filename,lineNo);
+ }
+ }
+
+ public boolean emitProcAddressTable() { return emitProcAddressTable; }
+ } // end class GLConfiguration
+}
+
--
cgit v1.2.3