Initial deob and project structure

gl/pom.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
+		 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.jagex</groupId>
+        <artifactId>rs2</artifactId>
+        <version>530</version>
+    </parent>
+
+    <groupId>com.jagex</groupId>
+    <artifactId>gl</artifactId>
+    <version>1.0</version>
+    <packaging>jar</packaging>
+</project>

gl/src/main/java/com/sun/gluegen/runtime/BufferFactory.java

@@ -0,0 +1,148 @@
+package com.sun.gluegen.runtime;
+
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.CharBuffer;
+import java.nio.DoubleBuffer;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.nio.LongBuffer;
+import java.nio.ShortBuffer;
+
+public class BufferFactory {
+
+	public static ByteBuffer newDirectByteBuffer(int arg0) {
+		ByteBuffer var1 = ByteBuffer.allocateDirect(arg0);
+		var1.order(ByteOrder.nativeOrder());
+		return var1;
+	}
+
+	public static boolean isDirect(Buffer arg0) {
+		if (arg0 == null) {
+			return true;
+		} else if (arg0 instanceof ByteBuffer) {
+			return ((ByteBuffer) arg0).isDirect();
+		} else if (arg0 instanceof FloatBuffer) {
+			return ((FloatBuffer) arg0).isDirect();
+		} else if (arg0 instanceof DoubleBuffer) {
+			return ((DoubleBuffer) arg0).isDirect();
+		} else if (arg0 instanceof CharBuffer) {
+			return ((CharBuffer) arg0).isDirect();
+		} else if (arg0 instanceof ShortBuffer) {
+			return ((ShortBuffer) arg0).isDirect();
+		} else if (arg0 instanceof IntBuffer) {
+			return ((IntBuffer) arg0).isDirect();
+		} else if (arg0 instanceof LongBuffer) {
+			return ((LongBuffer) arg0).isDirect();
+		} else {
+			throw new RuntimeException("Unexpected buffer type " + arg0.getClass().getName());
+		}
+	}
+
+	public static int getDirectBufferByteOffset(Buffer arg0) {
+		if (arg0 == null) {
+			return 0;
+		} else if (arg0 instanceof ByteBuffer) {
+			return arg0.position();
+		} else if (arg0 instanceof FloatBuffer) {
+			return arg0.position() * 4;
+		} else if (arg0 instanceof IntBuffer) {
+			return arg0.position() * 4;
+		} else if (arg0 instanceof ShortBuffer) {
+			return arg0.position() * 2;
+		} else if (arg0 instanceof DoubleBuffer) {
+			return arg0.position() * 8;
+		} else if (arg0 instanceof LongBuffer) {
+			return arg0.position() * 8;
+		} else if (arg0 instanceof CharBuffer) {
+			return arg0.position() * 2;
+		} else {
+			throw new RuntimeException("Disallowed array backing store type in buffer " + arg0.getClass().getName());
+		}
+	}
+
+	public static Object getArray(Buffer arg0) {
+		if (arg0 == null) {
+			return null;
+		} else if (arg0 instanceof ByteBuffer) {
+			return ((ByteBuffer) arg0).array();
+		} else if (arg0 instanceof FloatBuffer) {
+			return ((FloatBuffer) arg0).array();
+		} else if (arg0 instanceof IntBuffer) {
+			return ((IntBuffer) arg0).array();
+		} else if (arg0 instanceof ShortBuffer) {
+			return ((ShortBuffer) arg0).array();
+		} else if (arg0 instanceof DoubleBuffer) {
+			return ((DoubleBuffer) arg0).array();
+		} else if (arg0 instanceof LongBuffer) {
+			return ((LongBuffer) arg0).array();
+		} else if (arg0 instanceof CharBuffer) {
+			return ((CharBuffer) arg0).array();
+		} else {
+			throw new RuntimeException("Disallowed array backing store type in buffer " + arg0.getClass().getName());
+		}
+	}
+
+	public static int getIndirectBufferByteOffset(Buffer arg0) {
+		if (arg0 == null) {
+			return 0;
+		}
+		int var1 = arg0.position();
+		if (arg0 instanceof ByteBuffer) {
+			return ((ByteBuffer) arg0).arrayOffset() + var1;
+		} else if (arg0 instanceof FloatBuffer) {
+			return (((FloatBuffer) arg0).arrayOffset() + var1) * 4;
+		} else if (arg0 instanceof IntBuffer) {
+			return (((IntBuffer) arg0).arrayOffset() + var1) * 4;
+		} else if (arg0 instanceof ShortBuffer) {
+			return (((ShortBuffer) arg0).arrayOffset() + var1) * 2;
+		} else if (arg0 instanceof DoubleBuffer) {
+			return (((DoubleBuffer) arg0).arrayOffset() + var1) * 8;
+		} else if (arg0 instanceof LongBuffer) {
+			return (((LongBuffer) arg0).arrayOffset() + var1) * 8;
+		} else if (arg0 instanceof CharBuffer) {
+			return (((CharBuffer) arg0).arrayOffset() + var1) * 2;
+		} else {
+			throw new RuntimeException("Unknown buffer type " + arg0.getClass().getName());
+		}
+	}
+
+	public static void rangeCheck(int[] arg0, int arg1, int arg2) {
+		if (arg0 != null && arg0.length < arg1 + arg2) {
+			throw new ArrayIndexOutOfBoundsException("Required " + arg2 + " elements in array, only had " + (arg0.length - arg1));
+		}
+	}
+
+	public static void rangeCheck(Buffer arg0, int arg1) {
+		if (arg0 != null && arg0.remaining() < arg1) {
+			throw new IndexOutOfBoundsException("Required " + arg1 + " remaining elements in buffer, only had " + arg0.remaining());
+		}
+	}
+
+	public static void rangeCheckBytes(Buffer arg0, int arg1) {
+		if (arg0 == null) {
+			return;
+		}
+		int var2 = arg0.remaining();
+		int var3 = 0;
+		if (arg0 instanceof ByteBuffer) {
+			var3 = var2;
+		} else if (arg0 instanceof FloatBuffer) {
+			var3 = var2 * 4;
+		} else if (arg0 instanceof IntBuffer) {
+			var3 = var2 * 4;
+		} else if (arg0 instanceof ShortBuffer) {
+			var3 = var2 * 2;
+		} else if (arg0 instanceof DoubleBuffer) {
+			var3 = var2 * 8;
+		} else if (arg0 instanceof LongBuffer) {
+			var3 = var2 * 8;
+		} else if (arg0 instanceof CharBuffer) {
+			var3 = var2 * 2;
+		}
+		if (var3 < arg1) {
+			throw new IndexOutOfBoundsException("Required " + arg1 + " remaining bytes in buffer, only had " + var3);
+		}
+	}
+}

gl/src/main/java/com/sun/gluegen/runtime/CPU.java

@@ -0,0 +1,20 @@
+package com.sun.gluegen.runtime;
+
+public class CPU {
+
+	private static boolean is32Bit;
+
+	public static boolean is32Bit() {
+		return is32Bit;
+	}
+
+	static {
+		String var0 = System.getProperty("os.name").toLowerCase();
+		String var1 = System.getProperty("os.arch").toLowerCase();
+		if (var0.startsWith("windows") && var1.equals("x86") || !(!var0.startsWith("linux") || !var1.equals("i386")) || var0.startsWith("linux") && var1.equals("x86") || var0.startsWith("mac os") && var1.equals("ppc") || var0.startsWith("mac os") && var1.equals("i386") || var0.startsWith("sunos") && var1.equals("sparc") || var0.startsWith("sunos") && var1.equals("x86") || var0.startsWith("freebsd") && var1.equals("i386") || var0.startsWith("hp-ux") && var1.equals("pa_risc2.0")) {
+			is32Bit = true;
+		} else if ((!var0.startsWith("windows") || !var1.equals("amd64")) && (!var0.startsWith("linux") || !var1.equals("amd64")) && (!var0.startsWith("linux") || !var1.equals("x86_64")) && (!var0.startsWith("linux") || !var1.equals("ia64")) && (!var0.startsWith("mac os") || !var1.equals("x86_64")) && (!var0.startsWith("sunos") || !var1.equals("sparcv9")) && (!var0.startsWith("sunos") || !var1.equals("amd64"))) {
+			throw new RuntimeException("Please port CPU detection (32/64 bit) to your platform (" + var0 + "/" + var1 + ")");
+		}
+	}
+}

gl/src/main/java/com/sun/gluegen/runtime/DynamicLinker.java

@@ -0,0 +1,8 @@
+package com.sun.gluegen.runtime;
+
+interface DynamicLinker {
+
+	long openLibrary(String arg0);
+
+	void closeLibrary(long arg0);
+}

gl/src/main/java/com/sun/gluegen/runtime/DynamicLookupHelper.java

@@ -0,0 +1,6 @@
+package com.sun.gluegen.runtime;
+
+public interface DynamicLookupHelper {
+
+	long dynamicLookupFunction(String arg0);
+}

gl/src/main/java/com/sun/gluegen/runtime/MacOSXDynamicLinkerImpl.java

@@ -0,0 +1,16 @@
+package com.sun.gluegen.runtime;
+
+public class MacOSXDynamicLinkerImpl implements DynamicLinker {
+
+	private static native int dlclose(long arg0);
+
+	private static native long dlopen(String arg0, int arg1);
+
+	public long openLibrary(String arg0) {
+		return dlopen(arg0, 9);
+	}
+
+	public void closeLibrary(long arg0) {
+		dlclose(arg0);
+	}
+}

gl/src/main/java/com/sun/gluegen/runtime/NativeLibrary.java

@@ -0,0 +1,256 @@
+package com.sun.gluegen.runtime;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.StringTokenizer;
+
+public class NativeLibrary {
+
+	private static boolean DEBUG;
+
+	private static int platform;
+
+	private static DynamicLinker dynLink;
+
+	private static String[] prefixes;
+
+	private static String[] suffixes;
+
+	private long libraryHandle;
+
+	private String libraryPath;
+
+	private static boolean initializedFindLibraryMethod;
+
+	private static Method findLibraryMethod;
+
+	private NativeLibrary(long arg0, String arg1) {
+		this.libraryHandle = arg0;
+		this.libraryPath = arg1;
+	}
+
+	public static NativeLibrary open(String arg0, ClassLoader arg1) {
+		return open(arg0, arg0, arg0, true, arg1);
+	}
+
+	public static NativeLibrary open(String arg0, String arg1, String arg2, boolean arg3, ClassLoader arg4) {
+		List var5 = enumerateLibraryPaths(arg0, arg1, arg2, arg3, arg4);
+		Iterator var6 = var5.iterator();
+		String var7;
+		long var8;
+		do {
+			if (!var6.hasNext()) {
+				if (DEBUG) {
+					System.out.println("Did not succeed in loading (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
+				}
+				return null;
+			}
+			var7 = (String) var6.next();
+			if (DEBUG) {
+				System.out.println("Trying to load " + var7);
+			}
+			var8 = dynLink.openLibrary(var7);
+		} while (var8 == 0L);
+		if (DEBUG) {
+			System.out.println("Successfully loaded " + var7 + ": res = 0x" + Long.toHexString(var8));
+		}
+		return new NativeLibrary(var8, var7);
+	}
+
+	public void close() {
+		if (this.libraryHandle == 0L) {
+			throw new RuntimeException("Library already closed");
+		}
+		long var1 = this.libraryHandle;
+		this.libraryHandle = 0L;
+		dynLink.closeLibrary(var1);
+	}
+
+	private static List enumerateLibraryPaths(String arg0, String arg1, String arg2, boolean arg3, ClassLoader arg4) {
+		ArrayList var5 = new ArrayList();
+		String var6 = selectName(arg0, arg1, arg2);
+		if (var6 == null) {
+			return var5;
+		}
+		File var7 = new File(var6);
+		if (var7.isAbsolute()) {
+			var5.add(var6);
+			return var5;
+		}
+		String[] var8 = buildNames(var6);
+		if (arg3) {
+			for (int var9 = 0; var9 < var8.length; var9++) {
+				var5.add(var8[var9]);
+			}
+		}
+		String var13 = getPathFromClassLoader(var6, arg4);
+		if (DEBUG) {
+			System.out.println("Class loader path to " + var6 + ": " + var13);
+		}
+		if (var13 != null) {
+			var5.add(var13);
+		}
+		String var10 = (String) AccessController.doPrivileged(new PrivilegedAction() {
+
+			public Object run() {
+				return System.getProperty("java.library.path");
+			}
+		});
+		if (var10 != null) {
+			StringTokenizer var11 = new StringTokenizer(var10, File.pathSeparator);
+			while (var11.hasMoreTokens()) {
+				addPaths(var11.nextToken(), var8, var5);
+			}
+		}
+		String var14 = (String) AccessController.doPrivileged(new PrivilegedAction() {
+
+			public Object run() {
+				return System.getProperty("user.dir");
+			}
+		});
+		addPaths(var14, var8, var5);
+		if (platform == 3) {
+			addPaths("/Library/Frameworks/" + var6 + ".Framework", var8, var5);
+			addPaths("/System/Library/Frameworks/" + var6 + ".Framework", var8, var5);
+		}
+		if (!arg3) {
+			for (int var12 = 0; var12 < var8.length; var12++) {
+				var5.add(var8[var12]);
+			}
+		}
+		return var5;
+	}
+
+	private static String selectName(String arg0, String arg1, String arg2) {
+		switch(platform) {
+			case 1:
+				return arg0;
+			case 2:
+				return arg1;
+			case 3:
+				return arg2;
+			default:
+				throw new InternalError();
+		}
+	}
+
+	private static String[] buildNames(String arg0) {
+		int var3;
+		if (arg0.startsWith(prefixes[0])) {
+			if (arg0.endsWith(suffixes[0])) {
+				return new String[] { arg0 };
+			}
+			int var1 = arg0.indexOf(suffixes[0]);
+			boolean var2 = true;
+			if (var1 >= 0) {
+				for (var3 = var1 + suffixes[0].length(); var3 < arg0.length(); var3++) {
+					char var4 = arg0.charAt(var3);
+					if (var4 != '.' && (var4 < '0' || var4 > '9')) {
+						var2 = false;
+						break;
+					}
+				}
+				if (var2) {
+					return new String[] { arg0 };
+				}
+			}
+		}
+		String[] var5 = new String[prefixes.length * suffixes.length];
+		int var6 = 0;
+		for (var3 = 0; var3 < prefixes.length; var3++) {
+			for (int var7 = 0; var7 < suffixes.length; var7++) {
+				var5[var6++] = prefixes[var3] + arg0 + suffixes[var7];
+			}
+		}
+		return var5;
+	}
+
+	private static void addPaths(String arg0, String[] arg1, List arg2) {
+		for (int var3 = 0; var3 < arg1.length; var3++) {
+			arg2.add(arg0 + File.separator + arg1[var3]);
+		}
+	}
+
+	private static String getPathFromClassLoader(final String arg0, final ClassLoader arg1) {
+		if (arg1 == null) {
+			return null;
+		}
+		if (!initializedFindLibraryMethod) {
+			AccessController.doPrivileged(new PrivilegedAction() {
+
+				public Object run() {
+					try {
+						NativeLibrary.findLibraryMethod = ClassLoader.class.getDeclaredMethod("findLibrary", String.class);
+						NativeLibrary.findLibraryMethod.setAccessible(true);
+					} catch (Exception var2) {
+					}
+					NativeLibrary.initializedFindLibraryMethod = true;
+					return null;
+				}
+			});
+		}
+		if (findLibraryMethod != null) {
+			try {
+				return (String) AccessController.doPrivileged(new PrivilegedAction() {
+
+					public Object run() {
+						try {
+							return NativeLibrary.findLibraryMethod.invoke(arg1, arg0);
+						} catch (Exception var2) {
+							throw new RuntimeException(var2);
+						}
+					}
+				});
+			} catch (Exception var3) {
+				if (DEBUG) {
+					var3.printStackTrace();
+				}
+			}
+		}
+		return null;
+	}
+
+	static {
+		AccessController.doPrivileged(new PrivilegedAction() {
+
+			public Object run() {
+				String var1 = System.getProperty("os.name").toLowerCase();
+				if (var1.startsWith("wind")) {
+					NativeLibrary.platform = 1;
+				} else if (var1.startsWith("mac os x")) {
+					NativeLibrary.platform = 3;
+				} else {
+					NativeLibrary.platform = 2;
+				}
+				NativeLibrary.DEBUG = System.getProperty("gluegen.debug.NativeLibrary") != null;
+				return null;
+			}
+		});
+		switch(platform) {
+			case 1:
+				dynLink = new WindowsDynamicLinkerImpl();
+				prefixes = new String[] { "" };
+				suffixes = new String[] { ".dll" };
+				break;
+			case 2:
+				dynLink = new UnixDynamicLinkerImpl();
+				prefixes = new String[] { "lib" };
+				suffixes = new String[] { ".so" };
+				break;
+			case 3:
+				dynLink = new MacOSXDynamicLinkerImpl();
+				prefixes = new String[] { "lib", "" };
+				suffixes = new String[] { ".dylib", ".jnilib", "" };
+				break;
+			default:
+				throw new InternalError("Platform not initialized properly");
+		}
+		initializedFindLibraryMethod = false;
+		findLibraryMethod = null;
+	}
+}

gl/src/main/java/com/sun/gluegen/runtime/ProcAddressHelper.java

@@ -0,0 +1,26 @@
+package com.sun.gluegen.runtime;
+
+import java.lang.reflect.Field;
+
+public class ProcAddressHelper {
+
+	public static void resetProcAddressTable(Object arg0, DynamicLookupHelper arg1) throws RuntimeException {
+		Class var2 = arg0.getClass();
+		Field[] var3 = var2.getFields();
+		for (int var4 = 0; var4 < var3.length; var4++) {
+			String var5 = var3[var4].getName();
+			if (var5.startsWith("_addressof_")) {
+				int var6 = "_addressof_".length();
+				String var7 = var5.substring(var6);
+				try {
+					Field var8 = var3[var4];
+					assert var8.getType() == Long.TYPE;
+					long var9 = arg1.dynamicLookupFunction(var7);
+					var8.setLong(arg0, var9);
+				} catch (Exception var11) {
+					throw new RuntimeException("Can not get proc address for method \"" + var7 + "\": Couldn't set value of field \"" + var5 + "\" in class " + var2.getName(), var11);
+				}
+			}
+		}
+	}
+}

gl/src/main/java/com/sun/gluegen/runtime/StructAccessor.java

@@ -0,0 +1,75 @@
+package com.sun.gluegen.runtime;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.IntBuffer;
+import java.nio.LongBuffer;
+import java.nio.ShortBuffer;
+
+public class StructAccessor {
+
+	private ByteBuffer bb;
+
+	private IntBuffer ib;
+
+	private LongBuffer lb;
+
+	private ShortBuffer sb;
+
+	public StructAccessor(ByteBuffer arg0) {
+		this.bb = arg0.order(ByteOrder.nativeOrder());
+	}
+
+	public ByteBuffer getBuffer() {
+		return this.bb;
+	}
+
+	public byte getByteAt(int arg0) {
+		return this.bb.get(arg0);
+	}
+
+	public void setByteAt(int arg0, byte arg1) {
+		this.bb.put(arg0, arg1);
+	}
+
+	public int getIntAt(int arg0) {
+		return this.intBuffer().get(arg0);
+	}
+
+	public void setIntAt(int arg0, int arg1) {
+		this.intBuffer().put(arg0, arg1);
+	}
+
+	public long getLongAt(int arg0) {
+		return this.longBuffer().get(arg0);
+	}
+
+	public void setLongAt(int arg0, long arg1) {
+		this.longBuffer().put(arg0, arg1);
+	}
+
+	public void setShortAt(int arg0, short arg1) {
+		this.shortBuffer().put(arg0, arg1);
+	}
+
+	private IntBuffer intBuffer() {
+		if (this.ib == null) {
+			this.ib = this.bb.asIntBuffer();
+		}
+		return this.ib;
+	}
+
+	private LongBuffer longBuffer() {
+		if (this.lb == null) {
+			this.lb = this.bb.asLongBuffer();
+		}
+		return this.lb;
+	}
+
+	private ShortBuffer shortBuffer() {
+		if (this.sb == null) {
+			this.sb = this.bb.asShortBuffer();
+		}
+		return this.sb;
+	}
+}

gl/src/main/java/com/sun/gluegen/runtime/UnixDynamicLinkerImpl.java

@@ -0,0 +1,16 @@
+package com.sun.gluegen.runtime;
+
+public class UnixDynamicLinkerImpl implements DynamicLinker {
+
+	private static native int dlclose(long arg0);
+
+	private static native long dlopen(String arg0, int arg1);
+
+	public long openLibrary(String arg0) {
+		return dlopen(arg0, 257);
+	}
+
+	public void closeLibrary(long arg0) {
+		dlclose(arg0);
+	}
+}

gl/src/main/java/com/sun/gluegen/runtime/WindowsDynamicLinkerImpl.java

@@ -0,0 +1,16 @@
+package com.sun.gluegen.runtime;
+
+public class WindowsDynamicLinkerImpl implements DynamicLinker {
+
+	private static native int FreeLibrary(long arg0);
+
+	private static native long LoadLibraryA(String arg0);
+
+	public long openLibrary(String arg0) {
+		return LoadLibraryA(arg0);
+	}
+
+	public void closeLibrary(long arg0) {
+		FreeLibrary(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/FunctionAvailabilityCache.java

@@ -0,0 +1,150 @@
+package com.sun.opengl.impl;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.StringTokenizer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.media.opengl.GL;
+
+public final class FunctionAvailabilityCache {
+
+	private HashMap availabilityCache = new HashMap(50);
+
+	private HashSet availableExtensionCache = new HashSet(50);
+
+	private GLContextImpl context;
+
+	FunctionAvailabilityCache(GLContextImpl arg0) {
+		this.context = arg0;
+	}
+
+	public void flush() {
+		this.availabilityCache.clear();
+		this.availableExtensionCache.clear();
+	}
+
+	public boolean isExtensionAvailable(String arg0) {
+		this.initAvailableExtensions();
+		return this.availableExtensionCache.contains(mapGLExtensionName(arg0));
+	}
+
+	protected void initAvailableExtensions() {
+		if (!this.availableExtensionCache.isEmpty()) {
+			return;
+		}
+		GL var1 = this.context.getGL();
+		String var2 = var1.glGetString(GL.GL_EXTENSIONS) + " " + this.context.getPlatformExtensionsString();
+		StringTokenizer var3 = new StringTokenizer(var2);
+		while (var3.hasMoreTokens()) {
+			String var4 = var3.nextToken().trim();
+			String var7 = var4.intern();
+			this.availableExtensionCache.add(var7);
+		}
+		FunctionAvailabilityCache.Version var8 = new FunctionAvailabilityCache.Version(var1.glGetString(GL.GL_VERSION));
+		int var5 = var8.getMajor();
+		int var6 = var8.getMinor();
+		while (var5 > 0) {
+			while (var6 >= 0) {
+				this.availableExtensionCache.add("GL_VERSION_" + var5 + "_" + var6);
+				var6--;
+			}
+			switch(var5) {
+				case 2:
+					var6 = 5;
+				case 1:
+				default:
+					var5--;
+			}
+		}
+		this.availableExtensionCache.add("<INTERNAL_DUMMY_PLACEHOLDER>");
+	}
+
+	private static String mapGLExtensionName(String arg0) {
+		return arg0 != null && (arg0.equals("WGL_NV_vertex_array_range") || arg0.equals("GLX_NV_vertex_array_range")) ? "GL_NV_vertex_array_range" : arg0;
+	}
+
+	private static class Version implements Comparable {
+
+		private int major;
+
+		private int minor;
+
+		private int sub;
+
+		public Version(String arg0) {
+			try {
+				StringTokenizer var2;
+				if (arg0.startsWith("GL_VERSION_")) {
+					var2 = new StringTokenizer(arg0, "_");
+					var2.nextToken();
+					var2.nextToken();
+					if (!var2.hasMoreTokens()) {
+						this.major = 0;
+						return;
+					}
+					this.major = Integer.valueOf(var2.nextToken());
+					if (!var2.hasMoreTokens()) {
+						this.minor = 0;
+						return;
+					}
+					this.minor = Integer.valueOf(var2.nextToken());
+					if (!var2.hasMoreTokens()) {
+						this.sub = 0;
+						return;
+					}
+					this.sub = Integer.valueOf(var2.nextToken());
+				} else {
+					var2 = new StringTokenizer(arg0, ". ");
+					this.major = Integer.valueOf(var2.nextToken());
+					this.minor = Integer.valueOf(var2.nextToken());
+					var2 = new StringTokenizer(arg0, " ");
+					if (var2.hasMoreTokens()) {
+						var2.nextToken();
+						if (var2.hasMoreTokens()) {
+							Pattern var3 = Pattern.compile("\\D*(\\d+)\\.(\\d+)\\.?(\\d*).*");
+							Matcher var4 = var3.matcher(var2.nextToken());
+							if (var4.matches()) {
+								int var5 = Integer.valueOf(var4.group(1));
+								int var6 = Integer.valueOf(var4.group(2));
+								if (var5 == this.major && var6 > this.minor || var5 == this.major + 1) {
+									this.major = var5;
+									this.minor = var6;
+								}
+							}
+						}
+					}
+				}
+			} catch (Exception var7) {
+				throw (IllegalArgumentException) (new IllegalArgumentException("Illegally formatted version identifier: \"" + arg0 + "\"")).initCause(var7);
+			}
+		}
+
+		public int compareTo(Object arg0) {
+			FunctionAvailabilityCache.Version var2 = (FunctionAvailabilityCache.Version) arg0;
+			if (this.major > var2.major) {
+				return 1;
+			} else if (this.major < var2.major) {
+				return -1;
+			} else if (this.minor > var2.minor) {
+				return 1;
+			} else if (this.minor < var2.minor) {
+				return -1;
+			} else if (this.sub > var2.sub) {
+				return 1;
+			} else if (this.sub < var2.sub) {
+				return -1;
+			} else {
+				return 0;
+			}
+		}
+
+		public int getMajor() {
+			return this.major;
+		}
+
+		public int getMinor() {
+			return this.minor;
+		}
+	}
+}

gl/src/main/java/com/sun/opengl/impl/GLContextImpl.java

@@ -0,0 +1,96 @@
+package com.sun.opengl.impl;
+
+import com.sun.gluegen.runtime.ProcAddressHelper;
+import javax.media.opengl.GL;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLException;
+
+public abstract class GLContextImpl extends GLContext {
+
+	protected FunctionAvailabilityCache functionAvailability = new FunctionAvailabilityCache(this);
+
+	private GLProcAddressTable glProcAddressTable;
+
+	protected GL gl;
+
+	public GLContextImpl() {
+		this.setGL(this.createGL());
+	}
+
+	public int makeCurrent() throws GLException {
+		GLContext var1 = getCurrent();
+		if (var1 == this) {
+			this.update();
+			return 1;
+		}
+		if (var1 != null) {
+			var1.release();
+		}
+		int var2 = this.makeCurrentImpl();
+		if (var2 != 0) {
+			setCurrent(this);
+		}
+		return var2;
+	}
+
+	protected abstract int makeCurrentImpl() throws GLException;
+
+	public void release() throws GLException {
+		setCurrent(null);
+		this.releaseImpl();
+	}
+
+	protected abstract void releaseImpl() throws GLException;
+
+	public void destroy() {
+		this.destroyImpl();
+	}
+
+	protected abstract void destroyImpl() throws GLException;
+
+	protected void update() throws GLException {
+	}
+
+	public GL getGL() {
+		return this.gl;
+	}
+
+	public void setGL(GL arg0) {
+		this.gl = arg0;
+	}
+
+	protected GL createGL() {
+		return new GLImpl(this);
+	}
+
+	public GLProcAddressTable getGLProcAddressTable() {
+		if (this.glProcAddressTable == null) {
+			this.glProcAddressTable = new GLProcAddressTable();
+		}
+		return this.glProcAddressTable;
+	}
+
+	public abstract void setSwapInterval(int arg0);
+
+	protected abstract String mapToRealGLExtensionName(String arg0);
+
+	public abstract String getPlatformExtensionsString();
+
+	protected void resetProcAddressTable(Object arg0) {
+		ProcAddressHelper.resetProcAddressTable(arg0, GLDrawableFactoryImpl.getFactoryImpl());
+	}
+
+	protected void resetGLFunctionAvailability() {
+		this.setGL(this.createGL());
+		this.functionAvailability.flush();
+		this.resetProcAddressTable(this.getGLProcAddressTable());
+	}
+
+	public boolean isExtensionAvailable(String arg0) {
+		return this.functionAvailability.isExtensionAvailable(this.mapToRealGLExtensionName(arg0));
+	}
+
+	public static String toHexString(long arg0) {
+		return "0x" + Long.toHexString(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/GLDrawableFactoryImpl.java

@@ -0,0 +1,13 @@
+package com.sun.opengl.impl;
+
+import com.sun.gluegen.runtime.DynamicLookupHelper;
+import javax.media.opengl.GLDrawableFactory;
+
+public abstract class GLDrawableFactoryImpl extends GLDrawableFactory implements DynamicLookupHelper {
+
+	public abstract long dynamicLookupFunction(String arg0);
+
+	public static GLDrawableFactoryImpl getFactoryImpl() {
+		return (GLDrawableFactoryImpl) getFactory();
+	}
+}

gl/src/main/java/com/sun/opengl/impl/GLDrawableImpl.java

@@ -0,0 +1,21 @@
+package com.sun.opengl.impl;
+
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLDrawable;
+
+public abstract class GLDrawableImpl implements GLDrawable {
+
+	private GLCapabilities chosenCapabilities;
+
+	public static String toHexString(long arg0) {
+		return GLContextImpl.toHexString(arg0);
+	}
+
+	public GLCapabilities getChosenGLCapabilities() {
+		return this.chosenCapabilities == null ? null : (GLCapabilities) this.chosenCapabilities.clone();
+	}
+
+	public void setChosenGLCapabilities(GLCapabilities arg0) {
+		this.chosenCapabilities = arg0;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/GLImpl.java

@@ -0,0 +1,814 @@
+package com.sun.opengl.impl;
+
+import com.sun.gluegen.runtime.BufferFactory;
+import java.nio.Buffer;
+import java.nio.FloatBuffer;
+import java.util.HashMap;
+import java.util.Map;
+import javax.media.opengl.GL;
+import javax.media.opengl.GLException;
+
+public class GLImpl implements GL {
+
+	private boolean inBeginEndPair;
+
+	private GLContextImpl _context;
+
+	private boolean bufferObjectExtensionsInitialized = false;
+
+	private boolean haveARBPixelBufferObject;
+
+	private boolean haveEXTPixelBufferObject;
+
+	private boolean haveGL15;
+
+	private boolean haveGL21;
+
+	private boolean haveARBVertexBufferObject;
+
+	private Map arbVBOCache = new HashMap();
+
+	public void glActiveTexture(int arg0) {
+		long var2 = this._context.getGLProcAddressTable()._addressof_glActiveTexture;
+		if (var2 == 0L) {
+			var2 = this._context.getGLProcAddressTable()._addressof_glActiveTextureARB;
+			if (var2 == 0L) {
+				throw new GLException("Method \"glActiveTexture\" not available");
+			}
+		}
+		this.dispatch_glActiveTexture0(arg0, var2);
+	}
+
+	public native void dispatch_glActiveTexture0(int arg0, long arg1);
+
+	public native void glAlphaFunc(int arg0, float arg1);
+
+	public void glBegin(int arg0) {
+		this.inBeginEndPair = true;
+		this.glBegin0(arg0);
+	}
+
+	private native void glBegin0(int arg0);
+
+	public void glBindBufferARB(int arg0, int arg1) {
+		long var3 = this._context.getGLProcAddressTable()._addressof_glBindBufferARB;
+		if (var3 == 0L) {
+			throw new GLException("Method \"glBindBufferARB\" not available");
+		}
+		this.dispatch_glBindBufferARB0(arg0, arg1, var3);
+	}
+
+	public native void dispatch_glBindBufferARB0(int arg0, int arg1, long arg2);
+
+	public void glBindProgramARB(int arg0, int arg1) {
+		long var3 = this._context.getGLProcAddressTable()._addressof_glBindProgramARB;
+		if (var3 == 0L) {
+			throw new GLException("Method \"glBindProgramARB\" not available");
+		}
+		this.dispatch_glBindProgramARB0(arg0, arg1, var3);
+	}
+
+	public native void dispatch_glBindProgramARB0(int arg0, int arg1, long arg2);
+
+	public native void glBindTexture(int arg0, int arg1);
+
+	public native void glBlendFunc(int arg0, int arg1);
+
+	public void glBufferDataARB(int arg0, int arg1, Buffer arg2, int arg3) {
+		boolean var5 = BufferFactory.isDirect(arg2);
+		long var6 = this._context.getGLProcAddressTable()._addressof_glBufferDataARB;
+		if (var6 == 0L) {
+			throw new GLException("Method \"glBufferDataARB\" not available");
+		} else if (var5) {
+			this.dispatch_glBufferDataARB0(arg0, arg1, arg2, BufferFactory.getDirectBufferByteOffset(arg2), arg3, var6);
+		} else {
+			this.dispatch_glBufferDataARB1(arg0, arg1, BufferFactory.getArray(arg2), BufferFactory.getIndirectBufferByteOffset(arg2), arg3, var6);
+		}
+	}
+
+	private native void dispatch_glBufferDataARB0(int arg0, int arg1, Object arg2, int arg3, int arg4, long arg5);
+
+	private native void dispatch_glBufferDataARB1(int arg0, int arg1, Object arg2, int arg3, int arg4, long arg5);
+
+	public void glBufferSubDataARB(int arg0, int arg1, int arg2, Buffer arg3) {
+		boolean var5 = BufferFactory.isDirect(arg3);
+		long var6 = this._context.getGLProcAddressTable()._addressof_glBufferSubDataARB;
+		if (var6 == 0L) {
+			throw new GLException("Method \"glBufferSubDataARB\" not available");
+		} else if (var5) {
+			this.dispatch_glBufferSubDataARB0(arg0, arg1, arg2, arg3, BufferFactory.getDirectBufferByteOffset(arg3), var6);
+		} else {
+			this.dispatch_glBufferSubDataARB1(arg0, arg1, arg2, BufferFactory.getArray(arg3), BufferFactory.getIndirectBufferByteOffset(arg3), var6);
+		}
+	}
+
+	private native void dispatch_glBufferSubDataARB0(int arg0, int arg1, int arg2, Object arg3, int arg4, long arg5);
+
+	private native void dispatch_glBufferSubDataARB1(int arg0, int arg1, int arg2, Object arg3, int arg4, long arg5);
+
+	public native void glCallList(int arg0);
+
+	public native void glClear(int arg0);
+
+	public native void glClearColor(float arg0, float arg1, float arg2, float arg3);
+
+	public native void glClearDepth(double arg0);
+
+	public void glClientActiveTexture(int arg0) {
+		long var2 = this._context.getGLProcAddressTable()._addressof_glClientActiveTexture;
+		if (var2 == 0L) {
+			var2 = this._context.getGLProcAddressTable()._addressof_glClientActiveTextureARB;
+			if (var2 == 0L) {
+				throw new GLException("Method \"glClientActiveTexture\" not available");
+			}
+		}
+		this.dispatch_glClientActiveTexture0(arg0, var2);
+	}
+
+	public native void dispatch_glClientActiveTexture0(int arg0, long arg1);
+
+	public native void glColor3ub(byte arg0, byte arg1, byte arg2);
+
+	public native void glColor4f(float arg0, float arg1, float arg2, float arg3);
+
+	private native void glColor4fv1(Object arg0, int arg1);
+
+	public void glColor4fv(float[] arg0, int arg1) {
+		if (arg0 != null && arg0.length <= arg1) {
+			throw new GLException("array offset argument \"v_offset\" (" + arg1 + ") equals or exceeds array length (" + arg0.length + ")");
+		}
+		this.glColor4fv1(arg0, arg1 * 4);
+	}
+
+	public native void glColor4ub(byte arg0, byte arg1, byte arg2, byte arg3);
+
+	public native void glColorMaterial(int arg0, int arg1);
+
+	public void glColorPointer(int arg0, int arg1, int arg2, Buffer arg3) {
+		this.checkArrayVBODisabled();
+		BufferFactory.rangeCheck(arg3, 1);
+		if (!BufferFactory.isDirect(arg3)) {
+			throw new GLException("Argument \"ptr\" was not a direct buffer");
+		}
+		this.glColorPointer0(arg0, arg1, arg2, arg3, BufferFactory.getDirectBufferByteOffset(arg3));
+	}
+
+	private native void glColorPointer0(int arg0, int arg1, int arg2, Object arg3, int arg4);
+
+	public void glColorPointer(int arg0, int arg1, int arg2, long arg3) {
+		this.checkArrayVBOEnabled();
+		this.glColorPointer0(arg0, arg1, arg2, arg3);
+	}
+
+	private native void glColorPointer0(int arg0, int arg1, int arg2, long arg3);
+
+	public native void glCopyPixels(int arg0, int arg1, int arg2, int arg3, int arg4);
+
+	public native void glCullFace(int arg0);
+
+	private native void dispatch_glDeleteBuffersARB1(int arg0, Object arg1, int arg2, long arg3);
+
+	public void glDeleteBuffersARB(int arg0, int[] arg1, int arg2) {
+		BufferFactory.rangeCheck(arg1, arg2, arg0);
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"ids_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		}
+		long var4 = this._context.getGLProcAddressTable()._addressof_glDeleteBuffersARB;
+		if (var4 == 0L) {
+			throw new GLException("Method \"glDeleteBuffersARB\" not available");
+		}
+		this.dispatch_glDeleteBuffersARB1(arg0, arg1, arg2 * 4, var4);
+	}
+
+	public void glDeleteLists(int arg0, int arg1) {
+		this.glDeleteLists0(arg0, arg1);
+	}
+
+	private native void glDeleteLists0(int arg0, int arg1);
+
+	private native void glDeleteTextures1(int arg0, Object arg1, int arg2);
+
+	public void glDeleteTextures(int arg0, int[] arg1, int arg2) {
+		BufferFactory.rangeCheck(arg1, arg2, arg0);
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"textures_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		}
+		this.glDeleteTextures1(arg0, arg1, arg2 * 4);
+	}
+
+	public native void glDepthFunc(int arg0);
+
+	public native void glDepthMask(boolean arg0);
+
+	public native void glDisable(int arg0);
+
+	public native void glDisableClientState(int arg0);
+
+	public native void glDrawBuffer(int arg0);
+
+	public void glDrawElements(int arg0, int arg1, int arg2, Buffer arg3) {
+		this.checkElementVBODisabled();
+		BufferFactory.rangeCheck(arg3, arg1);
+		boolean var5 = BufferFactory.isDirect(arg3);
+		if (var5) {
+			this.glDrawElements0(arg0, arg1, arg2, arg3, BufferFactory.getDirectBufferByteOffset(arg3));
+		} else {
+			this.glDrawElements1(arg0, arg1, arg2, BufferFactory.getArray(arg3), BufferFactory.getIndirectBufferByteOffset(arg3));
+		}
+	}
+
+	private native void glDrawElements0(int arg0, int arg1, int arg2, Object arg3, int arg4);
+
+	private native void glDrawElements1(int arg0, int arg1, int arg2, Object arg3, int arg4);
+
+	public void glDrawElements(int arg0, int arg1, int arg2, long arg3) {
+		this.checkElementVBOEnabled();
+		this.glDrawElements0(arg0, arg1, arg2, arg3);
+	}
+
+	private native void glDrawElements0(int arg0, int arg1, int arg2, long arg3);
+
+	public void glDrawPixels(int arg0, int arg1, int arg2, int arg3, Buffer arg4) {
+		this.checkUnpackPBODisabled();
+		BufferFactory.rangeCheckBytes(arg4, this.imageSizeInBytes(arg2, arg3, arg0, arg1, 1));
+		boolean var6 = BufferFactory.isDirect(arg4);
+		if (var6) {
+			this.glDrawPixels0(arg0, arg1, arg2, arg3, arg4, BufferFactory.getDirectBufferByteOffset(arg4));
+		} else {
+			this.glDrawPixels1(arg0, arg1, arg2, arg3, BufferFactory.getArray(arg4), BufferFactory.getIndirectBufferByteOffset(arg4));
+		}
+	}
+
+	private native void glDrawPixels0(int arg0, int arg1, int arg2, int arg3, Object arg4, int arg5);
+
+	private native void glDrawPixels1(int arg0, int arg1, int arg2, int arg3, Object arg4, int arg5);
+
+	public native void glEnable(int arg0);
+
+	public native void glEnableClientState(int arg0);
+
+	public void glEnd() {
+		this.glEnd0();
+		this.inBeginEndPair = false;
+	}
+
+	private native void glEnd0();
+
+	public native void glEndList();
+
+	public native void glFogf(int arg0, float arg1);
+
+	private native void glFogfv1(int arg0, Object arg1, int arg2);
+
+	public void glFogfv(int arg0, float[] arg1, int arg2) {
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"params_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		}
+		this.glFogfv1(arg0, arg1, arg2 * 4);
+	}
+
+	public native void glFogi(int arg0, int arg1);
+
+	private native void dispatch_glGenBuffersARB1(int arg0, Object arg1, int arg2, long arg3);
+
+	public void glGenBuffersARB(int arg0, int[] arg1, int arg2) {
+		BufferFactory.rangeCheck(arg1, arg2, arg0);
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"ids_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		}
+		long var4 = this._context.getGLProcAddressTable()._addressof_glGenBuffersARB;
+		if (var4 == 0L) {
+			throw new GLException("Method \"glGenBuffersARB\" not available");
+		}
+		this.dispatch_glGenBuffersARB1(arg0, arg1, arg2 * 4, var4);
+	}
+
+	public int glGenLists(int arg0) {
+		return this.glGenLists0(arg0);
+	}
+
+	private native int glGenLists0(int arg0);
+
+	private native void dispatch_glGenProgramsARB1(int arg0, Object arg1, int arg2, long arg3);
+
+	public void glGenProgramsARB(int arg0, int[] arg1, int arg2) {
+		BufferFactory.rangeCheck(arg1, arg2, arg0);
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"ids_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		}
+		long var4 = this._context.getGLProcAddressTable()._addressof_glGenProgramsARB;
+		if (var4 == 0L) {
+			throw new GLException("Method \"glGenProgramsARB\" not available");
+		}
+		this.dispatch_glGenProgramsARB1(arg0, arg1, arg2 * 4, var4);
+	}
+
+	private native void glGenTextures1(int arg0, Object arg1, int arg2);
+
+	public void glGenTextures(int arg0, int[] arg1, int arg2) {
+		BufferFactory.rangeCheck(arg1, arg2, arg0);
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"textures_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		}
+		this.glGenTextures1(arg0, arg1, arg2 * 4);
+	}
+
+	public void glGetFloatv(int arg0, FloatBuffer arg1) {
+		boolean var3 = BufferFactory.isDirect(arg1);
+		if (var3) {
+			this.glGetFloatv0(arg0, arg1, BufferFactory.getDirectBufferByteOffset(arg1));
+		} else {
+			this.glGetFloatv1(arg0, BufferFactory.getArray(arg1), BufferFactory.getIndirectBufferByteOffset(arg1));
+		}
+	}
+
+	private native void glGetFloatv0(int arg0, Object arg1, int arg2);
+
+	private native void glGetFloatv1(int arg0, Object arg1, int arg2);
+
+	public void glGetFloatv(int arg0, float[] arg1, int arg2) {
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"params_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		}
+		this.glGetFloatv1(arg0, arg1, arg2 * 4);
+	}
+
+	private native void glGetIntegerv1(int arg0, Object arg1, int arg2);
+
+	public void glGetIntegerv(int arg0, int[] arg1, int arg2) {
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"params_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		}
+		this.glGetIntegerv1(arg0, arg1, arg2 * 4);
+	}
+
+	public native String glGetString(int arg0);
+
+	private native void glGetTexLevelParameteriv1(int arg0, int arg1, int arg2, Object arg3, int arg4);
+
+	public void glGetTexLevelParameteriv(int arg0, int arg1, int arg2, int[] arg3, int arg4) {
+		if (arg3 != null && arg3.length <= arg4) {
+			throw new GLException("array offset argument \"params_offset\" (" + arg4 + ") equals or exceeds array length (" + arg3.length + ")");
+		}
+		this.glGetTexLevelParameteriv1(arg0, arg1, arg2, arg3, arg4 * 4);
+	}
+
+	public native void glHint(int arg0, int arg1);
+
+	public void glInterleavedArrays(int arg0, int arg1, Buffer arg2) {
+		this.checkArrayVBODisabled();
+		BufferFactory.rangeCheck(arg2, 1);
+		boolean var4 = BufferFactory.isDirect(arg2);
+		if (var4) {
+			this.glInterleavedArrays0(arg0, arg1, arg2, BufferFactory.getDirectBufferByteOffset(arg2));
+		} else {
+			this.glInterleavedArrays1(arg0, arg1, BufferFactory.getArray(arg2), BufferFactory.getIndirectBufferByteOffset(arg2));
+		}
+	}
+
+	private native void glInterleavedArrays0(int arg0, int arg1, Object arg2, int arg3);
+
+	private native void glInterleavedArrays1(int arg0, int arg1, Object arg2, int arg3);
+
+	public void glInterleavedArrays(int arg0, int arg1, long arg2) {
+		this.checkArrayVBOEnabled();
+		this.glInterleavedArrays0(arg0, arg1, arg2);
+	}
+
+	private native void glInterleavedArrays0(int arg0, int arg1, long arg2);
+
+	private native void glLightModelfv1(int arg0, Object arg1, int arg2);
+
+	public void glLightModelfv(int arg0, float[] arg1, int arg2) {
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"params_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		}
+		this.glLightModelfv1(arg0, arg1, arg2 * 4);
+	}
+
+	public native void glLightf(int arg0, int arg1, float arg2);
+
+	private native void glLightfv1(int arg0, int arg1, Object arg2, int arg3);
+
+	public void glLightfv(int arg0, int arg1, float[] arg2, int arg3) {
+		if (arg2 != null && arg2.length <= arg3) {
+			throw new GLException("array offset argument \"params_offset\" (" + arg3 + ") equals or exceeds array length (" + arg2.length + ")");
+		}
+		this.glLightfv1(arg0, arg1, arg2, arg3 * 4);
+	}
+
+	public native void glLoadIdentity();
+
+	private native void glLoadMatrixf1(Object arg0, int arg1);
+
+	public void glLoadMatrixf(float[] arg0, int arg1) {
+		if (arg0 != null && arg0.length <= arg1) {
+			throw new GLException("array offset argument \"m_offset\" (" + arg1 + ") equals or exceeds array length (" + arg0.length + ")");
+		}
+		this.glLoadMatrixf1(arg0, arg1 * 4);
+	}
+
+	public native void glMatrixMode(int arg0);
+
+	public void glMultiTexCoord2f(int arg0, float arg1, float arg2) {
+		long var4 = this._context.getGLProcAddressTable()._addressof_glMultiTexCoord2f;
+		if (var4 == 0L) {
+			var4 = this._context.getGLProcAddressTable()._addressof_glMultiTexCoord2fARB;
+			if (var4 == 0L) {
+				throw new GLException("Method \"glMultiTexCoord2f\" not available");
+			}
+		}
+		this.dispatch_glMultiTexCoord2f0(arg0, arg1, arg2, var4);
+	}
+
+	public native void dispatch_glMultiTexCoord2f0(int arg0, float arg1, float arg2, long arg3);
+
+	public native void glNewList(int arg0, int arg1);
+
+	public void glNormalPointer(int arg0, int arg1, Buffer arg2) {
+		this.checkArrayVBODisabled();
+		BufferFactory.rangeCheck(arg2, 1);
+		if (!BufferFactory.isDirect(arg2)) {
+			throw new GLException("Argument \"ptr\" was not a direct buffer");
+		}
+		this.glNormalPointer0(arg0, arg1, arg2, BufferFactory.getDirectBufferByteOffset(arg2));
+	}
+
+	private native void glNormalPointer0(int arg0, int arg1, Object arg2, int arg3);
+
+	public void glNormalPointer(int arg0, int arg1, long arg2) {
+		this.checkArrayVBOEnabled();
+		this.glNormalPointer0(arg0, arg1, arg2);
+	}
+
+	private native void glNormalPointer0(int arg0, int arg1, long arg2);
+
+	public native void glOrtho(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5);
+
+	public native void glPixelStorei(int arg0, int arg1);
+
+	public native void glPixelZoom(float arg0, float arg1);
+
+	public void glPointParameterfARB(int arg0, float arg1) {
+		long var3 = this._context.getGLProcAddressTable()._addressof_glPointParameterfARB;
+		if (var3 == 0L) {
+			throw new GLException("Method \"glPointParameterfARB\" not available");
+		}
+		this.dispatch_glPointParameterfARB0(arg0, arg1, var3);
+	}
+
+	public native void dispatch_glPointParameterfARB0(int arg0, float arg1, long arg2);
+
+	private native void dispatch_glPointParameterfvARB1(int arg0, Object arg1, int arg2, long arg3);
+
+	public void glPointParameterfvARB(int arg0, float[] arg1, int arg2) {
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"v_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		}
+		long var4 = this._context.getGLProcAddressTable()._addressof_glPointParameterfvARB;
+		if (var4 == 0L) {
+			throw new GLException("Method \"glPointParameterfvARB\" not available");
+		}
+		this.dispatch_glPointParameterfvARB1(arg0, arg1, arg2 * 4, var4);
+	}
+
+	public native void glPolygonMode(int arg0, int arg1);
+
+	public native void glPopAttrib();
+
+	public native void glPopMatrix();
+
+	public void glProgramLocalParameter4fARB(int arg0, int arg1, float arg2, float arg3, float arg4, float arg5) {
+		long var7 = this._context.getGLProcAddressTable()._addressof_glProgramLocalParameter4fARB;
+		if (var7 == 0L) {
+			throw new GLException("Method \"glProgramLocalParameter4fARB\" not available");
+		}
+		this.dispatch_glProgramLocalParameter4fARB0(arg0, arg1, arg2, arg3, arg4, arg5, var7);
+	}
+
+	public native void dispatch_glProgramLocalParameter4fARB0(int arg0, int arg1, float arg2, float arg3, float arg4, float arg5, long arg6);
+
+	public void glProgramLocalParameter4fvARB(int arg0, int arg1, FloatBuffer arg2) {
+		boolean var4 = BufferFactory.isDirect(arg2);
+		long var5 = this._context.getGLProcAddressTable()._addressof_glProgramLocalParameter4fvARB;
+		if (var5 == 0L) {
+			throw new GLException("Method \"glProgramLocalParameter4fvARB\" not available");
+		} else if (var4) {
+			this.dispatch_glProgramLocalParameter4fvARB0(arg0, arg1, arg2, BufferFactory.getDirectBufferByteOffset(arg2), var5);
+		} else {
+			this.dispatch_glProgramLocalParameter4fvARB1(arg0, arg1, BufferFactory.getArray(arg2), BufferFactory.getIndirectBufferByteOffset(arg2), var5);
+		}
+	}
+
+	private native void dispatch_glProgramLocalParameter4fvARB0(int arg0, int arg1, Object arg2, int arg3, long arg4);
+
+	private native void dispatch_glProgramLocalParameter4fvARB1(int arg0, int arg1, Object arg2, int arg3, long arg4);
+
+	public void glProgramLocalParameter4fvARB(int arg0, int arg1, float[] arg2, int arg3) {
+		if (arg2 != null && arg2.length <= arg3) {
+			throw new GLException("array offset argument \"params_offset\" (" + arg3 + ") equals or exceeds array length (" + arg2.length + ")");
+		}
+		long var5 = this._context.getGLProcAddressTable()._addressof_glProgramLocalParameter4fvARB;
+		if (var5 == 0L) {
+			throw new GLException("Method \"glProgramLocalParameter4fvARB\" not available");
+		}
+		this.dispatch_glProgramLocalParameter4fvARB1(arg0, arg1, arg2, arg3 * 4, var5);
+	}
+
+	public void glProgramStringARB(int arg0, int arg1, int arg2, String arg3) {
+		long var5 = this._context.getGLProcAddressTable()._addressof_glProgramStringARB;
+		if (var5 == 0L) {
+			throw new GLException("Method \"glProgramStringARB\" not available");
+		}
+		this.dispatch_glProgramStringARB0(arg0, arg1, arg2, arg3, var5);
+	}
+
+	public native void dispatch_glProgramStringARB0(int arg0, int arg1, int arg2, String arg3, long arg4);
+
+	public native void glPushAttrib(int arg0);
+
+	public native void glPushMatrix();
+
+	public native void glRasterPos2i(int arg0, int arg1);
+
+	public native void glReadBuffer(int arg0);
+
+	public native void glRotatef(float arg0, float arg1, float arg2, float arg3);
+
+	public native void glScalef(float arg0, float arg1, float arg2);
+
+	public native void glScissor(int arg0, int arg1, int arg2, int arg3);
+
+	public native void glShadeModel(int arg0);
+
+	public native void glTexCoord2f(float arg0, float arg1);
+
+	public void glTexCoordPointer(int arg0, int arg1, int arg2, Buffer arg3) {
+		this.checkArrayVBODisabled();
+		BufferFactory.rangeCheck(arg3, 1);
+		if (!BufferFactory.isDirect(arg3)) {
+			throw new GLException("Argument \"ptr\" was not a direct buffer");
+		}
+		this.glTexCoordPointer0(arg0, arg1, arg2, arg3, BufferFactory.getDirectBufferByteOffset(arg3));
+	}
+
+	private native void glTexCoordPointer0(int arg0, int arg1, int arg2, Object arg3, int arg4);
+
+	public void glTexCoordPointer(int arg0, int arg1, int arg2, long arg3) {
+		this.checkArrayVBOEnabled();
+		this.glTexCoordPointer0(arg0, arg1, arg2, arg3);
+	}
+
+	private native void glTexCoordPointer0(int arg0, int arg1, int arg2, long arg3);
+
+	public native void glTexEnvf(int arg0, int arg1, float arg2);
+
+	private native void glTexEnvfv1(int arg0, int arg1, Object arg2, int arg3);
+
+	public void glTexEnvfv(int arg0, int arg1, float[] arg2, int arg3) {
+		if (arg2 != null && arg2.length <= arg3) {
+			throw new GLException("array offset argument \"params_offset\" (" + arg3 + ") equals or exceeds array length (" + arg2.length + ")");
+		}
+		this.glTexEnvfv1(arg0, arg1, arg2, arg3 * 4);
+	}
+
+	public native void glTexEnvi(int arg0, int arg1, int arg2);
+
+	private native void glTexGenfv1(int arg0, int arg1, Object arg2, int arg3);
+
+	public void glTexGenfv(int arg0, int arg1, float[] arg2, int arg3) {
+		if (arg2 != null && arg2.length <= arg3) {
+			throw new GLException("array offset argument \"params_offset\" (" + arg3 + ") equals or exceeds array length (" + arg2.length + ")");
+		}
+		this.glTexGenfv1(arg0, arg1, arg2, arg3 * 4);
+	}
+
+	public native void glTexGeni(int arg0, int arg1, int arg2);
+
+	public void glTexImage1D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, Buffer arg7) {
+		this.checkUnpackPBODisabled();
+		BufferFactory.rangeCheckBytes(arg7, this.imageSizeInBytes(arg5, arg6, arg3, 1, 1));
+		boolean var9 = BufferFactory.isDirect(arg7);
+		if (var9) {
+			this.glTexImage1D0(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, BufferFactory.getDirectBufferByteOffset(arg7));
+		} else {
+			this.glTexImage1D1(arg0, arg1, arg2, arg3, arg4, arg5, arg6, BufferFactory.getArray(arg7), BufferFactory.getIndirectBufferByteOffset(arg7));
+		}
+	}
+
+	private native void glTexImage1D0(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, Object arg7, int arg8);
+
+	private native void glTexImage1D1(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, Object arg7, int arg8);
+
+	public void glTexImage2D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, Buffer arg8) {
+		this.checkUnpackPBODisabled();
+		BufferFactory.rangeCheckBytes(arg8, this.imageSizeInBytes(arg6, arg7, arg3, arg4, 1));
+		boolean var10 = BufferFactory.isDirect(arg8);
+		if (var10) {
+			this.glTexImage2D0(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, BufferFactory.getDirectBufferByteOffset(arg8));
+		} else {
+			this.glTexImage2D1(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, BufferFactory.getArray(arg8), BufferFactory.getIndirectBufferByteOffset(arg8));
+		}
+	}
+
+	private native void glTexImage2D0(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, Object arg8, int arg9);
+
+	private native void glTexImage2D1(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, Object arg8, int arg9);
+
+	public void glTexImage3D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, Buffer arg9) {
+		this.checkUnpackPBODisabled();
+		BufferFactory.rangeCheckBytes(arg9, this.imageSizeInBytes(arg7, arg8, arg3, arg4, arg5));
+		boolean var11 = BufferFactory.isDirect(arg9);
+		long var12 = this._context.getGLProcAddressTable()._addressof_glTexImage3D;
+		if (var12 == 0L) {
+			var12 = this._context.getGLProcAddressTable()._addressof_glTexImage3DEXT;
+			if (var12 == 0L) {
+				throw new GLException("Method \"glTexImage3D\" not available");
+			}
+		}
+		if (var11) {
+			this.dispatch_glTexImage3D0(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, BufferFactory.getDirectBufferByteOffset(arg9), var12);
+		} else {
+			this.dispatch_glTexImage3D1(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, BufferFactory.getArray(arg9), BufferFactory.getIndirectBufferByteOffset(arg9), var12);
+		}
+	}
+
+	private native void dispatch_glTexImage3D0(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, Object arg9, int arg10, long arg11);
+
+	private native void dispatch_glTexImage3D1(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, Object arg9, int arg10, long arg11);
+
+	public native void glTexParameteri(int arg0, int arg1, int arg2);
+
+	public native void glTranslatef(float arg0, float arg1, float arg2);
+
+	public native void glVertex2f(float arg0, float arg1);
+
+	public void glVertexPointer(int arg0, int arg1, int arg2, Buffer arg3) {
+		this.checkArrayVBODisabled();
+		BufferFactory.rangeCheck(arg3, 1);
+		if (!BufferFactory.isDirect(arg3)) {
+			throw new GLException("Argument \"ptr\" was not a direct buffer");
+		}
+		this.glVertexPointer0(arg0, arg1, arg2, arg3, BufferFactory.getDirectBufferByteOffset(arg3));
+	}
+
+	private native void glVertexPointer0(int arg0, int arg1, int arg2, Object arg3, int arg4);
+
+	public void glVertexPointer(int arg0, int arg1, int arg2, long arg3) {
+		this.checkArrayVBOEnabled();
+		this.glVertexPointer0(arg0, arg1, arg2, arg3);
+	}
+
+	private native void glVertexPointer0(int arg0, int arg1, int arg2, long arg3);
+
+	public native void glViewport(int arg0, int arg1, int arg2, int arg3);
+
+	public GLImpl(GLContextImpl arg0) {
+		this._context = arg0;
+	}
+
+	public boolean isExtensionAvailable(String arg0) {
+		return this._context.isExtensionAvailable(arg0);
+	}
+
+	public void setSwapInterval(int arg0) {
+		this._context.setSwapInterval(arg0);
+	}
+
+	private int imageSizeInBytes(int arg0, int arg1, int arg2, int arg3, int arg4) {
+		boolean var6 = false;
+		boolean var7 = false;
+		if (arg2 < 0) {
+			return 0;
+		} else if (arg3 < 0) {
+			return 0;
+		} else if (arg4 < 0) {
+			return 0;
+		} else {
+			byte var8;
+			switch(arg0) {
+				case 6400:
+				case 6401:
+					var8 = 1;
+					break;
+				case 6402:
+				case 6403:
+				case 6404:
+				case 6405:
+				case 6406:
+				case 6409:
+					var8 = 1;
+					break;
+				case 6407:
+				case 32992:
+					var8 = 3;
+					break;
+				case 6408:
+				case 32768:
+				case 32993:
+					var8 = 4;
+					break;
+				case 6410:
+					var8 = 2;
+					break;
+				case 34548:
+					var8 = 2;
+					break;
+				default:
+					return 0;
+			}
+			byte var9;
+			switch(arg1) {
+				case 5120:
+				case 5121:
+					var9 = 1;
+					break;
+				case 5122:
+				case 5123:
+					var9 = 2;
+					break;
+				case 5124:
+				case 5125:
+				case 5126:
+					var9 = 4;
+					break;
+				case 6656:
+					if (arg0 == 6400) {
+						return arg4 * arg3 * ((arg2 + 7) / 8);
+					}
+					return 0;
+				case 32818:
+				case 33634:
+					var9 = 1;
+					var8 = 1;
+					break;
+				case 32819:
+				case 32820:
+				case 33635:
+				case 33636:
+				case 33637:
+				case 33638:
+					var9 = 2;
+					var8 = 1;
+					break;
+				case 32821:
+				case 32822:
+				case 33639:
+				case 33640:
+					var9 = 4;
+					var8 = 1;
+					break;
+				default:
+					return 0;
+			}
+			return var8 * var9 * arg2 * arg3 * arg4;
+		}
+	}
+
+	private void initBufferObjectExtensionChecks() {
+		if (this.bufferObjectExtensionsInitialized) {
+			return;
+		}
+		this.bufferObjectExtensionsInitialized = true;
+		this.haveARBPixelBufferObject = this.isExtensionAvailable("GL_ARB_pixel_buffer_object");
+		this.haveEXTPixelBufferObject = this.isExtensionAvailable("GL_EXT_pixel_buffer_object");
+		this.haveGL15 = this.isExtensionAvailable("GL_VERSION_1_5");
+		this.haveGL21 = this.isExtensionAvailable("GL_VERSION_2_1");
+		this.haveARBVertexBufferObject = this.isExtensionAvailable("GL_ARB_vertex_buffer_object");
+	}
+
+	private void checkBufferObject(boolean arg0, boolean arg1, boolean arg2, boolean arg3, int arg4, String arg5) {
+		if (this.inBeginEndPair) {
+			throw new GLException("May not call this between glBegin and glEnd");
+		}
+		boolean var7 = arg0 || arg1 || arg2;
+		if (!var7 && arg3) {
+			throw new GLException("Required extensions not available to call this function");
+		}
+	}
+
+	private void checkUnpackPBODisabled() {
+		this.initBufferObjectExtensionChecks();
+		this.checkBufferObject(this.haveARBPixelBufferObject, this.haveEXTPixelBufferObject, this.haveGL21, false, 35052, "unpack pixel_buffer_object");
+	}
+
+	private void checkArrayVBODisabled() {
+		this.initBufferObjectExtensionChecks();
+		this.checkBufferObject(this.haveGL15, this.haveARBVertexBufferObject, false, false, 34962, "array vertex_buffer_object");
+	}
+
+	private void checkArrayVBOEnabled() {
+		this.initBufferObjectExtensionChecks();
+		this.checkBufferObject(this.haveGL15, this.haveARBVertexBufferObject, false, true, 34962, "array vertex_buffer_object");
+	}
+
+	private void checkElementVBODisabled() {
+		this.initBufferObjectExtensionChecks();
+		this.checkBufferObject(this.haveGL15, this.haveARBVertexBufferObject, false, false, 34963, "element vertex_buffer_object");
+	}
+
+	private void checkElementVBOEnabled() {
+		this.initBufferObjectExtensionChecks();
+		this.checkBufferObject(this.haveGL15, this.haveARBVertexBufferObject, false, true, 34963, "element vertex_buffer_object");
+	}
+}

gl/src/main/java/com/sun/opengl/impl/JAWT.java

@@ -0,0 +1,85 @@
+package com.sun.opengl.impl;
+
+import com.sun.gluegen.runtime.BufferFactory;
+import com.sun.gluegen.runtime.CPU;
+import com.sun.gluegen.runtime.StructAccessor;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+public abstract class JAWT {
+
+	StructAccessor accessor;
+
+	private static volatile JAWT jawt;
+
+	public static int size() {
+		return CPU.is32Bit() ? JAWT32.size() : JAWT64.size();
+	}
+
+	public static JAWT create() {
+		return create(BufferFactory.newDirectByteBuffer(size()));
+	}
+
+	public static JAWT create(ByteBuffer arg0) {
+		return CPU.is32Bit() ? new JAWT32(arg0) : new JAWT64(arg0);
+	}
+
+	JAWT(ByteBuffer arg0) {
+		this.accessor = new StructAccessor(arg0);
+	}
+
+	public ByteBuffer getBuffer() {
+		return this.accessor.getBuffer();
+	}
+
+	public abstract JAWT version(int arg0);
+
+	public JAWT_DrawingSurface GetDrawingSurface(Object arg0) {
+		ByteBuffer var2 = this.GetDrawingSurface0(this.getBuffer(), arg0);
+		return var2 == null ? null : JAWT_DrawingSurface.create(var2.order(ByteOrder.nativeOrder()));
+	}
+
+	private native ByteBuffer GetDrawingSurface0(ByteBuffer arg0, Object arg1);
+
+	public void FreeDrawingSurface(JAWT_DrawingSurface arg0) {
+		this.FreeDrawingSurface0(this.getBuffer(), arg0 == null ? null : arg0.getBuffer());
+	}
+
+	private native void FreeDrawingSurface0(ByteBuffer arg0, ByteBuffer arg1);
+
+	public void Lock() {
+		this.Lock0(this.getBuffer());
+	}
+
+	private native void Lock0(ByteBuffer arg0);
+
+	public void Unlock() {
+		this.Unlock0(this.getBuffer());
+	}
+
+	private native void Unlock0(ByteBuffer arg0);
+
+	public static JAWT getJAWT() {
+		if (jawt == null) {
+			synchronized (JAWT.class) {
+				if (jawt == null) {
+					AccessController.doPrivileged(new PrivilegedAction() {
+
+						public Object run() {
+							JAWT var1 = JAWT.create();
+							var1.version(65540);
+							if (!JAWTFactory.JAWT_GetAWT(var1)) {
+								throw new RuntimeException("Unable to initialize JAWT");
+							}
+							JAWT.jawt = var1;
+							return null;
+						}
+					});
+				}
+			}
+		}
+		return jawt;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/JAWT32.java

@@ -0,0 +1,19 @@
+package com.sun.opengl.impl;
+
+import java.nio.ByteBuffer;
+
+class JAWT32 extends JAWT {
+
+	public static int size() {
+		return 24;
+	}
+
+	JAWT32(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public JAWT version(int arg0) {
+		this.accessor.setIntAt(0, arg0);
+		return this;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/JAWT64.java

@@ -0,0 +1,19 @@
+package com.sun.opengl.impl;
+
+import java.nio.ByteBuffer;
+
+class JAWT64 extends JAWT {
+
+	public static int size() {
+		return 48;
+	}
+
+	JAWT64(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public JAWT version(int arg0) {
+		this.accessor.setIntAt(0, arg0);
+		return this;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/JAWTFactory.java

@@ -0,0 +1,12 @@
+package com.sun.opengl.impl;
+
+import java.nio.ByteBuffer;
+
+public class JAWTFactory {
+
+	public static boolean JAWT_GetAWT(JAWT arg0) {
+		return JAWT_GetAWT0(arg0 == null ? null : arg0.getBuffer());
+	}
+
+	private static native boolean JAWT_GetAWT0(ByteBuffer arg0);
+}

gl/src/main/java/com/sun/opengl/impl/JAWT_DrawingSurface.java

@@ -0,0 +1,48 @@
+package com.sun.opengl.impl;
+
+import com.sun.gluegen.runtime.CPU;
+import com.sun.gluegen.runtime.StructAccessor;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+public abstract class JAWT_DrawingSurface {
+
+	StructAccessor accessor;
+
+	public static JAWT_DrawingSurface create(ByteBuffer arg0) {
+		return CPU.is32Bit() ? new JAWT_DrawingSurface32(arg0) : new JAWT_DrawingSurface64(arg0);
+	}
+
+	JAWT_DrawingSurface(ByteBuffer arg0) {
+		this.accessor = new StructAccessor(arg0);
+	}
+
+	public ByteBuffer getBuffer() {
+		return this.accessor.getBuffer();
+	}
+
+	public int Lock() {
+		return this.Lock0(this.getBuffer());
+	}
+
+	private native int Lock0(ByteBuffer arg0);
+
+	public JAWT_DrawingSurfaceInfo GetDrawingSurfaceInfo() {
+		ByteBuffer var1 = this.GetDrawingSurfaceInfo0(this.getBuffer());
+		return var1 == null ? null : JAWT_DrawingSurfaceInfo.create(var1.order(ByteOrder.nativeOrder()));
+	}
+
+	private native ByteBuffer GetDrawingSurfaceInfo0(ByteBuffer arg0);
+
+	public void FreeDrawingSurfaceInfo(JAWT_DrawingSurfaceInfo arg0) {
+		this.FreeDrawingSurfaceInfo0(this.getBuffer(), arg0 == null ? null : arg0.getBuffer());
+	}
+
+	private native void FreeDrawingSurfaceInfo0(ByteBuffer arg0, ByteBuffer arg1);
+
+	public void Unlock() {
+		this.Unlock0(this.getBuffer());
+	}
+
+	private native void Unlock0(ByteBuffer arg0);
+}

gl/src/main/java/com/sun/opengl/impl/JAWT_DrawingSurface32.java

@@ -0,0 +1,10 @@
+package com.sun.opengl.impl;
+
+import java.nio.ByteBuffer;
+
+class JAWT_DrawingSurface32 extends JAWT_DrawingSurface {
+
+	JAWT_DrawingSurface32(ByteBuffer arg0) {
+		super(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/JAWT_DrawingSurface64.java

@@ -0,0 +1,10 @@
+package com.sun.opengl.impl;
+
+import java.nio.ByteBuffer;
+
+class JAWT_DrawingSurface64 extends JAWT_DrawingSurface {
+
+	JAWT_DrawingSurface64(ByteBuffer arg0) {
+		super(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/JAWT_DrawingSurfaceInfo.java

@@ -0,0 +1,63 @@
+package com.sun.opengl.impl;
+
+import com.sun.gluegen.runtime.CPU;
+import com.sun.gluegen.runtime.StructAccessor;
+import java.lang.reflect.Method;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+public abstract class JAWT_DrawingSurfaceInfo {
+
+	StructAccessor accessor;
+
+	private static Method platformInfoFactoryMethod;
+
+	public static JAWT_DrawingSurfaceInfo create(ByteBuffer arg0) {
+		return CPU.is32Bit() ? new JAWT_DrawingSurfaceInfo32(arg0) : new JAWT_DrawingSurfaceInfo64(arg0);
+	}
+
+	JAWT_DrawingSurfaceInfo(ByteBuffer arg0) {
+		this.accessor = new StructAccessor(arg0);
+	}
+
+	public ByteBuffer getBuffer() {
+		return this.accessor.getBuffer();
+	}
+
+	public JAWT_PlatformInfo platformInfo() {
+		return newPlatformInfo(this.platformInfo0(this.getBuffer()));
+	}
+
+	private native ByteBuffer platformInfo0(Buffer arg0);
+
+	private static JAWT_PlatformInfo newPlatformInfo(ByteBuffer arg0) {
+		if (platformInfoFactoryMethod == null) {
+			String var1 = (String) AccessController.doPrivileged(new PrivilegedAction() {
+
+				public Object run() {
+					return System.getProperty("os.name").toLowerCase();
+				}
+			});
+			try {
+				Class var2;
+				if (var1.startsWith("wind")) {
+					var2 = Class.forName("com.sun.opengl.impl.windows.JAWT_Win32DrawingSurfaceInfo");
+				} else if (var1.startsWith("mac os x")) {
+					var2 = Class.forName("com.sun.opengl.impl.macosx.JAWT_MacOSXDrawingSurfaceInfo");
+				} else {
+					var2 = Class.forName("com.sun.opengl.impl.x11.JAWT_X11DrawingSurfaceInfo");
+				}
+				platformInfoFactoryMethod = var2.getMethod("create", ByteBuffer.class);
+			} catch (Exception var4) {
+				throw new RuntimeException(var4);
+			}
+		}
+		try {
+			return (JAWT_PlatformInfo) platformInfoFactoryMethod.invoke(null, arg0);
+		} catch (Exception var3) {
+			throw new RuntimeException(var3);
+		}
+	}
+}

gl/src/main/java/com/sun/opengl/impl/JAWT_DrawingSurfaceInfo32.java

@@ -0,0 +1,10 @@
+package com.sun.opengl.impl;
+
+import java.nio.ByteBuffer;
+
+class JAWT_DrawingSurfaceInfo32 extends JAWT_DrawingSurfaceInfo {
+
+	JAWT_DrawingSurfaceInfo32(ByteBuffer arg0) {
+		super(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/JAWT_DrawingSurfaceInfo64.java

@@ -0,0 +1,10 @@
+package com.sun.opengl.impl;
+
+import java.nio.ByteBuffer;
+
+class JAWT_DrawingSurfaceInfo64 extends JAWT_DrawingSurfaceInfo {
+
+	JAWT_DrawingSurfaceInfo64(ByteBuffer arg0) {
+		super(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/JAWT_PlatformInfo.java

@@ -0,0 +1,4 @@
+package com.sun.opengl.impl;
+
+public interface JAWT_PlatformInfo {
+}

gl/src/main/java/com/sun/opengl/impl/macosx/CGL.java

@@ -0,0 +1,55 @@
+package com.sun.opengl.impl.macosx;
+
+import javax.media.opengl.GLException;
+
+public class CGL {
+
+	public static native boolean clearCurrentContext(long arg0);
+
+	private static native long createContext1(long arg0, long arg1, long arg2, Object arg3, int arg4);
+
+	public static long createContext(long arg0, long arg1, long arg2, int[] arg3, int arg4) {
+		if (arg3 != null && arg3.length <= arg4) {
+			throw new GLException("array offset argument \"viewNotReady_offset\" (" + arg4 + ") equals or exceeds array length (" + arg3.length + ")");
+		}
+		return createContext1(arg0, arg1, arg2, arg3, arg4 * 4);
+	}
+
+	private static native long createPixelFormat1(Object arg0, int arg1, int arg2, Object arg3, int arg4);
+
+	public static long createPixelFormat(int[] arg0, int arg1, int arg2, int[] arg3, int arg4) {
+		if (arg0 != null && arg0.length <= arg1) {
+			throw new GLException("array offset argument \"iattrs_offset\" (" + arg1 + ") equals or exceeds array length (" + arg0.length + ")");
+		} else if (arg3 == null || arg3.length > arg4) {
+			return createPixelFormat1(arg0, arg1 * 4, arg2, arg3, arg4 * 4);
+		} else {
+			throw new GLException("array offset argument \"ivalues_offset\" (" + arg4 + ") equals or exceeds array length (" + arg3.length + ")");
+		}
+	}
+
+	public static native boolean deleteContext(long arg0);
+
+	public static native void deletePixelFormat(long arg0);
+
+	public static native boolean flushBuffer(long arg0);
+
+	public static native long getProcAddress(String arg0);
+
+	public static native boolean makeCurrentContext(long arg0);
+
+	private static native void queryPixelFormat1(long arg0, Object arg1, int arg2, int arg3, Object arg4, int arg5);
+
+	public static void queryPixelFormat(long arg0, int[] arg1, int arg2, int arg3, int[] arg4, int arg5) {
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"iattrs_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		} else if (arg4 == null || arg4.length > arg5) {
+			queryPixelFormat1(arg0, arg1, arg2 * 4, arg3, arg4, arg5 * 4);
+		} else {
+			throw new GLException("array offset argument \"ivalues_offset\" (" + arg5 + ") equals or exceeds array length (" + arg4.length + ")");
+		}
+	}
+
+	public static native void setSwapInterval(long arg0, int arg1);
+
+	public static native void updateContext(long arg0);
+}

gl/src/main/java/com/sun/opengl/impl/macosx/JAWT_MacOSXDrawingSurfaceInfo.java

@@ -0,0 +1,30 @@
+package com.sun.opengl.impl.macosx;
+
+import com.sun.gluegen.runtime.BufferFactory;
+import com.sun.gluegen.runtime.CPU;
+import com.sun.gluegen.runtime.StructAccessor;
+import com.sun.opengl.impl.JAWT_PlatformInfo;
+import java.nio.ByteBuffer;
+
+public abstract class JAWT_MacOSXDrawingSurfaceInfo implements JAWT_PlatformInfo {
+
+	StructAccessor accessor;
+
+	public static int size() {
+		return CPU.is32Bit() ? JAWT_MacOSXDrawingSurfaceInfo32.size() : JAWT_MacOSXDrawingSurfaceInfo64.size();
+	}
+
+	public static JAWT_MacOSXDrawingSurfaceInfo create() {
+		return create(BufferFactory.newDirectByteBuffer(size()));
+	}
+
+	public static JAWT_MacOSXDrawingSurfaceInfo create(ByteBuffer arg0) {
+		return CPU.is32Bit() ? new JAWT_MacOSXDrawingSurfaceInfo32(arg0) : new JAWT_MacOSXDrawingSurfaceInfo64(arg0);
+	}
+
+	JAWT_MacOSXDrawingSurfaceInfo(ByteBuffer arg0) {
+		this.accessor = new StructAccessor(arg0);
+	}
+
+	public abstract long cocoaViewRef();
+}

gl/src/main/java/com/sun/opengl/impl/macosx/JAWT_MacOSXDrawingSurfaceInfo32.java

@@ -0,0 +1,19 @@
+package com.sun.opengl.impl.macosx;
+
+import com.sun.opengl.impl.JAWT_PlatformInfo;
+import java.nio.ByteBuffer;
+
+class JAWT_MacOSXDrawingSurfaceInfo32 extends JAWT_MacOSXDrawingSurfaceInfo implements JAWT_PlatformInfo {
+
+	public static int size() {
+		return 4;
+	}
+
+	JAWT_MacOSXDrawingSurfaceInfo32(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public long cocoaViewRef() {
+		return (long) this.accessor.getIntAt(0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/macosx/JAWT_MacOSXDrawingSurfaceInfo64.java

@@ -0,0 +1,19 @@
+package com.sun.opengl.impl.macosx;
+
+import com.sun.opengl.impl.JAWT_PlatformInfo;
+import java.nio.ByteBuffer;
+
+class JAWT_MacOSXDrawingSurfaceInfo64 extends JAWT_MacOSXDrawingSurfaceInfo implements JAWT_PlatformInfo {
+
+	public static int size() {
+		return 8;
+	}
+
+	JAWT_MacOSXDrawingSurfaceInfo64(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public long cocoaViewRef() {
+		return this.accessor.getLongAt(0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/macosx/MacOSXGLContext.java

@@ -0,0 +1,186 @@
+package com.sun.opengl.impl.macosx;
+
+import com.sun.opengl.impl.GLContextImpl;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLException;
+
+public abstract class MacOSXGLContext extends GLContextImpl {
+
+	protected MacOSXGLDrawable drawable;
+
+	protected long nsContext;
+
+	public MacOSXGLContext(MacOSXGLDrawable arg0) {
+		this.drawable = arg0;
+	}
+
+	protected String mapToRealGLExtensionName(String arg0) {
+		return arg0;
+	}
+
+	protected abstract boolean create();
+
+	protected boolean create(boolean arg0, boolean arg1) {
+		long var3 = 0L;
+		int[] var5 = new int[1];
+		GLCapabilities var6 = this.drawable.getCapabilities();
+		int[] var7 = new int[128];
+		int[] var8 = new int[128];
+		int var9 = 0;
+		if (arg0) {
+			var7[var9] = 90;
+			var8[var9] = 1;
+			var9++;
+		}
+		if (arg1) {
+			var7[var9] = 58;
+			var8[var9] = 1;
+			var9++;
+		}
+		var7[var9] = 5;
+		var8[var9] = var6.getDoubleBuffered() ? 1 : 0;
+		var9++;
+		var7[var9] = 6;
+		var8[var9] = var6.getStereo() ? 1 : 0;
+		var9++;
+		var7[var9] = 8;
+		var8[var9] = var6.getRedBits() + var6.getGreenBits() + var6.getBlueBits();
+		var9++;
+		var7[var9] = 11;
+		var8[var9] = var6.getAlphaBits();
+		var9++;
+		var7[var9] = 12;
+		var8[var9] = var6.getDepthBits();
+		var9++;
+		var7[var9] = 14;
+		var8[var9] = var6.getAccumRedBits() + var6.getAccumGreenBits() + var6.getAccumBlueBits() + var6.getAccumAlphaBits();
+		var9++;
+		var7[var9] = 13;
+		var8[var9] = var6.getStencilBits();
+		var9++;
+		if (var6.getSampleBuffers()) {
+			var7[var9] = 55;
+			var8[var9] = 1;
+			var9++;
+			var7[var9] = 56;
+			var8[var9] = var6.getNumSamples();
+			var9++;
+		}
+		long var10 = CGL.createPixelFormat(var7, 0, var9, var8, 0);
+		if (var10 == 0L) {
+			throw new GLException("Unable to allocate pixel format with requested GLCapabilities");
+		}
+		try {
+			this.nsContext = CGL.createContext(var3, this.drawable.getView(), var10, var5, 0);
+			if (this.nsContext == 0L) {
+				if (var5[0] == 1) {
+					boolean var19 = false;
+					return var19;
+				}
+				throw new GLException("Error creating NSOpenGLContext with requested pixel format");
+			}
+			if (this.drawable.getChosenGLCapabilities() == null) {
+				GLCapabilities var12 = new GLCapabilities();
+				CGL.queryPixelFormat(var10, var7, 0, var9, var8, 0);
+				for (int var13 = 0; var13 < var9; var13++) {
+					int var14 = var7[var13];
+					int var15;
+					switch(var14) {
+						case 5:
+							var12.setDoubleBuffered(var8[var13] != 0);
+							break;
+						case 6:
+							var12.setStereo(var8[var13] != 0);
+							break;
+						case 8:
+							var15 = var8[var13];
+							if (var15 == 32) {
+								var15 = 24;
+							}
+							var15 /= 3;
+							var12.setRedBits(var15);
+							var12.setGreenBits(var15);
+							var12.setBlueBits(var15);
+							break;
+						case 11:
+							var12.setAlphaBits(var8[var13]);
+							break;
+						case 12:
+							var12.setDepthBits(var8[var13]);
+							break;
+						case 13:
+							var12.setStencilBits(var8[var13]);
+							break;
+						case 14:
+							var15 = var8[var13] / 4;
+							var12.setAccumRedBits(var15);
+							var12.setAccumGreenBits(var15);
+							var12.setAccumBlueBits(var15);
+							var12.setAccumAlphaBits(var15);
+							break;
+						case 55:
+							var12.setSampleBuffers(var8[var13] != 0);
+							break;
+						case 56:
+							var12.setNumSamples(var8[var13]);
+							break;
+						case 58:
+							var12.setPbufferFloatingPointBuffers(var8[var13] != 0);
+					}
+				}
+				this.drawable.setChosenGLCapabilities(var12);
+			}
+		} finally {
+			CGL.deletePixelFormat(var10);
+		}
+		return true;
+	}
+
+	protected int makeCurrentImpl() throws GLException {
+		boolean var1 = false;
+		if (this.nsContext == 0L) {
+			if (!this.create()) {
+				return 0;
+			}
+			var1 = true;
+		}
+		if (!CGL.makeCurrentContext(this.nsContext)) {
+			throw new GLException("Error making nsContext current");
+		} else if (var1) {
+			this.resetGLFunctionAvailability();
+			return 2;
+		} else {
+			return 1;
+		}
+	}
+
+	protected void releaseImpl() throws GLException {
+		if (!CGL.clearCurrentContext(this.nsContext)) {
+			throw new GLException("Error freeing OpenGL nsContext");
+		}
+	}
+
+	protected void destroyImpl() throws GLException {
+		if (this.nsContext != 0L) {
+			if (!CGL.deleteContext(this.nsContext)) {
+				throw new GLException("Unable to delete OpenGL context");
+			}
+			this.nsContext = 0L;
+		}
+	}
+
+	public String getPlatformExtensionsString() {
+		return "";
+	}
+
+	public void setSwapInterval(int arg0) {
+		if (this.nsContext == 0L) {
+			throw new GLException("OpenGL context not current");
+		}
+		CGL.setSwapInterval(this.nsContext, arg0);
+	}
+
+	public boolean isExtensionAvailable(String arg0) {
+		return arg0.equals("GL_ARB_pbuffer") || arg0.equals("GL_ARB_pixel_format") ? true : super.isExtensionAvailable(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/macosx/MacOSXGLDrawable.java

@@ -0,0 +1,35 @@
+package com.sun.opengl.impl.macosx;
+
+import com.sun.opengl.impl.GLDrawableImpl;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLException;
+
+public abstract class MacOSXGLDrawable extends GLDrawableImpl {
+
+	protected GLCapabilities capabilities;
+
+	protected GLCapabilitiesChooser chooser;
+
+	public MacOSXGLDrawable(GLCapabilities arg0, GLCapabilitiesChooser arg1) {
+		this.capabilities = (GLCapabilities) arg0.clone();
+		this.chooser = arg1;
+	}
+
+	public abstract void setRealized(boolean arg0);
+
+	public abstract void swapBuffers();
+
+	public abstract long getView();
+
+	public GLCapabilities getCapabilities() {
+		byte var1 = 1;
+		GLCapabilities[] var2 = new GLCapabilities[var1];
+		var2[0] = this.capabilities;
+		int var3 = this.chooser.chooseCapabilities(this.capabilities, var2, 0);
+		if (var3 < 0 || var3 >= var1) {
+			throw new GLException("Invalid result " + var3 + " from GLCapabilitiesChooser (should be between 0 and " + (var1 - 1) + ")");
+		}
+		return var2[var3];
+	}
+}

gl/src/main/java/com/sun/opengl/impl/macosx/MacOSXGLDrawableFactory.java

@@ -0,0 +1,31 @@
+package com.sun.opengl.impl.macosx;
+
+import com.sun.opengl.impl.GLDrawableFactoryImpl;
+import java.awt.Component;
+import javax.media.opengl.DefaultGLCapabilitiesChooser;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLDrawable;
+
+public class MacOSXGLDrawableFactory extends GLDrawableFactoryImpl {
+
+	public GLDrawable getGLDrawable(Object arg0, GLCapabilities arg1, GLCapabilitiesChooser arg2) {
+		if (arg0 == null) {
+			throw new IllegalArgumentException("Null target");
+		} else if (arg0 instanceof Component) {
+			if (arg1 == null) {
+				arg1 = new GLCapabilities();
+			}
+			if (arg2 == null) {
+				arg2 = new DefaultGLCapabilitiesChooser();
+			}
+			return new MacOSXOnscreenGLDrawable((Component) arg0, arg1, arg2);
+		} else {
+			throw new IllegalArgumentException("GLDrawables not supported for objects of type " + arg0.getClass().getName() + " (only Components are supported in this implementation)");
+		}
+	}
+
+	public long dynamicLookupFunction(String arg0) {
+		return CGL.getProcAddress(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/macosx/MacOSXOnscreenGLContext.java

@@ -0,0 +1,51 @@
+package com.sun.opengl.impl.macosx;
+
+import javax.media.opengl.GLException;
+
+public class MacOSXOnscreenGLContext extends MacOSXGLContext {
+
+	protected MacOSXOnscreenGLDrawable drawable;
+
+	public MacOSXOnscreenGLContext(MacOSXOnscreenGLDrawable arg0) {
+		super(arg0);
+		this.drawable = arg0;
+	}
+
+	protected int makeCurrentImpl() throws GLException {
+		int var1 = this.drawable.lockSurface();
+		if (var1 == 1) {
+			return 0;
+		}
+		int var3;
+		try {
+			if (var1 == 2) {
+				super.destroyImpl();
+			}
+			int var2 = super.makeCurrentImpl();
+			if (var2 == 1 || var2 == 2) {
+				CGL.updateContext(this.nsContext);
+			}
+			var3 = var2;
+		} finally {
+			this.drawable.unlockSurface();
+		}
+		return var3;
+	}
+
+	public void swapBuffers() throws GLException {
+		if (!CGL.flushBuffer(this.nsContext)) {
+			throw new GLException("Error swapping buffers");
+		}
+	}
+
+	protected void update() throws GLException {
+		if (this.nsContext == 0L) {
+			throw new GLException("Context not created");
+		}
+		CGL.updateContext(this.nsContext);
+	}
+
+	protected boolean create() {
+		return this.create(false, false);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/macosx/MacOSXOnscreenGLDrawable.java

@@ -0,0 +1,114 @@
+package com.sun.opengl.impl.macosx;
+
+import com.sun.opengl.impl.JAWT;
+import com.sun.opengl.impl.JAWT_DrawingSurface;
+import com.sun.opengl.impl.JAWT_DrawingSurfaceInfo;
+import java.awt.Component;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLException;
+
+public class MacOSXOnscreenGLDrawable extends MacOSXGLDrawable {
+
+	private Component component;
+
+	protected long nsView;
+
+	JAWT_DrawingSurface ds;
+
+	JAWT_DrawingSurfaceInfo dsi;
+
+	protected boolean realized;
+
+	private boolean firstLock = true;
+
+	public MacOSXOnscreenGLDrawable(Component arg0, GLCapabilities arg1, GLCapabilitiesChooser arg2) {
+		super(arg1, arg2);
+		this.component = arg0;
+	}
+
+	public GLContext createContext(GLContext arg0) {
+		return new MacOSXOnscreenGLContext(this);
+	}
+
+	public void setRealized(boolean arg0) {
+		this.realized = arg0;
+		this.setChosenGLCapabilities(null);
+	}
+
+	public void swapBuffers() throws GLException {
+		((MacOSXOnscreenGLContext) GLContext.getCurrent()).swapBuffers();
+	}
+
+	public long getView() {
+		return this.nsView;
+	}
+
+	public int lockSurface() throws GLException {
+		if (this.nsView != 0L) {
+			return 3;
+		} else if (this.realized) {
+			this.ds = JAWT.getJAWT().GetDrawingSurface(this.component);
+			if (this.ds == null) {
+				return 1;
+			}
+			int var1 = this.ds.Lock();
+			if ((var1 & 0x1) != 0) {
+				JAWT.getJAWT().FreeDrawingSurface(this.ds);
+				this.ds = null;
+				return 1;
+			}
+			if (this.firstLock) {
+				AccessController.doPrivileged(new PrivilegedAction() {
+
+					public Object run() {
+						MacOSXOnscreenGLDrawable.this.dsi = MacOSXOnscreenGLDrawable.this.ds.GetDrawingSurfaceInfo();
+						return null;
+					}
+				});
+				this.firstLock = false;
+			} else {
+				this.dsi = this.ds.GetDrawingSurfaceInfo();
+			}
+			if (this.dsi == null) {
+				this.ds.Unlock();
+				JAWT.getJAWT().FreeDrawingSurface(this.ds);
+				this.ds = null;
+				return 1;
+			}
+			JAWT_MacOSXDrawingSurfaceInfo var2 = (JAWT_MacOSXDrawingSurfaceInfo) this.dsi.platformInfo();
+			if (var2 != null) {
+				this.nsView = var2.cocoaViewRef();
+			}
+			if (this.nsView == 0L) {
+				this.ds.FreeDrawingSurfaceInfo(this.dsi);
+				this.ds.Unlock();
+				JAWT.getJAWT().FreeDrawingSurface(this.ds);
+				this.ds = null;
+				this.dsi = null;
+				return 1;
+			} else if ((var1 & 0x8) == 0) {
+				return 3;
+			} else {
+				return 2;
+			}
+		} else {
+			return 1;
+		}
+	}
+
+	public void unlockSurface() throws GLException {
+		if (this.nsView == 0L) {
+			return;
+		}
+		this.ds.FreeDrawingSurfaceInfo(this.dsi);
+		this.ds.Unlock();
+		JAWT.getJAWT().FreeDrawingSurface(this.ds);
+		this.ds = null;
+		this.dsi = null;
+		this.nsView = 0L;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/BuildMipmap.java

@@ -0,0 +1,569 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+import javax.media.opengl.GL;
+
+public class BuildMipmap {
+
+	public static int bitmapBuild2DMipmaps(GL arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, ByteBuffer arg7) {
+		int[] var8 = new int[1];
+		int[] var9 = new int[1];
+		ShortBuffer var12 = null;
+		ShortBuffer var15 = null;
+		ShortBuffer var16 = null;
+		PixelStorageModes var20 = new PixelStorageModes();
+		Mipmap.retrieveStoreModes(arg0, var20);
+		Mipmap.closestFit(arg0, arg1, arg3, arg4, arg2, arg5, arg6, var8, var9);
+		int var11 = Mipmap.computeLog(var8[0]);
+		int var10 = Mipmap.computeLog(var9[0]);
+		if (var10 > var11) {
+			var11 = var10;
+		}
+		try {
+			var12 = ByteBuffer.allocateDirect(Mipmap.image_size(arg3, arg4, arg5, 5123)).order(ByteOrder.nativeOrder()).asShortBuffer();
+		} catch (OutOfMemoryError var22) {
+			return 100902;
+		}
+		int var13 = arg3;
+		int var14 = arg4;
+		Image.fill_image(var20, arg3, arg4, arg5, arg6, Mipmap.is_index(arg5), arg7, var12);
+		int var19 = Mipmap.elements_per_group(arg5, arg6);
+		arg0.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, GL.GL_LINE_LOOP);
+		arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, GL.GL_POINTS);
+		arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, GL.GL_POINTS);
+		arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, GL.GL_POINTS);
+		arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, GL.GL_POINTS);
+		for (var10 = 0; var10 < var11; var10++) {
+			if (var13 == var8[0] && var14 == var9[0]) {
+				var12.rewind();
+				arg0.glTexImage2D(arg1, var10, arg2, var13, var14, 0, arg5, GL.GL_UNSIGNED_SHORT, var12);
+			} else {
+				if (var15 == null) {
+					int var17 = Mipmap.image_size(var8[0], var9[0], arg5, 5123);
+					try {
+						var15 = ByteBuffer.allocateDirect(var17).order(ByteOrder.nativeOrder()).asShortBuffer();
+					} catch (OutOfMemoryError var23) {
+						arg0.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, var20.getUnpackAlignment());
+						arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, var20.getUnpackSkipRows());
+						arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, var20.getUnpackSkipPixels());
+						arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, var20.getUnpackRowLength());
+						arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, var20.getUnpackSwapBytes() ? GL.GL_LINES : GL.GL_POINTS);
+						return 100902;
+					}
+				}
+				ScaleInternal.scale_internal(var19, var13, var14, var12, var8[0], var9[0], var15);
+				var16 = var15;
+				var15 = var12;
+				var12 = var16;
+				var13 = var8[0];
+				var14 = var9[0];
+				var16.rewind();
+				arg0.glTexImage2D(arg1, var10, arg2, var13, var14, 0, arg5, GL.GL_UNSIGNED_SHORT, var16);
+			}
+			if (var9[0] > 1) {
+				var8[0] /= 2;
+			}
+			if (var9[0] > 1) {
+				var9[0] /= 2;
+			}
+		}
+		arg0.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, var20.getUnpackAlignment());
+		arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, var20.getUnpackSkipRows());
+		arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, var20.getUnpackSkipPixels());
+		arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, var20.getUnpackRowLength());
+		arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, var20.getUnpackSwapBytes() ? GL.GL_LINES : GL.GL_POINTS);
+		return 0;
+	}
+
+	public static int gluBuild2DMipmapLevelsCore(GL arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11, ByteBuffer arg12) {
+		ByteBuffer var18 = null;
+		ByteBuffer var19 = null;
+		ByteBuffer var20 = null;
+		Object var23 = null;
+		PixelStorageModes var33 = new PixelStorageModes();
+		assert Mipmap.checkMipmapArgs(arg2, arg7, arg8) == 0;
+		assert arg3 >= 1 && arg4 >= 1;
+		if (arg8 == 6656) {
+			return bitmapBuild2DMipmaps(arg0, arg1, arg2, arg3, arg4, arg7, arg8, arg12);
+		}
+		int var13 = arg5;
+		int var14 = arg6;
+		int var16 = Mipmap.computeLog(arg5);
+		int var15 = Mipmap.computeLog(arg6);
+		if (var15 > var16) {
+			var16 = var15;
+		}
+		var16 += arg9;
+		Mipmap.retrieveStoreModes(arg0, var33);
+		boolean var27 = var33.getUnpackSwapBytes();
+		int var26 = Mipmap.elements_per_group(arg7, arg8);
+		int var28;
+		if (var33.getUnpackRowLength() > 0) {
+			var28 = var33.getUnpackRowLength();
+		} else {
+			var28 = arg3;
+		}
+		int var29 = Mipmap.bytes_per_element(arg8);
+		int var30 = var29 * var26;
+		if (var29 == 1) {
+			var27 = false;
+		}
+		int var31 = var28 * var30;
+		int var32 = var31 % var33.getUnpackAlignment();
+		if (var32 != 0) {
+			var31 += var33.getUnpackAlignment() - var32;
+		}
+		arg12.position(var33.getUnpackSkipRows() * var31 + var33.getUnpackSkipPixels() * var30);
+		arg12.mark();
+		arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, GL.GL_POINTS);
+		arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, GL.GL_POINTS);
+		arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, GL.GL_POINTS);
+		int var24;
+		int var34;
+		int var35;
+		if (arg3 == arg5 && arg4 == arg6) {
+			if (arg10 <= arg9 && arg9 <= arg11) {
+				arg12.rewind();
+				arg0.glTexImage2D(arg1, arg9, arg2, arg3, arg4, 0, arg7, arg8, arg12);
+			}
+			if (var16 == 0) {
+				arg0.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, var33.getUnpackAlignment());
+				arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, var33.getUnpackSkipRows());
+				arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, var33.getUnpackSkipPixels());
+				arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, var33.getUnpackRowLength());
+				arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, var33.getUnpackSwapBytes() ? GL.GL_LINES : GL.GL_POINTS);
+				return 0;
+			}
+			var34 = arg5 / 2;
+			var35 = arg6 / 2;
+			if (var34 < 1) {
+				var34 = 1;
+			}
+			if (var35 < 1) {
+				var35 = 1;
+			}
+			var24 = Mipmap.image_size(var34, var35, arg7, arg8);
+			try {
+				switch(arg8) {
+					case 5120:
+					case 5121:
+					case 5122:
+					case 5123:
+					case 5124:
+					case 5125:
+					case 5126:
+					case 32818:
+					case 32819:
+					case 32820:
+					case 32821:
+					case 32822:
+					case 33634:
+					case 33635:
+					case 33636:
+					case 33637:
+					case 33638:
+					case 33639:
+					case 33640:
+						var19 = ByteBuffer.allocateDirect(var24).order(ByteOrder.nativeOrder());
+						break;
+					default:
+						return 100900;
+				}
+			} catch (OutOfMemoryError var45) {
+				arg0.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, var33.getUnpackAlignment());
+				arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, var33.getUnpackSkipRows());
+				arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, var33.getUnpackSkipPixels());
+				arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, var33.getUnpackRowLength());
+				arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, var33.getUnpackSwapBytes() ? GL.GL_LINES : GL.GL_POINTS);
+				return 100902;
+			}
+			if (var19 != null) {
+				switch(arg8) {
+					case 5120:
+						HalveImage.halveImage_byte(var26, arg3, arg4, arg12, var19, var29, var31, var30);
+						break;
+					case 5121:
+						HalveImage.halveImage_ubyte(var26, arg3, arg4, arg12, var19, var29, var31, var30);
+						break;
+					case 5122:
+						HalveImage.halveImage_short(var26, arg3, arg4, arg12, var19.asShortBuffer(), var29, var31, var30, var27);
+						break;
+					case 5123:
+						HalveImage.halveImage_ushort(var26, arg3, arg4, arg12, var19.asShortBuffer(), var29, var31, var30, var27);
+						break;
+					case 5124:
+						HalveImage.halveImage_int(var26, arg3, arg4, arg12, var19.asIntBuffer(), var29, var31, var30, var27);
+						break;
+					case 5125:
+						HalveImage.halveImage_uint(var26, arg3, arg4, arg12, var19.asIntBuffer(), var29, var31, var30, var27);
+						break;
+					case 5126:
+						HalveImage.halveImage_float(var26, arg3, arg4, arg12, var19.asFloatBuffer(), var29, var31, var30, var27);
+						break;
+					case 32818:
+						assert arg7 == 6407;
+						HalveImage.halveImagePackedPixel(3, new Extract332(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 32819:
+						HalveImage.halveImagePackedPixel(4, new Extract4444(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 32820:
+						HalveImage.halveImagePackedPixel(4, new Extract5551(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 32821:
+						HalveImage.halveImagePackedPixel(4, new Extract8888(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 32822:
+						HalveImage.halveImagePackedPixel(4, new Extract1010102(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 33634:
+						assert arg7 == 6407;
+						HalveImage.halveImagePackedPixel(3, new Extract233rev(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 33635:
+						HalveImage.halveImagePackedPixel(3, new Extract565(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 33636:
+						HalveImage.halveImagePackedPixel(3, new Extract565rev(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 33637:
+						HalveImage.halveImagePackedPixel(4, new Extract4444rev(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 33638:
+						HalveImage.halveImagePackedPixel(4, new Extract1555rev(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 33639:
+						HalveImage.halveImagePackedPixel(4, new Extract8888rev(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					case 33640:
+						HalveImage.halveImagePackedPixel(4, new Extract2101010rev(), arg3, arg4, arg12, var19, var29, var31, var27);
+						break;
+					default:
+						assert false;
+				}
+			}
+			var13 = arg3 / 2;
+			var14 = arg4 / 2;
+			if (var13 < 1) {
+				var13 = 1;
+			}
+			if (var14 < 1) {
+				var14 = 1;
+			}
+			var27 = false;
+			var31 = var13 * var30;
+			var24 = Mipmap.image_size(var13, var14, arg7, arg8);
+			var18 = var19;
+			try {
+				switch(arg8) {
+					case 5120:
+					case 5121:
+					case 5122:
+					case 5123:
+					case 5124:
+					case 5125:
+					case 5126:
+					case 32818:
+					case 32819:
+					case 32820:
+					case 32821:
+					case 32822:
+					case 33634:
+					case 33635:
+					case 33636:
+					case 33637:
+					case 33638:
+					case 33639:
+					case 33640:
+						var19 = ByteBuffer.allocateDirect(var24).order(ByteOrder.nativeOrder());
+						break;
+					default:
+						return 100900;
+				}
+			} catch (OutOfMemoryError var44) {
+				arg0.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, var33.getUnpackAlignment());
+				arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, var33.getUnpackSkipRows());
+				arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, var33.getUnpackSkipPixels());
+				arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, var33.getUnpackRowLength());
+				arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, var33.getUnpackSwapBytes() ? GL.GL_LINES : GL.GL_POINTS);
+				return 100902;
+			}
+			var15 = arg9 + 1;
+		} else {
+			var24 = Mipmap.image_size(arg5, arg6, arg7, arg8);
+			try {
+				switch(arg8) {
+					case 5120:
+					case 5121:
+					case 5122:
+					case 5123:
+					case 5124:
+					case 5125:
+					case 5126:
+					case 32818:
+					case 32819:
+					case 32820:
+					case 32821:
+					case 32822:
+					case 33634:
+					case 33635:
+					case 33636:
+					case 33637:
+					case 33638:
+					case 33639:
+					case 33640:
+						var19 = ByteBuffer.allocateDirect(var24).order(ByteOrder.nativeOrder());
+						break;
+					default:
+						return 100900;
+				}
+			} catch (OutOfMemoryError var46) {
+				arg0.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, var33.getUnpackAlignment());
+				arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, var33.getUnpackSkipRows());
+				arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, var33.getUnpackSkipPixels());
+				arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, var33.getUnpackRowLength());
+				arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, var33.getUnpackSwapBytes() ? GL.GL_LINES : GL.GL_POINTS);
+				return 100902;
+			}
+			arg12.reset();
+			switch(arg8) {
+				case 5120:
+					ScaleInternal.scale_internal_byte(var26, arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var30);
+					break;
+				case 5121:
+					ScaleInternal.scale_internal_ubyte(var26, arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var30);
+					break;
+				case 5122:
+					ScaleInternal.scale_internal_ushort(var26, arg3, arg4, arg12, arg5, arg6, var19.asShortBuffer(), var29, var31, var30, var27);
+					break;
+				case 5123:
+					ScaleInternal.scale_internal_ushort(var26, arg3, arg4, arg12, arg5, arg6, var19.asShortBuffer(), var29, var31, var30, var27);
+					break;
+				case 5124:
+					ScaleInternal.scale_internal_int(var26, arg3, arg4, arg12, arg5, arg6, var19.asIntBuffer(), var29, var31, var30, var27);
+					break;
+				case 5125:
+					ScaleInternal.scale_internal_uint(var26, arg3, arg4, arg12, arg5, arg6, var19.asIntBuffer(), var29, var31, var30, var27);
+					break;
+				case 5126:
+					ScaleInternal.scale_internal_float(var26, arg3, arg4, arg12, arg5, arg6, var19.asFloatBuffer(), var29, var31, var30, var27);
+					break;
+				case 32818:
+					ScaleInternal.scaleInternalPackedPixel(3, new Extract332(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 32819:
+					ScaleInternal.scaleInternalPackedPixel(4, new Extract4444(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 32820:
+					ScaleInternal.scaleInternalPackedPixel(4, new Extract5551(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 32821:
+					ScaleInternal.scaleInternalPackedPixel(4, new Extract8888(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 32822:
+					ScaleInternal.scaleInternalPackedPixel(4, new Extract1010102(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 33634:
+					ScaleInternal.scaleInternalPackedPixel(3, new Extract233rev(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 33635:
+					ScaleInternal.scaleInternalPackedPixel(3, new Extract565(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 33636:
+					ScaleInternal.scaleInternalPackedPixel(3, new Extract565rev(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 33637:
+					ScaleInternal.scaleInternalPackedPixel(4, new Extract4444rev(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 33638:
+					ScaleInternal.scaleInternalPackedPixel(4, new Extract1555rev(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 33639:
+					ScaleInternal.scaleInternalPackedPixel(4, new Extract8888rev(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				case 33640:
+					ScaleInternal.scaleInternalPackedPixel(4, new Extract2101010rev(), arg3, arg4, arg12, arg5, arg6, var19, var29, var31, var27);
+					break;
+				default:
+					assert false;
+			}
+			var27 = false;
+			var31 = arg5 * var30;
+			var20 = var18;
+			var18 = var19;
+			var19 = var20;
+			if (var16 != 0) {
+				var34 = arg5 / 2;
+				var35 = arg6 / 2;
+				if (var34 < 1) {
+					var34 = 1;
+				}
+				if (var35 < 1) {
+					var35 = 1;
+				}
+				var24 = Mipmap.image_size(var34, var35, arg7, arg8);
+				try {
+					switch(arg8) {
+						case 5120:
+						case 5121:
+						case 5122:
+						case 5123:
+						case 5124:
+						case 5125:
+						case 5126:
+						case 32818:
+						case 32819:
+						case 32820:
+						case 32821:
+						case 32822:
+						case 33634:
+						case 33635:
+						case 33636:
+						case 33637:
+						case 33638:
+						case 33639:
+						case 33640:
+							var19 = ByteBuffer.allocateDirect(var24).order(ByteOrder.nativeOrder());
+							break;
+						default:
+							return 100900;
+					}
+				} catch (OutOfMemoryError var42) {
+					arg0.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, var33.getUnpackAlignment());
+					arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, var33.getUnpackSkipRows());
+					arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, var33.getUnpackSkipPixels());
+					arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, var33.getUnpackRowLength());
+					arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, var33.getUnpackSwapBytes() ? GL.GL_LINES : GL.GL_POINTS);
+					return 100902;
+				}
+			}
+			var15 = arg9;
+		}
+		arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, GL.GL_POINTS);
+		if (arg10 <= var15 && var15 <= arg11) {
+			var18.rewind();
+			arg0.glTexImage2D(arg1, var15, arg2, var13, var14, 0, arg7, arg8, var18);
+		}
+		var15++;
+		while (var15 <= var16) {
+			var18.rewind();
+			var19.rewind();
+			switch(arg8) {
+				case 5120:
+					HalveImage.halveImage_byte(var26, var13, var14, var18, var19, var29, var31, var30);
+					break;
+				case 5121:
+					HalveImage.halveImage_ubyte(var26, var13, var14, var18, var19, var29, var31, var30);
+					break;
+				case 5122:
+					HalveImage.halveImage_short(var26, var13, var14, var18, var19.asShortBuffer(), var29, var31, var30, var27);
+					break;
+				case 5123:
+					HalveImage.halveImage_ushort(var26, var13, var14, var18, var19.asShortBuffer(), var29, var31, var30, var27);
+					break;
+				case 5124:
+					HalveImage.halveImage_int(var26, var13, var14, var18, var19.asIntBuffer(), var29, var31, var30, var27);
+					break;
+				case 5125:
+					HalveImage.halveImage_uint(var26, var13, var14, var18, var19.asIntBuffer(), var29, var31, var30, var27);
+					break;
+				case 5126:
+					HalveImage.halveImage_float(var26, var13, var14, var18, var19.asFloatBuffer(), var29, var31, var30, var27);
+					break;
+				case 32818:
+					assert arg7 == 6407;
+					HalveImage.halveImagePackedPixel(3, new Extract332(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 32819:
+					HalveImage.halveImagePackedPixel(4, new Extract4444(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 32820:
+					HalveImage.halveImagePackedPixel(4, new Extract5551(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 32821:
+					HalveImage.halveImagePackedPixel(4, new Extract8888(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 32822:
+					HalveImage.halveImagePackedPixel(4, new Extract1010102(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 33634:
+					assert arg7 == 6407;
+					HalveImage.halveImagePackedPixel(3, new Extract233rev(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 33635:
+					HalveImage.halveImagePackedPixel(3, new Extract565(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 33636:
+					HalveImage.halveImagePackedPixel(3, new Extract565rev(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 33637:
+					HalveImage.halveImagePackedPixel(4, new Extract4444rev(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 33638:
+					HalveImage.halveImagePackedPixel(4, new Extract1555rev(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 33639:
+					HalveImage.halveImagePackedPixel(4, new Extract8888rev(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				case 33640:
+					HalveImage.halveImagePackedPixel(4, new Extract2101010rev(), var13, var14, var18, var19, var29, var31, var27);
+					break;
+				default:
+					assert false;
+			}
+			var20 = var18;
+			var18 = var19;
+			var19 = var20;
+			if (var13 > 1) {
+				var13 /= 2;
+				var31 /= 2;
+			}
+			if (var14 > 1) {
+				var14 /= 2;
+			}
+			var34 = var31 % var33.getUnpackAlignment();
+			if (var34 != 0) {
+				var35 = var31 + var33.getUnpackAlignment() - var34;
+				ByteBuffer var40 = null;
+				try {
+					var40 = ByteBuffer.allocateDirect(var35 * var14);
+				} catch (OutOfMemoryError var43) {
+					arg0.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, var33.getUnpackAlignment());
+					arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, var33.getUnpackSkipRows());
+					arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, var33.getUnpackSkipPixels());
+					arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, var33.getUnpackRowLength());
+					arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, var33.getUnpackSwapBytes() ? GL.GL_LINES : GL.GL_POINTS);
+					return 100902;
+				}
+				var18.rewind();
+				int var36 = 0;
+				while (true) {
+					if (var36 >= var14) {
+						if (arg10 <= var15 && var15 <= arg11) {
+							var40.rewind();
+							arg0.glTexImage2D(arg1, var15, arg2, var13, var14, 0, arg7, arg8, var40);
+						}
+						break;
+					}
+					var40.position(var35 * var36);
+					for (int var37 = 0; var37 < var31; var37++) {
+						var40.put(var18.get());
+					}
+					var36++;
+				}
+			} else if (arg10 <= var15 && var15 <= arg11) {
+				var18.rewind();
+				arg0.glTexImage2D(arg1, var15, arg2, var13, var14, 0, arg7, arg8, var18);
+			}
+			var15++;
+		}
+		arg0.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, var33.getUnpackAlignment());
+		arg0.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, var33.getUnpackSkipRows());
+		arg0.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, var33.getUnpackSkipPixels());
+		arg0.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, var33.getUnpackRowLength());
+		arg0.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, var33.getUnpackSwapBytes() ? GL.GL_LINES : GL.GL_POINTS);
+		return 0;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract.java

@@ -0,0 +1,10 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public interface Extract {
+
+	void extract(boolean arg0, ByteBuffer arg1, float[] arg2);
+
+	void shove(float[] arg0, int arg1, ByteBuffer arg2);
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract1010102.java

@@ -0,0 +1,31 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract1010102 implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		long var4 = 0L;
+		if (arg0) {
+			var4 = Mipmap.GLU_SWAP_4_BYTES(arg1.getInt()) & 0xFFFFFFFF;
+		} else {
+			var4 = arg1.getInt() & 0xFFFFFFFF;
+		}
+		arg2[0] = (float) (var4 >> 22 & 0xFFFFFFFFFFFFFFFFL) / 1023.0F;
+		arg2[1] = (float) (var4 >> 12 & 0x3FFL) / 1023.0F;
+		arg2[2] = (float) (var4 >> 2 & 0x3FFL) / 1023.0F;
+		arg2[3] = (float) (var4 & 0x3L) / 3.0F;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		assert arg0[3] >= 0.0F && arg0[3] <= 1.0F;
+		long var4 = (long) (((int) (arg0[0] * 1023.0F + 0.5F) & 0x3FF) << 22);
+		long var6 = var4 | (long) (((int) (arg0[1] * 1023.0F + 0.5F) & 0x3FF) << 12);
+		long var7 = var6 | (long) (((int) (arg0[2] * 1023.0F + 0.5F) & 0x3FF) << 2);
+		long var8 = var7 | (long) ((int) (arg0[3] * 3.0F + 0.5F) & 0x3);
+		arg2.asIntBuffer().put(arg1, (int) var8);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract1555rev.java

@@ -0,0 +1,32 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract1555rev implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		boolean var4 = false;
+		int var5;
+		if (arg0) {
+			var5 = Mipmap.GLU_SWAP_2_BYTES(arg1.getShort()) & 0xFFFF;
+		} else {
+			var5 = arg1.getShort() & 0xFFFF;
+		}
+		arg2[0] = (float) (var5 & 0x1F) / 31.0F;
+		arg2[1] = (float) (var5 >> 5 & 0x1) / 31.0F;
+		arg2[2] = (float) (var5 >> 10 & 0x1F) / 31.0F;
+		arg2[3] = var5 >> 15 & 0x1;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		assert arg0[3] >= 0.0F && arg0[3] <= 1.0F;
+		int var4 = (int) (arg0[0] * 31.0F + 0.5F) & 0x1F;
+		int var5 = var4 | ((int) (arg0[1] * 31.0F + 0.5F) & 0x1F) << 5;
+		int var6 = var5 | ((int) (arg0[2] * 31.0F + 0.5F) & 0x1F) << 10;
+		int var7 = var6 | ((int) (arg0[3] + 0.5F) & 0x1) << 15;
+		arg2.asShortBuffer().put(arg1, (short) var7);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract2101010rev.java

@@ -0,0 +1,31 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract2101010rev implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		long var4 = 0L;
+		if (arg0) {
+			var4 = Mipmap.GLU_SWAP_4_BYTES(arg1.getInt()) & 0xFFFFFFFF;
+		} else {
+			var4 = arg1.getInt() & 0xFFFFFFFF;
+		}
+		arg2[0] = (float) (var4 & 0x3FFL) / 1023.0F;
+		arg2[1] = (float) (var4 >> 10 & 0x3FFL) / 1023.0F;
+		arg2[2] = (float) (var4 >> 20 & 0x3FFL) / 1023.0F;
+		arg2[3] = (float) (var4 >> 30 & 0xFFFFFFFFFFFFFFFFL) / 3.0F;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		assert arg0[3] >= 0.0F && arg0[3] <= 1.0F;
+		long var4 = (long) ((int) (arg0[0] * 1023.0F + 0.5F) & 0x3FF);
+		long var6 = var4 | (long) (((int) (arg0[1] * 1023.0F + 0.5F) & 0x3FF) << 10);
+		long var7 = var6 | (long) (((int) (arg0[2] * 1023.0F + 0.5F) & 0x3FF) << 20);
+		long var8 = var7 | (long) (((int) (arg0[3] * 3.0F + 0.5F) & 0x3) << 30);
+		arg2.asIntBuffer().put(arg1, (int) var8);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract233rev.java

@@ -0,0 +1,24 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract233rev implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		byte var4 = arg1.get();
+		arg2[0] = (float) (var4 & 0x7) / 7.0F;
+		arg2[1] = (float) (var4 >> 3 & 0x7) / 7.0F;
+		arg2[2] = (float) (var4 >> 6 & 0x3) / 3.0F;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		byte var4 = (byte) ((int) (arg0[0] * 7.0F + 0.5F) & 0x7);
+		byte var5 = (byte) (var4 | (byte) (((int) (arg0[1] * 7.0F + 0.5F) & 0x7) << 3));
+		byte var6 = (byte) (var5 | (byte) (((int) (arg0[2] * 3.0F + 0.5F) & 0x3) << 6));
+		arg2.position(arg1);
+		arg2.put(var6);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract332.java

@@ -0,0 +1,23 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract332 implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		byte var4 = arg1.get();
+		arg2[0] = (float) (var4 >> 5 & 0x7) / 7.0F;
+		arg2[1] = (float) (var4 >> 2 & 0x7) / 7.0F;
+		arg2[2] = (float) (var4 & 0x3) / 3.0F;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		byte var4 = (byte) (((int) (arg0[0] * 7.0F + 0.5F) & 0x7) << 5);
+		byte var5 = (byte) (var4 | (byte) (((int) (arg0[1] * 7.0F + 0.5F) & 0x7) << 2));
+		byte var6 = (byte) (var5 | (byte) ((int) (arg0[2] * 3.0F + 0.5F) & 0x3));
+		arg2.put(arg1, var6);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract4444.java

@@ -0,0 +1,31 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract4444 implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		boolean var4 = false;
+		int var5;
+		if (arg0) {
+			var5 = Mipmap.GLU_SWAP_2_BYTES(arg1.getShort()) & 0xFFFF;
+		} else {
+			var5 = arg1.getShort() & 0xFFFF;
+		}
+		arg2[0] = (float) (var5 >> 12 & 0xF) / 15.0F;
+		arg2[1] = (float) (var5 >> 8 & 0xF) / 15.0F;
+		arg2[2] = (float) (var5 >> 4 & 0xF) / 15.0F;
+		arg2[3] = (float) (var5 & 0xF) / 15.0F;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		int var4 = ((int) (arg0[0] * 15.0F + 0.5F) & 0xF) << 12;
+		int var5 = var4 | ((int) (arg0[1] * 15.0F + 0.5F) & 0xF) << 8;
+		int var6 = var5 | ((int) (arg0[2] * 15.0F + 0.5F) & 0xF) << 4;
+		int var7 = var6 | (int) (arg0[3] * 15.0F + 0.5F) & 0xF;
+		arg2.asShortBuffer().put(arg1, (short) var7);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract4444rev.java

@@ -0,0 +1,32 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract4444rev implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		boolean var4 = false;
+		int var5;
+		if (arg0) {
+			var5 = Mipmap.GLU_SWAP_2_BYTES(arg1.getShort()) & 0xFFFF;
+		} else {
+			var5 = arg1.getShort() & 0xFFFF;
+		}
+		arg2[0] = (float) (var5 & 0xF) / 15.0F;
+		arg2[1] = (float) (var5 >> 4 & 0xF) / 15.0F;
+		arg2[2] = (float) (var5 >> 8 & 0xF) / 15.0F;
+		arg2[3] = (float) (var5 >> 12 & 0xF) / 15.0F;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		assert arg0[3] >= 0.0F && arg0[3] <= 1.0F;
+		int var4 = (int) (arg0[0] * 15.0F + 0.5F) & 0xF;
+		int var5 = var4 | ((int) (arg0[1] * 15.0F + 0.5F) & 0xF) << 4;
+		int var6 = var5 | ((int) (arg0[2] * 15.0F + 0.5F) & 0xF) << 8;
+		int var7 = var6 | ((int) (arg0[3] * 15.0F + 0.5F) & 0xF) << 12;
+		arg2.asShortBuffer().put(arg1, (short) var7);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract5551.java

@@ -0,0 +1,32 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract5551 implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		boolean var4 = false;
+		int var5;
+		if (arg0) {
+			var5 = Mipmap.GLU_SWAP_2_BYTES(arg1.getShort()) & 0xFFFF;
+		} else {
+			var5 = arg1.getShort() & 0xFFFF;
+		}
+		arg2[0] = (float) (var5 >> 11 & 0x1F) / 31.0F;
+		arg2[1] = (float) (var5 >> 6 & 0x3) / 31.0F;
+		arg2[2] = (float) (var5 >> 1 & 0x780) / 31.0F;
+		arg2[3] = var5 & 0xF000;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		assert arg0[3] >= 0.0F && arg0[3] <= 1.0F;
+		int var4 = ((int) (arg0[0] * 31.0F + 0.5F) & 0x1F) << 11;
+		int var5 = var4 | ((int) (arg0[1] * 31.0F + 0.5F) & 0x1F) << 6;
+		int var6 = var5 | ((int) (arg0[2] * 31.0F + 0.5F) & 0x1F) << 1;
+		int var7 = var6 | (int) (arg0[3] + 0.5F) & 0x1;
+		arg2.asShortBuffer().put(arg1, (short) var7);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract565.java

@@ -0,0 +1,29 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract565 implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		boolean var4 = false;
+		int var5;
+		if (arg0) {
+			var5 = Mipmap.GLU_SWAP_2_BYTES(arg1.getShort()) & 0xFFFF;
+		} else {
+			var5 = arg1.getShort() & 0xFFFF;
+		}
+		arg2[0] = (float) (var5 >> 11 & 0x1F) / 31.0F;
+		arg2[1] = (float) (var5 >> 5 & 0x3F) / 63.0F;
+		arg2[2] = (float) (var5 & 0x1F) / 31.0F;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		int var4 = ((int) (arg0[0] * 31.0F + 0.5F) & 0x1F) << 11;
+		int var5 = var4 | ((int) (arg0[1] * 63.0F + 0.5F) & 0x3F) << 5;
+		int var6 = var5 | (int) (arg0[2] * 31.0F + 0.5F) & 0x1F;
+		arg2.asShortBuffer().put(arg1, (short) var6);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract565rev.java

@@ -0,0 +1,29 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract565rev implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		boolean var4 = false;
+		int var5;
+		if (arg0) {
+			var5 = Mipmap.GLU_SWAP_2_BYTES(arg1.getShort()) & 0xFFFF;
+		} else {
+			var5 = arg1.getShort() & 0xFFFF;
+		}
+		arg2[0] = (float) (var5 & 0x1F) / 31.0F;
+		arg2[1] = (float) (var5 >> 5 & 0x3F) / 63.0F;
+		arg2[2] = (float) (var5 >> 11 & 0x1F) / 31.0F;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		int var4 = (int) (arg0[0] * 31.0F + 0.5F) & 0x1F;
+		int var5 = var4 | ((int) (arg0[1] * 63.0F + 0.5F) & 0x3F) << 5;
+		int var6 = var5 | ((int) (arg0[2] * 31.0F + 0.5F) & 0x1F) << 11;
+		arg2.asShortBuffer().put(arg1, (short) var6);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract8888.java

@@ -0,0 +1,31 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract8888 implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		long var4 = 0L;
+		if (arg0) {
+			var4 = Mipmap.GLU_SWAP_4_BYTES(arg1.getInt()) & 0xFFFFFFFF;
+		} else {
+			var4 = arg1.getInt() & 0xFFFFFFFF;
+		}
+		arg2[0] = (float) (var4 >> 24 & 0xFFFFFFFFFFFFFFFFL) / 255.0F;
+		arg2[1] = (float) (var4 >> 16 & 0xFFL) / 255.0F;
+		arg2[2] = (float) (var4 >> 8 & 0xFFL) / 255.0F;
+		arg2[3] = (float) (var4 & 0xFFL) / 255.0F;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		assert arg0[3] >= 0.0F && arg0[3] <= 1.0F;
+		long var4 = (long) (((int) (arg0[0] * 255.0F + 0.5F) & 0xFF) << 24);
+		long var6 = var4 | (long) (((int) (arg0[1] * 255.0F + 0.5F) & 0xFF) << 16);
+		long var7 = var6 | (long) (((int) (arg0[2] * 255.0F + 0.5F) & 0xFF) << 8);
+		long var8 = var7 | (long) ((int) (arg0[3] * 255.0F + 0.5F) & 0xFF);
+		arg2.asIntBuffer().put(arg1, (int) var8);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Extract8888rev.java

@@ -0,0 +1,31 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Extract8888rev implements Extract {
+
+	public void extract(boolean arg0, ByteBuffer arg1, float[] arg2) {
+		long var4 = 0L;
+		if (arg0) {
+			var4 = Mipmap.GLU_SWAP_4_BYTES(arg1.getInt()) & 0xFFFFFFFF;
+		} else {
+			var4 = arg1.getInt() & 0xFFFFFFFF;
+		}
+		arg2[0] = (float) (var4 & 0xFFL) / 255.0F;
+		arg2[1] = (float) (var4 >> 8 & 0xFFL) / 255.0F;
+		arg2[2] = (float) (var4 >> 16 & 0xFFL) / 255.0F;
+		arg2[3] = (float) (var4 >> 24 & 0xFFFFFFFFFFFFFFFFL) / 255.0F;
+	}
+
+	public void shove(float[] arg0, int arg1, ByteBuffer arg2) {
+		assert arg0[0] >= 0.0F && arg0[0] <= 1.0F;
+		assert arg0[1] >= 0.0F && arg0[1] <= 1.0F;
+		assert arg0[2] >= 0.0F && arg0[2] <= 1.0F;
+		assert arg0[3] >= 0.0F && arg0[3] <= 1.0F;
+		long var4 = (long) ((int) (arg0[0] * 255.0F + 0.5F) & 0xFF);
+		long var6 = var4 | (long) (((int) (arg0[1] * 255.0F + 0.5F) & 0xFF) << 8);
+		long var7 = var6 | (long) (((int) (arg0[2] * 255.0F + 0.5F) & 0xFF) << 16);
+		long var8 = var7 | (long) (((int) (arg0[3] * 255.0F + 0.5F) & 0xFF) << 24);
+		arg2.asIntBuffer().put(arg1, (int) var8);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/HalveImage.java

@@ -0,0 +1,922 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.nio.ShortBuffer;
+
+public class HalveImage {
+
+	public static void halveImage(int arg0, int arg1, int arg2, ShortBuffer arg3, ShortBuffer arg4) {
+		int var11 = 0;
+		boolean var12 = false;
+		int var8 = arg1 / 2;
+		int var9 = arg2 / 2;
+		int var10 = arg1 * arg0;
+		for (int var5 = 0; var5 < var9; var5++) {
+			for (int var6 = 0; var6 < var8; var6++) {
+				for (int var7 = 0; var7 < arg0; var7++) {
+					arg3.position(var11);
+					short var13 = arg3.get();
+					arg3.position(var11 + arg0);
+					short var14 = (short) (var13 + arg3.get());
+					arg3.position(var11 + var10);
+					short var15 = (short) (var14 + arg3.get());
+					arg3.position(var11 + var10 + arg0);
+					short var16 = (short) (var15 + arg3.get());
+					short var17 = (short) (var16 + 2);
+					short var18 = (short) (var17 / 4);
+					arg4.put(var18);
+					var11++;
+				}
+				var11 += arg0;
+			}
+			var11 += var10;
+		}
+	}
+
+	public static void halveImage_ubyte(int arg0, int arg1, int arg2, ByteBuffer arg3, ByteBuffer arg4, int arg5, int arg6, int arg7) {
+		if (arg1 == 1 || arg2 == 1) {
+			assert arg1 != 1 || arg2 != 1;
+			halve1Dimage_ubyte(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+			return;
+		}
+		int var11 = arg1 / 2;
+		int var12 = arg2 / 2;
+		boolean var13 = false;
+		int var14 = 0;
+		boolean var15 = false;
+		for (int var8 = 0; var8 < var12; var8++) {
+			for (int var9 = 0; var9 < var11; var9++) {
+				for (int var10 = 0; var10 < arg0; var10++) {
+					arg3.position(var14);
+					int var16 = arg3.get() & 0xFF;
+					arg3.position(var14 + arg7);
+					int var17 = var16 + (arg3.get() & 0xFF);
+					arg3.position(var14 + arg6);
+					int var18 = var17 + (arg3.get() & 0xFF);
+					arg3.position(var14 + arg6 + arg7);
+					int var19 = var18 + (arg3.get() & 0xFF) + 2;
+					arg4.put((byte) (var19 / 4));
+					var14 += arg5;
+				}
+				var14 += arg7;
+			}
+			var14 += arg6;
+		}
+	}
+
+	public static void halve1Dimage_ubyte(int arg0, int arg1, int arg2, ByteBuffer arg3, ByteBuffer arg4, int arg5, int arg6, int arg7) {
+		int var8 = arg1 / 2;
+		int var9 = arg2 / 2;
+		int var10 = 0;
+		int var11 = 0;
+		boolean var13 = false;
+		assert arg1 == 1 || arg2 == 1;
+		assert arg1 != arg2;
+		int var12;
+		int var14;
+		int var16;
+		if (arg2 == 1) {
+			assert arg1 != 1;
+			var9 = 1;
+			for (var12 = 0; var12 < var8; var12++) {
+				for (var14 = 0; var14 < arg0; var14++) {
+					arg3.position(var10);
+					var16 = arg3.get() & 0xFF;
+					arg3.position(var10 + arg7);
+					int var17 = var16 + (arg3.get() & 0xFF);
+					int var18 = var17 / 2;
+					arg4.put((byte) var18);
+					var10 += arg5;
+					var11++;
+				}
+				var10 += arg7;
+			}
+			var14 = arg6 - arg1 * arg7;
+			var10 += var14;
+		} else if (arg1 == 1) {
+			var14 = arg6 - arg1 * arg7;
+			assert arg2 != 1;
+			var8 = 1;
+			for (var12 = 0; var12 < var9; var12++) {
+				for (int var15 = 0; var15 < arg0; var15++) {
+					arg3.position(var10);
+					var16 = arg3.get() & 0xFF;
+					arg3.position(var10 + arg6);
+					var16 += arg3.get() & 0xFF;
+					var16 /= 2;
+					arg4.put((byte) var16);
+					var10 += arg5;
+					var11++;
+				}
+				var10 += var14;
+				var10 += arg6;
+			}
+		}
+		assert var10 == arg6 * arg2;
+		assert var11 == arg0 * arg5 * var8 * var9;
+	}
+
+	public static void halveImage_byte(int arg0, int arg1, int arg2, ByteBuffer arg3, ByteBuffer arg4, int arg5, int arg6, int arg7) {
+		boolean var13 = false;
+		int var14 = 0;
+		boolean var15 = false;
+		if (arg1 == 1 || arg2 == 1) {
+			assert arg1 != 1 || arg2 != 1;
+			halve1Dimage_byte(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+			return;
+		}
+		int var11 = arg1 / 2;
+		int var12 = arg2 / 2;
+		for (int var8 = 0; var8 < var12; var8++) {
+			for (int var9 = 0; var9 < var11; var9++) {
+				for (int var10 = 0; var10 < arg0; var10++) {
+					arg3.position(var14);
+					byte var16 = arg3.get();
+					arg3.position(var14 + arg7);
+					byte var17 = (byte) (var16 + arg3.get());
+					arg3.position(var14 + arg6);
+					byte var18 = (byte) (var17 + arg3.get());
+					arg3.position(var14 + arg6 + arg7);
+					byte var19 = (byte) (var18 + arg3.get());
+					byte var20 = (byte) (var19 + 2);
+					byte var21 = (byte) (var20 / 4);
+					arg4.put(var21);
+					var14 += arg5;
+				}
+				var14 += arg7;
+			}
+			var14 += arg6;
+		}
+	}
+
+	public static void halve1Dimage_byte(int arg0, int arg1, int arg2, ByteBuffer arg3, ByteBuffer arg4, int arg5, int arg6, int arg7) {
+		int var8 = arg1 / 2;
+		int var9 = arg1 / 2;
+		int var10 = 0;
+		int var11 = 0;
+		boolean var13 = false;
+		assert arg1 == 1 || arg2 == 1;
+		assert arg1 != arg2;
+		int var12;
+		int var14;
+		byte var16;
+		if (arg2 == 1) {
+			assert arg1 != 1;
+			var9 = 1;
+			for (var12 = 0; var12 < var8; var12++) {
+				for (var14 = 0; var14 < arg0; var14++) {
+					arg3.position(var10);
+					var16 = arg3.get();
+					arg3.position(var10 + arg7);
+					byte var17 = (byte) (var16 + arg3.get());
+					byte var18 = (byte) (var17 / 2);
+					arg4.put(var18);
+					var10 += arg5;
+					var11++;
+				}
+				var10 += arg7;
+			}
+			var14 = arg6 - arg1 * arg7;
+			int var10000 = var10 + var14;
+		} else if (arg1 == 1) {
+			var14 = arg6 - arg1 * arg7;
+			assert arg2 != 1;
+			var8 = 1;
+			for (var12 = 0; var12 < var9; var12++) {
+				for (int var15 = 0; var15 < arg0; var15++) {
+					arg3.position(var10);
+					var16 = arg3.get();
+					arg3.position(var10 + arg6);
+					var16 += arg3.get();
+					var16 = (byte) (var16 / 2);
+					var10 += arg5;
+					var11++;
+				}
+				var10 += var14;
+				var10 += arg6;
+			}
+			assert var10 == arg6 * arg2;
+		}
+		assert var11 == arg0 * arg5 * var8 * var9;
+	}
+
+	public static void halveImage_ushort(int arg0, int arg1, int arg2, ByteBuffer arg3, ShortBuffer arg4, int arg5, int arg6, int arg7, boolean arg8) {
+		boolean var15 = false;
+		int var16 = 0;
+		boolean var17 = false;
+		if (arg1 == 1 || arg2 == 1) {
+			assert arg1 != 1 || arg2 != 1;
+			halve1Dimage_ushort(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+			return;
+		}
+		int var13 = arg1 / 2;
+		int var14 = arg2 / 2;
+		int var9;
+		int var10;
+		int var11;
+		int var18;
+		if (!arg8) {
+			for (var9 = 0; var9 < var14; var9++) {
+				for (var10 = 0; var10 < var13; var10++) {
+					for (var11 = 0; var11 < arg0; var11++) {
+						arg3.position(var16);
+						var18 = arg3.getShort() & 0xFFFF;
+						arg3.position(var16 + arg7);
+						int var19 = var18 + (arg3.getShort() & 0xFFFF);
+						arg3.position(var16 + arg6);
+						int var20 = var19 + (arg3.getShort() & 0xFFFF);
+						arg3.position(var16 + arg6 + arg7);
+						int var21 = var20 + (arg3.getShort() & 0xFFFF);
+						arg4.put((short) ((var21 + 2) / 4));
+						var16 += arg5;
+					}
+					var16 += arg7;
+				}
+				var16 += arg6;
+			}
+			return;
+		}
+		for (var9 = 0; var9 < var14; var9++) {
+			for (var10 = 0; var10 < var13; var10++) {
+				for (var11 = 0; var11 < arg0; var11++) {
+					arg3.position(var16);
+					var18 = Mipmap.GLU_SWAP_2_BYTES(arg3.getShort()) & 0xFFFF;
+					arg3.position(var16 + arg7);
+					var18 += Mipmap.GLU_SWAP_2_BYTES(arg3.getShort()) & 0xFFFF;
+					arg3.position(var16 + arg6);
+					var18 += Mipmap.GLU_SWAP_2_BYTES(arg3.getShort()) & 0xFFFF;
+					arg3.position(var16 + arg6 + arg7);
+					var18 += Mipmap.GLU_SWAP_2_BYTES(arg3.getShort()) & 0xFFFF;
+					arg4.put((short) ((var18 + 2) / 4));
+					var16 += arg5;
+				}
+				var16 += arg7;
+			}
+			var16 += arg6;
+		}
+	}
+
+	public static void halve1Dimage_ushort(int arg0, int arg1, int arg2, ByteBuffer arg3, ShortBuffer arg4, int arg5, int arg6, int arg7, boolean arg8) {
+		int var9 = arg1 / 2;
+		int var10 = arg2 / 2;
+		int var11 = 0;
+		int var12 = 0;
+		assert arg1 == 1 || arg2 == 1;
+		assert arg1 != arg2;
+		int var13;
+		int var14;
+		if (arg2 == 1) {
+			assert arg1 != 1;
+			var10 = 1;
+			for (var13 = 0; var13 < var9; var13++) {
+				for (var14 = 0; var14 < var10; var14++) {
+					int[] var15 = new int[2];
+					if (arg8) {
+						arg3.position(var11);
+						var15[0] = Mipmap.GLU_SWAP_2_BYTES(arg3.getShort()) & 0xFFFF;
+						arg3.position(var11 + arg7);
+						var15[1] = Mipmap.GLU_SWAP_2_BYTES(arg3.getShort()) & 0xFFFF;
+					} else {
+						arg3.position(var11);
+						var15[0] = arg3.getShort() & 0xFFFF;
+						arg3.position(var11 + arg7);
+						var15[1] = arg3.getShort() & 0xFFFF;
+					}
+					arg4.put((short) ((var15[0] + var15[1]) / 2));
+					var11 += arg5;
+					var12 += 2;
+				}
+				var11 += arg7;
+			}
+			var14 = arg6 - arg1 * arg7;
+			int var10000 = var11 + var14;
+		} else if (arg1 == 1) {
+			var14 = arg6 - arg1 * arg7;
+			assert arg2 != 1;
+			var9 = 1;
+			for (var13 = 0; var13 < var10; var13++) {
+				for (int var17 = 0; var17 < arg0; var17++) {
+					int[] var16 = new int[2];
+					if (arg8) {
+						arg3.position(var11);
+						var16[0] = Mipmap.GLU_SWAP_2_BYTES(arg3.getShort()) & 0xFFFF;
+						arg3.position(var11 + arg6);
+						var16[0] = Mipmap.GLU_SWAP_2_BYTES(arg3.getShort()) & 0xFFFF;
+					} else {
+						arg3.position(var11);
+						var16[0] = arg3.getShort() & 0xFFFF;
+						arg3.position(var11 + arg6);
+						var16[1] = arg3.getShort() & 0xFFFF;
+					}
+					arg4.put((short) ((var16[0] + var16[1]) / 2));
+					var11 += arg5;
+					var12 += 2;
+				}
+				var11 += var14;
+				var11 += arg6;
+			}
+			assert var11 == arg6 * arg2;
+		}
+		assert var12 == arg0 * arg5 * var9 * var10;
+	}
+
+	public static void halveImage_short(int arg0, int arg1, int arg2, ByteBuffer arg3, ShortBuffer arg4, int arg5, int arg6, int arg7, boolean arg8) {
+		boolean var15 = false;
+		int var16 = 0;
+		boolean var17 = false;
+		if (arg1 == 1 || arg2 == 1) {
+			assert arg1 != 1 || arg2 != 1;
+			halve1Dimage_short(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+			return;
+		}
+		int var13 = arg1 / 2;
+		int var14 = arg2 / 2;
+		int var9;
+		int var10;
+		int var11;
+		short var20;
+		if (!arg8) {
+			for (var9 = 0; var9 < var14; var9++) {
+				for (var10 = 0; var10 < var13; var10++) {
+					for (var11 = 0; var11 < arg0; var11++) {
+						arg3.position(var16);
+						var20 = arg3.getShort();
+						arg3.position(var16 + arg7);
+						short var21 = (short) (var20 + arg3.getShort());
+						arg3.position(var16 + arg6);
+						short var22 = (short) (var21 + arg3.getShort());
+						arg3.position(var16 + arg6 + arg7);
+						short var23 = (short) (var22 + arg3.getShort());
+						short var24 = (short) (var23 + 2);
+						short var25 = (short) (var24 / 4);
+						arg4.put(var25);
+						var16 += arg5;
+					}
+					var16 += arg7;
+				}
+				var16 += arg6;
+			}
+			return;
+		}
+		for (var9 = 0; var9 < var14; var9++) {
+			for (var10 = 0; var10 < var13; var10++) {
+				for (var11 = 0; var11 < arg0; var11++) {
+					arg3.position(var16);
+					var20 = Mipmap.GLU_SWAP_2_BYTES(arg3.getShort());
+					arg3.position(var16 + arg7);
+					var20 += Mipmap.GLU_SWAP_2_BYTES(arg3.getShort());
+					arg3.position(var16 + arg6);
+					var20 += Mipmap.GLU_SWAP_2_BYTES(arg3.getShort());
+					arg3.position(var16 + arg6 + arg7);
+					var20 += Mipmap.GLU_SWAP_2_BYTES(arg3.getShort());
+					var20 = (short) (var20 + 2);
+					var20 = (short) (var20 / 4);
+					arg4.put(var20);
+					var16 += arg5;
+				}
+				var16 += arg7;
+			}
+			var16 += arg6;
+		}
+	}
+
+	public static void halve1Dimage_short(int arg0, int arg1, int arg2, ByteBuffer arg3, ShortBuffer arg4, int arg5, int arg6, int arg7, boolean arg8) {
+		int var9 = arg1 / 2;
+		int var10 = arg2 / 2;
+		int var11 = 0;
+		int var12 = 0;
+		assert arg1 == 1 || arg2 == 1;
+		assert arg1 != arg2;
+		int var13;
+		int var14;
+		if (arg2 == 1) {
+			assert arg1 != 1;
+			var10 = 1;
+			for (var13 = 0; var13 < var9; var13++) {
+				for (var14 = 0; var14 < arg0; var14++) {
+					short[] var15 = new short[2];
+					if (arg8) {
+						arg3.position(var11);
+						var15[0] = Mipmap.GLU_SWAP_2_BYTES(arg3.getShort());
+						arg3.position(var11 + arg7);
+						var15[1] = Mipmap.GLU_SWAP_2_BYTES(arg3.getShort());
+					} else {
+						arg3.position(var11);
+						var15[0] = arg3.getShort();
+						arg3.position(var11 + arg7);
+						var15[1] = arg3.getShort();
+					}
+					arg4.put((short) ((var15[0] + var15[1]) / 2));
+					var11 += arg5;
+					var12 += 2;
+				}
+				var11 += arg7;
+			}
+			var14 = arg6 - arg1 * arg7;
+			int var10000 = var11 + var14;
+		} else if (arg1 == 1) {
+			var14 = arg6 - arg1 * arg7;
+			assert arg2 != 1;
+			var9 = 1;
+			for (var13 = 0; var13 < var10; var13++) {
+				for (int var17 = 0; var17 < arg0; var17++) {
+					short[] var16 = new short[2];
+					if (arg8) {
+						arg3.position(var11);
+						var16[0] = Mipmap.GLU_SWAP_2_BYTES(arg3.getShort());
+						arg3.position(var11 + arg6);
+						var16[1] = Mipmap.GLU_SWAP_2_BYTES(arg3.getShort());
+					} else {
+						arg3.position(var11);
+						var16[0] = arg3.getShort();
+						arg3.position(var11 + arg6);
+						var16[1] = arg3.getShort();
+					}
+					arg4.put((short) ((var16[0] + var16[1]) / 2));
+					var11 += arg5;
+					var12 += 2;
+				}
+				var11 += var14;
+				var11 += arg6;
+			}
+			assert var11 == arg6 * arg2;
+		}
+		assert var12 == arg0 * arg5 * var9 * var10;
+	}
+
+	public static void halveImage_uint(int arg0, int arg1, int arg2, ByteBuffer arg3, IntBuffer arg4, int arg5, int arg6, int arg7, boolean arg8) {
+		boolean var15 = false;
+		int var16 = 0;
+		double var17 = 0.0D;
+		if (arg1 == 1 || arg2 == 1) {
+			assert arg1 != 1 || arg2 != 1;
+			halve1Dimage_uint(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+			return;
+		}
+		int var13 = arg1 / 2;
+		int var14 = arg2 / 2;
+		int var9;
+		int var10;
+		int var11;
+		if (!arg8) {
+			for (var9 = 0; var9 < var14; var9++) {
+				for (var10 = 0; var10 < var13; var10++) {
+					for (var11 = 0; var11 < arg0; var11++) {
+						arg3.position(var16);
+						var17 = (long) arg3.getInt() & 0x7FFFFFFFL;
+						arg3.position(var16 + arg7);
+						var17 += (long) arg3.getInt() & 0x7FFFFFFFL;
+						arg3.position(var16 + arg6);
+						var17 += (long) arg3.getInt() & 0x7FFFFFFFL;
+						arg3.position(var16 + arg6 + arg7);
+						var17 += (long) arg3.getInt() & 0x7FFFFFFFL;
+						arg4.put((int) (var17 / 4.0D + 0.5D));
+						var16 += arg5;
+					}
+					var16 += arg7;
+				}
+				var16 += arg6;
+			}
+			return;
+		}
+		for (var9 = 0; var9 < var14; var9++) {
+			for (var10 = 0; var10 < var13; var10++) {
+				for (var11 = 0; var11 < arg0; var11++) {
+					arg3.position(var16);
+					double var19 = (double) (Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF);
+					arg3.position(var16 + arg7);
+					double var21 = var19 + (double) (Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF);
+					arg3.position(var16 + arg6);
+					double var22 = var21 + (double) (Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF);
+					arg3.position(var16 + arg6 + arg7);
+					double var10000 = var22 + (double) (Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF);
+					var17 /= 4.0D;
+					var17 += 0.5D;
+					arg4.put((int) var17);
+					var16 += arg5;
+				}
+				var16 += arg7;
+			}
+			var16 += arg6;
+		}
+	}
+
+	public static void halve1Dimage_uint(int arg0, int arg1, int arg2, ByteBuffer arg3, IntBuffer arg4, int arg5, int arg6, int arg7, boolean arg8) {
+		int var9 = arg1 / 2;
+		int var10 = arg2 / 2;
+		int var11 = 0;
+		int var12 = 0;
+		assert arg1 == 1 || arg2 == 1;
+		assert arg1 != arg2;
+		int var13;
+		int var14;
+		if (arg2 == 1) {
+			assert arg1 != 1;
+			var10 = 1;
+			for (var13 = 0; var13 < var9; var13++) {
+				for (var14 = 0; var14 < var10; var14++) {
+					long[] var15 = new long[2];
+					if (arg8) {
+						arg3.position(var11);
+						var15[0] = Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF;
+						arg3.position(var11 + arg7);
+						var15[1] = Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF;
+					} else {
+						arg3.position(var11);
+						var15[0] = arg3.getInt() & 0xFFFFFFFF;
+						arg3.position(var11 + arg7);
+						var15[1] = arg3.getInt() & 0xFFFFFFFF;
+					}
+					arg4.put((int) ((double) (var15[0] + var15[1]) / 2.0D));
+					var11 += arg5;
+					var12 += 4;
+				}
+				var11 += arg7;
+			}
+			var14 = arg6 - arg1 * arg7;
+			int var10000 = var11 + var14;
+		} else if (arg1 == 1) {
+			var14 = arg6 - arg1 * arg7;
+			assert arg2 != 1;
+			var9 = 1;
+			for (var13 = 0; var13 < var10; var13++) {
+				for (int var17 = 0; var17 < arg0; var17++) {
+					long[] var16 = new long[2];
+					if (arg8) {
+						arg3.position(var11);
+						var16[0] = Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF;
+						arg3.position(var11 + arg7);
+						var16[0] = Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF;
+					} else {
+						arg3.position(var11);
+						var16[0] = arg3.getInt() & 0xFFFFFFFF;
+						arg3.position(var11 + arg6);
+						var16[1] = arg3.getInt() & 0xFFFFFFFF;
+					}
+					arg4.put((int) ((double) (var16[0] + var16[1]) / 2.0D));
+					var11 += arg5;
+					var12 += 4;
+				}
+				var11 += var14;
+				var11 += arg6;
+			}
+			assert var11 == arg6 * arg2;
+		}
+		assert var12 == arg0 * arg5 * var9 * var10;
+	}
+
+	public static void halveImage_int(int arg0, int arg1, int arg2, ByteBuffer arg3, IntBuffer arg4, int arg5, int arg6, int arg7, boolean arg8) {
+		boolean var15 = false;
+		int var16 = 0;
+		boolean var17 = false;
+		if (arg1 == 1 || arg2 == 1) {
+			assert arg1 != 1 || arg2 != 1;
+			halve1Dimage_int(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+			return;
+		}
+		int var13 = arg1 / 2;
+		int var14 = arg2 / 2;
+		int var9;
+		int var10;
+		int var11;
+		if (!arg8) {
+			for (var9 = 0; var9 < var14; var9++) {
+				for (var10 = 0; var10 < var13; var10++) {
+					for (var11 = 0; var11 < arg0; var11++) {
+						arg3.position(var16);
+						int var21 = arg3.getInt();
+						arg3.position(var16 + arg7);
+						int var22 = var21 + arg3.getInt();
+						arg3.position(var16 + arg6);
+						int var23 = var22 + arg3.getInt();
+						arg3.position(var16 + arg6 + arg7);
+						int var25 = var23 + arg3.getInt();
+						int var27 = (int) ((float) var25 / 4.0F + 0.5F);
+						arg4.put(var27);
+						var16 += arg5;
+					}
+					var16 += arg7;
+				}
+				var16 += arg6;
+			}
+			return;
+		}
+		for (var9 = 0; var9 < var14; var9++) {
+			for (var10 = 0; var10 < var13; var10++) {
+				for (var11 = 0; var11 < arg0; var11++) {
+					arg3.position(var16);
+					long var18 = (long) (Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF);
+					float var20 = (float) var18;
+					arg3.position(var16 + arg7);
+					long var24 = (long) (Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF);
+					float var29 = var20 + (float) var24;
+					arg3.position(var16 + arg6);
+					long var26 = (long) (Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF);
+					float var30 = var29 + (float) var26;
+					arg3.position(var16 + arg6 + arg7);
+					long var28 = (long) (Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF);
+					float var31 = var30 + (float) var28;
+					arg4.put((int) (var31 / 4.0F + 0.5F));
+					var16 += arg5;
+				}
+				var16 += arg7;
+			}
+			var16 += arg6;
+		}
+	}
+
+	public static void halve1Dimage_int(int arg0, int arg1, int arg2, ByteBuffer arg3, IntBuffer arg4, int arg5, int arg6, int arg7, boolean arg8) {
+		int var9 = arg1 / 2;
+		int var10 = arg2 / 2;
+		int var11 = 0;
+		int var12 = 0;
+		assert arg1 == 1 || arg2 == 1;
+		assert arg1 != arg2;
+		int var13;
+		int var14;
+		if (arg2 == 1) {
+			assert arg1 != 1;
+			var10 = 1;
+			for (var13 = 0; var13 < var9; var13++) {
+				for (var14 = 0; var14 < arg0; var14++) {
+					long[] var15 = new long[2];
+					if (arg8) {
+						arg3.position(var11);
+						var15[0] = Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF;
+						arg3.position(var11 + arg7);
+						var15[1] = Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF;
+					} else {
+						arg3.position(var11);
+						var15[0] = arg3.getInt() & 0xFFFFFFFF;
+						arg3.position(var11 + arg7);
+						var15[1] = arg3.getInt() & 0xFFFFFFFF;
+					}
+					arg4.put((int) (((float) var15[0] + (float) var15[1]) / 2.0F));
+					var11 += arg5;
+					var12 += 4;
+				}
+				var11 += arg7;
+			}
+			var14 = arg6 - arg1 * arg7;
+			int var10000 = var11 + var14;
+		} else if (arg1 == 1) {
+			var14 = arg6 - arg1 * arg7;
+			assert arg2 != 1;
+			var9 = 1;
+			for (var13 = 0; var13 < var10; var13++) {
+				for (int var17 = 0; var17 < arg0; var17++) {
+					long[] var16 = new long[2];
+					if (arg8) {
+						arg3.position(var11);
+						var16[0] = Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF;
+						arg3.position(var11 + arg6);
+						var16[1] = Mipmap.GLU_SWAP_4_BYTES(arg3.getInt()) & 0xFFFFFFFF;
+					} else {
+						arg3.position(var11);
+						var16[0] = arg3.getInt() & 0xFFFFFFFF;
+						arg3.position(var11 + arg6);
+						var16[1] = arg3.getInt() & 0xFFFFFFFF;
+					}
+					arg4.put((int) (((float) var16[0] + (float) var16[1]) / 2.0F));
+					var11 += arg5;
+					var12 += 4;
+				}
+				var11 += var14;
+				var11 += arg6;
+			}
+			assert var11 == arg6 * arg2;
+		}
+		assert var12 == arg0 * arg5 * var9 * var10;
+	}
+
+	public static void halveImage_float(int arg0, int arg1, int arg2, ByteBuffer arg3, FloatBuffer arg4, int arg5, int arg6, int arg7, boolean arg8) {
+		boolean var15 = false;
+		int var16 = 0;
+		float var17 = 0.0F;
+		if (arg1 == 1 || arg2 == 1) {
+			assert arg1 != 1 || arg2 != 1;
+			halve1Dimage_float(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+			return;
+		}
+		int var13 = arg1 / 2;
+		int var14 = arg2 / 2;
+		int var9;
+		int var10;
+		int var11;
+		if (!arg8) {
+			for (var9 = 0; var9 < var14; var9++) {
+				for (var10 = 0; var10 < var13; var10++) {
+					for (var11 = 0; var11 < arg0; var11++) {
+						arg3.position(var16);
+						var17 = arg3.getFloat();
+						arg3.position(var16 + arg7);
+						var17 += arg3.getFloat();
+						arg3.position(var16 + arg6);
+						var17 += arg3.getFloat();
+						arg3.position(var16 + arg6 + arg7);
+						var17 /= 4.0F;
+						arg4.put(var17);
+						var16 += arg5;
+					}
+					var16 += arg7;
+				}
+				var16 += arg6;
+			}
+			return;
+		}
+		for (var9 = 0; var9 < var14; var9++) {
+			for (var10 = 0; var10 < var13; var10++) {
+				for (var11 = 0; var11 < arg0; var11++) {
+					arg3.position(var16);
+					float var18 = Mipmap.GLU_SWAP_4_BYTES(arg3.getFloat());
+					arg3.position(var16 + arg7);
+					float var19 = var18 + Mipmap.GLU_SWAP_4_BYTES(arg3.getFloat());
+					arg3.position(var16 + arg6);
+					float var20 = var19 + Mipmap.GLU_SWAP_4_BYTES(arg3.getFloat());
+					arg3.position(var16 + arg6 + arg7);
+					float var21 = var20 + Mipmap.GLU_SWAP_4_BYTES(arg3.getFloat());
+					arg4.put(var21 / 4.0F);
+					var16 += arg5;
+				}
+				var16 += arg7;
+			}
+			var16 += arg6;
+		}
+	}
+
+	public static void halve1Dimage_float(int arg0, int arg1, int arg2, ByteBuffer arg3, FloatBuffer arg4, int arg5, int arg6, int arg7, boolean arg8) {
+		int var9 = arg1 / 2;
+		int var10 = arg2 / 2;
+		int var11 = 0;
+		int var12 = 0;
+		assert arg1 == 1 || arg2 == 1;
+		assert arg1 != arg2;
+		int var13;
+		int var14;
+		if (arg2 == 1) {
+			assert arg1 != 1;
+			var10 = 1;
+			for (var13 = 0; var13 < var9; var13++) {
+				for (var14 = 0; var14 < arg0; var14++) {
+					float[] var15 = new float[2];
+					if (arg8) {
+						arg3.position(var11);
+						var15[0] = Mipmap.GLU_SWAP_4_BYTES(arg3.getFloat());
+						arg3.position(var11 + arg7);
+						var15[1] = Mipmap.GLU_SWAP_4_BYTES(arg3.getFloat());
+					} else {
+						arg3.position(var11);
+						var15[0] = arg3.getFloat();
+						arg3.position(var11 + arg7);
+						var15[1] = arg3.getFloat();
+					}
+					arg4.put((var15[0] + var15[1]) / 2.0F);
+					var11 += arg5;
+					var12 += 4;
+				}
+				var11 += arg7;
+			}
+			var14 = arg6 - arg1 * arg7;
+			int var10000 = var11 + var14;
+		} else if (arg1 == 1) {
+			var14 = arg6 - arg1 * arg7;
+			assert arg2 != 1;
+			var9 = 1;
+			for (var13 = 0; var13 < var10; var13++) {
+				for (int var17 = 0; var17 < arg0; var17++) {
+					float[] var16 = new float[2];
+					if (arg8) {
+						arg3.position(var11);
+						var16[0] = Mipmap.GLU_SWAP_4_BYTES(arg3.getFloat());
+						arg3.position(var11 + arg6);
+						var16[1] = Mipmap.GLU_SWAP_4_BYTES(arg3.getFloat());
+					} else {
+						arg3.position(var11);
+						var16[0] = arg3.getFloat();
+						arg3.position(var11 + arg6);
+						var16[1] = arg3.getFloat();
+					}
+					arg4.put((var16[0] + var16[1]) / 2.0F);
+					var11 += arg5;
+					var12 += 4;
+				}
+				var11 += var14;
+				var11 += arg6;
+			}
+			assert var11 == arg6 * arg2;
+		}
+		assert var12 == arg0 * arg5 * var9 * var10;
+	}
+
+	public static void halveImagePackedPixel(int arg0, Extract arg1, int arg2, int arg3, ByteBuffer arg4, ByteBuffer arg5, int arg6, int arg7, boolean arg8) {
+		if (arg2 == 1 || arg3 == 1) {
+			assert arg2 != 1 || arg3 != 1;
+			halve1DimagePackedPixel(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+			return;
+		}
+		int var11 = arg2 / 2;
+		int var12 = arg3 / 2;
+		int var13 = 0;
+		int var14 = arg7 - arg2 * arg6;
+		int var15 = 0;
+		for (int var9 = 0; var9 < var12; var9++) {
+			for (int var10 = 0; var10 < var11; var10++) {
+				float[] var16 = new float[4];
+				float[][] var17 = new float[4][4];
+				arg4.position(var13);
+				arg1.extract(arg8, arg4, var17[0]);
+				arg4.position(var13 + arg6);
+				arg1.extract(arg8, arg4, var17[1]);
+				arg4.position(var13 + arg7);
+				arg1.extract(arg8, arg4, var17[2]);
+				arg4.position(var13 + arg7 + arg6);
+				arg1.extract(arg8, arg4, var17[3]);
+				for (int var18 = 0; var18 < arg0; var18++) {
+					boolean var19 = false;
+					var16[var18] = 0.0F;
+					for (int var20 = 0; var20 < 4; var20++) {
+						var16[var18] += var17[var20][var18];
+					}
+					var16[var18] /= 4.0F;
+				}
+				arg1.shove(var16, var15, arg5);
+				var15++;
+				var13 += arg6 + arg6;
+			}
+			var13 += var14;
+			var13 += arg7;
+		}
+		assert var13 == arg7 * arg3;
+		assert var15 == var11 * var12;
+	}
+
+	public static void halve1DimagePackedPixel(int arg0, Extract arg1, int arg2, int arg3, ByteBuffer arg4, ByteBuffer arg5, int arg6, int arg7, boolean arg8) {
+		int var9 = arg2 / 2;
+		int var10 = arg3 / 2;
+		int var11 = 0;
+		assert arg2 == 1 || arg3 == 1;
+		assert arg2 != arg3;
+		int var12;
+		int var13;
+		float[] var14;
+		float[][] var15;
+		int var16;
+		boolean var17;
+		int var21;
+		if (arg3 == 1) {
+			var13 = 0;
+			assert arg2 != 1;
+			byte var19 = 1;
+			for (var12 = 0; var12 < var9; var12++) {
+				var14 = new float[4];
+				var15 = new float[2][4];
+				arg4.position(var11);
+				arg1.extract(arg8, arg4, var15[0]);
+				arg4.position(var11 + arg6);
+				arg1.extract(arg8, arg4, var15[1]);
+				for (var16 = 0; var16 < arg0; var16++) {
+					var17 = false;
+					var14[var16] = 0.0F;
+					for (var21 = 0; var21 < 2; var21++) {
+						var14[var16] += var15[var21][var16];
+					}
+					var14[var16] /= 2.0F;
+				}
+				arg1.shove(var14, var13, arg5);
+				var13++;
+				var11 += arg6 + arg6;
+			}
+			int var20 = arg7 - arg2 * arg6;
+			var11 += var20;
+			assert var11 == arg7;
+			assert var13 == var9 * var19;
+		} else if (arg2 == 1) {
+			var13 = 0;
+			assert arg3 != 1;
+			byte var18 = 1;
+			for (var12 = 0; var12 < var10; var12++) {
+				var14 = new float[4];
+				var15 = new float[2][4];
+				arg4.position(var11);
+				arg1.extract(arg8, arg4, var15[0]);
+				arg4.position(var11 + arg7);
+				arg1.extract(arg8, arg4, var15[1]);
+				for (var16 = 0; var16 < arg0; var16++) {
+					var17 = false;
+					var14[var16] = 0.0F;
+					for (var21 = 0; var21 < 2; var21++) {
+						var14[var16] += var15[var21][var16];
+					}
+					var14[var16] /= 2.0F;
+				}
+				arg1.shove(var14, var13, arg5);
+				var13++;
+				var11 += arg7 + arg7;
+			}
+			assert var11 == arg7;
+			assert var13 == var18 * var10;
+		}
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Image.java

@@ -0,0 +1,318 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+import java.nio.ShortBuffer;
+
+public class Image {
+
+	public static void fill_image(PixelStorageModes arg0, int arg1, int arg2, int arg3, int arg4, boolean arg5, ByteBuffer arg6, ShortBuffer arg7) {
+		int var16 = 0;
+		Object var22 = null;
+		switch(arg4) {
+			case 32818:
+				var22 = new Extract332();
+				break;
+			case 32819:
+				var22 = new Extract4444();
+				break;
+			case 32820:
+				var22 = new Extract5551();
+				break;
+			case 32821:
+				var22 = new Extract8888();
+				break;
+			case 32822:
+				var22 = new Extract1010102();
+				break;
+			case 33634:
+				var22 = new Extract233rev();
+				break;
+			case 33635:
+				var22 = new Extract565();
+				break;
+			case 33636:
+				var22 = new Extract565rev();
+				break;
+			case 33637:
+				var22 = new Extract4444rev();
+				break;
+			case 33638:
+				var22 = new Extract1555rev();
+				break;
+			case 33639:
+				var22 = new Extract8888rev();
+				break;
+			case 33640:
+				var22 = new Extract2101010rev();
+		}
+		boolean var21 = arg0.getUnpackSwapBytes();
+		int var8 = Mipmap.elements_per_group(arg3, arg4);
+		int var12;
+		if (arg0.getUnpackRowLength() > 0) {
+			var12 = arg0.getUnpackRowLength();
+		} else {
+			var12 = arg1;
+		}
+		int var10;
+		int var11;
+		int var14;
+		int var15;
+		int var17;
+		int var18;
+		int var19;
+		if (arg4 == 6656) {
+			var10 = (var12 * var8 + 7) / 8;
+			var11 = var10 % arg0.getUnpackAlignment();
+			if (var11 != 0) {
+				var10 += arg0.getUnpackAlignment() - var11;
+			}
+			var15 = arg0.getUnpackSkipRows() * var10 + arg0.getUnpackSkipPixels() * var8 / 8;
+			var14 = arg1 * var8;
+			var17 = 0;
+			for (var18 = 0; var18 < arg2; var18++) {
+				var16 = var15;
+				arg6.position(var15);
+				int var23 = arg0.getUnpackSkipPixels() * var8 % 8;
+				for (var19 = 0; var19 < var14; var19++) {
+					int var24;
+					if (arg0.getUnpackLsbFirst()) {
+						arg6.position(var16);
+						var24 = arg6.get() & 0xFF & 0x1 << var23;
+					} else {
+						var24 = arg6.get() & 0xFF & 0x1 << 7 - var23;
+					}
+					if (var24 == 0) {
+						arg7.position(var17);
+						arg7.put((short) 0);
+					} else if (arg5) {
+						arg7.position(var17);
+						arg7.put((short) 1);
+					} else {
+						arg7.position(var17);
+						arg7.put((short) -1);
+					}
+					var23++;
+					if (var23 == 8) {
+						var23 = 0;
+						var16++;
+					}
+					var17++;
+				}
+				var15 += var10;
+			}
+			return;
+		}
+		int var9 = Mipmap.bytes_per_element(arg4);
+		int var13 = var9 * var8;
+		if (var9 == 1) {
+			var21 = false;
+		}
+		var10 = var12 * var13;
+		var11 = var10 % arg0.getUnpackAlignment();
+		if (var11 != 0) {
+			var10 += arg0.getUnpackAlignment() - var11;
+		}
+		var15 = arg0.getUnpackSkipRows() * var10 + arg0.getUnpackSkipPixels() * var13;
+		var14 = arg1 * var8;
+		var17 = 0;
+		for (var18 = 0; var18 < arg2; var18++) {
+			var16 = var15;
+			arg6.position(var15);
+			for (var19 = 0; var19 < var14; var19++) {
+				Type_Widget var25 = new Type_Widget();
+				float[] var26 = new float[4];
+				arg6.position(var16);
+				int var20;
+				label219: switch(arg4) {
+					case 5120:
+						if (arg5) {
+							arg7.put(var17++, (short) arg6.get());
+						} else {
+							arg7.put(var17++, (short) (arg6.get() * 516));
+						}
+						break;
+					case 5121:
+						if (arg5) {
+							arg7.put(var17++, (short) (arg6.get() & 0xFF));
+						} else {
+							arg7.put(var17++, (short) (arg6.get() * 257 & 0xFF));
+						}
+						break;
+					case 5122:
+					case 5123:
+						if (var21) {
+							var25.setUB1(arg6.get());
+							var25.setUB0(arg6.get());
+						} else {
+							var25.setUB0(arg6.get());
+							var25.setUB1(arg6.get());
+						}
+						if (arg4 != 5122) {
+							arg7.put(var17++, var25.getUS0());
+						} else if (arg5) {
+							arg7.put(var17++, var25.getS0());
+						} else {
+							arg7.put(var17++, (short) (var25.getS0() * 2));
+						}
+						break;
+					case 5124:
+					case 5125:
+					case 5126:
+						if (var21) {
+							var25.setUB3(arg6.get());
+							var25.setUB2(arg6.get());
+							var25.setUB1(arg6.get());
+							var25.setUB0(arg6.get());
+						} else {
+							var25.setUB0(arg6.get());
+							var25.setUB1(arg6.get());
+							var25.setUB2(arg6.get());
+							var25.setUB3(arg6.get());
+						}
+						if (arg4 == 5126) {
+							if (arg5) {
+								arg7.put(var17++, (short) var25.getF());
+							} else {
+								arg7.put(var17++, (short) (var25.getF() * 65535.0F));
+							}
+						} else if (arg4 == 5125) {
+							if (arg5) {
+								arg7.put(var17++, (short) var25.getUI());
+							} else {
+								arg7.put(var17++, (short) (var25.getUI() >> 16));
+							}
+						} else if (arg5) {
+							arg7.put(var17++, (short) var25.getI());
+						} else {
+							arg7.put(var17++, (short) (var25.getI() >> 15));
+						}
+						break;
+					case 32818:
+						((Extract) var22).extract(false, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 3) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 32819:
+						((Extract) var22).extract(var21, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 4) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 32820:
+						((Extract) var22).extract(var21, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 4) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 32821:
+						((Extract) var22).extract(var21, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 4) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 32822:
+						((Extract) var22).extract(var21, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 4) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 33634:
+						((Extract) var22).extract(false, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 3) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 33635:
+						((Extract) var22).extract(var21, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 3) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 33636:
+						((Extract) var22).extract(var21, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 3) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 33637:
+						((Extract) var22).extract(var21, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 4) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 33638:
+						((Extract) var22).extract(var21, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 4) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 33639:
+						((Extract) var22).extract(var21, arg6, var26);
+						var20 = 0;
+						while (true) {
+							if (var20 >= 4) {
+								break label219;
+							}
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+							var20++;
+						}
+					case 33640:
+						((Extract) var22).extract(var21, arg6, var26);
+						for (var20 = 0; var20 < 4; var20++) {
+							arg7.put(var17++, (short) (var26[var20] * 65535.0F));
+						}
+				}
+				var16 += var9;
+			}
+			var15 += var10;
+			var16 = var15;
+		}
+		if (Mipmap.isTypePackedPixel(arg4)) {
+			assert var17 == arg1 * arg2 * Mipmap.elements_per_group(arg3, 0);
+		} else {
+			assert var17 == arg1 * arg2 * var8;
+		}
+		assert var16 == var10 * arg2 + arg0.getUnpackSkipRows() * var10 + arg0.getUnpackSkipPixels() * var13;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Mipmap.java

@@ -0,0 +1,332 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.nio.ShortBuffer;
+import javax.media.opengl.GL;
+import javax.media.opengl.GLException;
+
+public class Mipmap {
+
+	public static int computeLog(int arg0) {
+		int var1 = 0;
+		if (arg0 == 0) {
+			return -1;
+		}
+		while ((arg0 & 0x1) < 1) {
+			arg0 >>= 0x1;
+			var1++;
+		}
+		return arg0 == 1 ? var1 : -1;
+	}
+
+	public static int nearestPower(int arg0) {
+		int var1 = 1;
+		if (arg0 == 0) {
+			return -1;
+		}
+		while (arg0 != 1) {
+			if (arg0 == 3) {
+				return var1 * 4;
+			}
+			arg0 >>= 0x1;
+			var1 *= 2;
+		}
+		return var1;
+	}
+
+	public static short GLU_SWAP_2_BYTES(short arg0) {
+		boolean var1 = false;
+		byte var3 = (byte) (arg0 >>> 8);
+		short var2 = (short) (arg0 << 8);
+		return (short) (var2 | var3 & 0xFF);
+	}
+
+	public static int GLU_SWAP_4_BYTES(int arg0) {
+		int var1 = arg0 << 24;
+		int var2 = var1 | (arg0 & 0xFF00) << 8;
+		int var3 = var2 | arg0 >>> 8 & 0xFF00;
+		return var3 | arg0 >>> 24 & 0xFF;
+	}
+
+	public static float GLU_SWAP_4_BYTES(float arg0) {
+		int var1 = Float.floatToRawIntBits(arg0);
+		return Float.intBitsToFloat(var1);
+	}
+
+	public static int checkMipmapArgs(int arg0, int arg1, int arg2) {
+		if (!legalFormat(arg1) || !legalType(arg2)) {
+			return 100900;
+		} else if (arg1 == 6401) {
+			return 100900;
+		} else if (isLegalFormatForPackedPixelType(arg1, arg2)) {
+			return 0;
+		} else {
+			return 100904;
+		}
+	}
+
+	public static boolean legalFormat(int arg0) {
+		switch(arg0) {
+			case 6400:
+			case 6401:
+			case 6402:
+			case 6403:
+			case 6404:
+			case 6405:
+			case 6406:
+			case 6407:
+			case 6408:
+			case 6409:
+			case 6410:
+			case 32992:
+			case 32993:
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	public static boolean legalType(int arg0) {
+		switch(arg0) {
+			case 5120:
+			case 5121:
+			case 5122:
+			case 5123:
+			case 5124:
+			case 5125:
+			case 5126:
+			case 6656:
+			case 32818:
+			case 32819:
+			case 32820:
+			case 32821:
+			case 32822:
+			case 33634:
+			case 33635:
+			case 33636:
+			case 33637:
+			case 33638:
+			case 33639:
+			case 33640:
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	public static boolean isTypePackedPixel(int arg0) {
+		assert legalType(arg0);
+		return arg0 == 32818 || arg0 == 33634 || arg0 == 33635 || arg0 == 33636 || arg0 == 32819 || arg0 == 33637 || arg0 == 32820 || arg0 == 33638 || arg0 == 32821 || arg0 == 33639 || arg0 == 32822 || arg0 == 33640;
+	}
+
+	public static boolean isLegalFormatForPackedPixelType(int arg0, int arg1) {
+		if (isTypePackedPixel(arg1)) {
+			return true;
+		} else if ((arg1 == 32818 || arg1 == 33634 || arg1 == 33635 || arg1 == 33636) & arg0 != 6407) {
+			return false;
+		} else {
+			return arg1 != 32819 && arg1 != 33637 && arg1 != 32820 && arg1 != 33638 && arg1 != 32821 && arg1 != 33639 && arg1 != 32822 && arg1 != 33640 || arg0 == 6408 || arg0 == 32993;
+		}
+	}
+
+	public static void closestFit(GL arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int[] arg7, int[] arg8) {
+		if (Double.parseDouble(arg0.glGetString(GL.GL_VERSION).trim().substring(0, 3)) >= 1.1D) {
+			int var9 = nearestPower(arg2);
+			int var10 = nearestPower(arg3);
+			int[] var11 = new int[1];
+			boolean var12 = false;
+			try {
+				do {
+					int var13 = arg2 > 1 ? var9 >> 1 : var9;
+					int var14 = arg3 > 1 ? var10 >> 1 : var10;
+					assert var13 > 0;
+					assert var14 > 0;
+					int var15;
+					if (arg1 == 3553 || arg1 == 32868) {
+						var15 = 32868;
+						arg0.glTexImage2D(var15, 1, arg4, var13, var14, 0, arg5, arg6, null);
+					} else if (arg1 == 34069 || arg1 == 34070 || arg1 == 34071 || arg1 == 34072 || arg1 == 34073 || arg1 == 34074) {
+						var15 = 34075;
+						arg0.glTexImage2D(var15, 1, arg4, var13, var14, 0, arg5, arg6, null);
+					} else {
+						assert arg1 == 3552 || arg1 == 32867;
+						var15 = 32867;
+						arg0.glTexImage1D(var15, 1, arg4, var13, 0, arg5, arg6, null);
+					}
+					arg0.glGetTexLevelParameteriv(var15, GL.GL_LINES, GL.GL_TEXTURE_WIDTH, var11, 0);
+					if (var11[0] == 0) {
+						if (var9 == 1 && var10 == 1) {
+							var12 = true;
+							break;
+						}
+						var9 = var13;
+						var10 = var14;
+					}
+				} while (var11[0] == 0);
+			} catch (GLException var16) {
+				var12 = true;
+			}
+			if (!var12) {
+				arg7[0] = var9;
+				arg8[0] = var10;
+				return;
+			}
+		}
+		int[] var17 = new int[1];
+		arg0.glGetIntegerv(GL.GL_MAX_TEXTURE_SIZE, var17, 0);
+		arg7[0] = nearestPower(arg2);
+		if (arg7[0] > var17[0]) {
+			arg7[0] = var17[0];
+		}
+		arg8[0] = nearestPower(arg3);
+		if (arg8[0] > var17[0]) {
+			arg8[0] = var17[0];
+		}
+	}
+
+	public static int elements_per_group(int arg0, int arg1) {
+		if (arg1 == 32818 || arg1 == 33634 || arg1 == 33635 || arg1 == 33636 || arg1 == 32819 || arg1 == 33637 || arg1 == 32820 || arg1 == 33638 || arg1 == 32821 || arg1 == 33639 || arg1 == 32822 || arg1 == 33640) {
+			return 1;
+		}
+		switch(arg0) {
+			case 6407:
+			case 32992:
+				return 3;
+			case 6408:
+			case 32993:
+				return 4;
+			case 6410:
+				return 2;
+			default:
+				return 1;
+		}
+	}
+
+	public static int bytes_per_element(int arg0) {
+		switch(arg0) {
+			case 5120:
+			case 5121:
+			case 6656:
+			case 32818:
+			case 33634:
+				return 1;
+			case 5122:
+			case 5123:
+			case 32819:
+			case 32820:
+			case 33635:
+			case 33636:
+			case 33637:
+			case 33638:
+				return 2;
+			case 5124:
+			case 5125:
+			case 5126:
+			case 32821:
+			case 32822:
+			case 33639:
+			case 33640:
+				return 4;
+			default:
+				return 4;
+		}
+	}
+
+	public static boolean is_index(int arg0) {
+		return arg0 == 6400 || arg0 == 6401;
+	}
+
+	public static int image_size(int arg0, int arg1, int arg2, int arg3) {
+		assert arg0 > 0;
+		assert arg1 > 0;
+		int var5 = elements_per_group(arg2, arg3);
+		int var4;
+		if (arg3 == 6656) {
+			var4 = (arg0 + 7) / 8;
+		} else {
+			var4 = bytes_per_element(arg3) * arg0;
+		}
+		return var4 * arg1 * var5;
+	}
+
+	public static void retrieveStoreModes(GL arg0, PixelStorageModes arg1) {
+		int[] var2 = new int[1];
+		arg0.glGetIntegerv(GL.GL_UNPACK_ALIGNMENT, var2, 0);
+		arg1.setUnpackAlignment(var2[0]);
+		arg0.glGetIntegerv(GL.GL_UNPACK_ROW_LENGTH, var2, 0);
+		arg1.setUnpackRowLength(var2[0]);
+		arg0.glGetIntegerv(GL.GL_UNPACK_SKIP_ROWS, var2, 0);
+		arg1.setUnpackSkipRows(var2[0]);
+		arg0.glGetIntegerv(GL.GL_UNPACK_SKIP_PIXELS, var2, 0);
+		arg1.setUnpackSkipPixels(var2[0]);
+		arg0.glGetIntegerv(GL.GL_UNPACK_LSB_FIRST, var2, 0);
+		arg1.setUnpackLsbFirst(var2[0] == 1);
+		arg0.glGetIntegerv(GL.GL_UNPACK_SWAP_BYTES, var2, 0);
+		arg1.setUnpackSwapBytes(var2[0] == 1);
+		arg0.glGetIntegerv(GL.GL_PACK_ALIGNMENT, var2, 0);
+		arg1.setPackAlignment(var2[0]);
+		arg0.glGetIntegerv(GL.GL_PACK_ROW_LENGTH, var2, 0);
+		arg1.setPackRowLength(var2[0]);
+		arg0.glGetIntegerv(GL.GL_PACK_SKIP_ROWS, var2, 0);
+		arg1.setPackSkipRows(var2[0]);
+		arg0.glGetIntegerv(GL.GL_PACK_SKIP_PIXELS, var2, 0);
+		arg1.setPackSkipPixels(var2[0]);
+		arg0.glGetIntegerv(GL.GL_PACK_LSB_FIRST, var2, 0);
+		arg1.setPackLsbFirst(var2[0] == 1);
+		arg0.glGetIntegerv(GL.GL_PACK_SWAP_BYTES, var2, 0);
+		arg1.setPackSwapBytes(var2[0] == 1);
+	}
+
+	public static int gluBuild2DMipmaps(GL arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, Object arg7) {
+		int var8 = 0;
+		int[] var9 = new int[1];
+		int[] var10 = new int[1];
+		int var13 = checkMipmapArgs(arg2, arg5, arg6);
+		if (var13 != 0) {
+			return var13;
+		} else if (arg3 >= 1 && arg4 >= 1) {
+			closestFit(arg0, arg1, arg3, arg4, arg2, arg5, arg6, var9, var10);
+			int var12 = computeLog(var9[0]);
+			int var11 = computeLog(var10[0]);
+			if (var11 > var12) {
+				var12 = var11;
+			}
+			ByteBuffer var14 = null;
+			if (arg7 instanceof ByteBuffer) {
+				var14 = (ByteBuffer) arg7;
+				var8 = var14.position();
+			} else if (arg7 instanceof byte[]) {
+				byte[] var15 = (byte[]) arg7;
+				var14 = ByteBuffer.allocateDirect(var15.length);
+				var14.put(var15);
+			} else if (arg7 instanceof short[]) {
+				short[] var20 = (short[]) arg7;
+				var14 = ByteBuffer.allocateDirect(var20.length * 2);
+				ShortBuffer var16 = var14.asShortBuffer();
+				var16.put(var20);
+			} else if (arg7 instanceof int[]) {
+				int[] var21 = (int[]) arg7;
+				var14 = ByteBuffer.allocateDirect(var21.length * 4);
+				IntBuffer var24 = var14.asIntBuffer();
+				var24.put(var21);
+			} else if (arg7 instanceof float[]) {
+				float[] var22 = (float[]) arg7;
+				var14 = ByteBuffer.allocateDirect(var22.length * 4);
+				FloatBuffer var25 = var14.asFloatBuffer();
+				var25.put(var22);
+			}
+			int var23;
+			try {
+				var23 = BuildMipmap.gluBuild2DMipmapLevelsCore(arg0, arg1, arg2, arg3, arg4, var9[0], var10[0], arg5, arg6, 0, 0, var12, var14);
+			} finally {
+				var14.position(var8);
+			}
+			return var23;
+		} else {
+			return 100901;
+		}
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/PixelStorageModes.java

@@ -0,0 +1,100 @@
+package com.sun.opengl.impl.mipmap;
+
+public class PixelStorageModes {
+
+	private int packAlignment;
+
+	private int packRowLength;
+
+	private int packSkipRows;
+
+	private int packSkipPixels;
+
+	private boolean packLsbFirst;
+
+	private boolean packSwapBytes;
+
+	private int unpackAlignment;
+
+	private int unpackRowLength;
+
+	private int unpackSkipRows;
+
+	private int unpackSkipPixels;
+
+	private boolean unpackLsbFirst;
+
+	private boolean unpackSwapBytes;
+
+	public void setPackAlignment(int arg0) {
+		this.packAlignment = arg0;
+	}
+
+	public void setPackRowLength(int arg0) {
+		this.packRowLength = arg0;
+	}
+
+	public void setPackSkipRows(int arg0) {
+		this.packSkipRows = arg0;
+	}
+
+	public void setPackSkipPixels(int arg0) {
+		this.packSkipPixels = arg0;
+	}
+
+	public void setPackLsbFirst(boolean arg0) {
+		this.packLsbFirst = arg0;
+	}
+
+	public void setPackSwapBytes(boolean arg0) {
+		this.packSwapBytes = arg0;
+	}
+
+	public int getUnpackAlignment() {
+		return this.unpackAlignment;
+	}
+
+	public void setUnpackAlignment(int arg0) {
+		this.unpackAlignment = arg0;
+	}
+
+	public int getUnpackRowLength() {
+		return this.unpackRowLength;
+	}
+
+	public void setUnpackRowLength(int arg0) {
+		this.unpackRowLength = arg0;
+	}
+
+	public int getUnpackSkipRows() {
+		return this.unpackSkipRows;
+	}
+
+	public void setUnpackSkipRows(int arg0) {
+		this.unpackSkipRows = arg0;
+	}
+
+	public int getUnpackSkipPixels() {
+		return this.unpackSkipPixels;
+	}
+
+	public void setUnpackSkipPixels(int arg0) {
+		this.unpackSkipPixels = arg0;
+	}
+
+	public boolean getUnpackLsbFirst() {
+		return this.unpackLsbFirst;
+	}
+
+	public void setUnpackLsbFirst(boolean arg0) {
+		this.unpackLsbFirst = arg0;
+	}
+
+	public boolean getUnpackSwapBytes() {
+		return this.unpackSwapBytes;
+	}
+
+	public void setUnpackSwapBytes(boolean arg0) {
+		this.unpackSwapBytes = arg0;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/mipmap/Type_Widget.java

@@ -0,0 +1,53 @@
+package com.sun.opengl.impl.mipmap;
+
+import java.nio.ByteBuffer;
+
+public class Type_Widget {
+
+	ByteBuffer buffer = ByteBuffer.allocate(4);
+
+	public void setUB0(byte arg0) {
+		this.buffer.position(0);
+		this.buffer.put(arg0);
+	}
+
+	public void setUB1(byte arg0) {
+		this.buffer.position(1);
+		this.buffer.put(arg0);
+	}
+
+	public void setUB2(byte arg0) {
+		this.buffer.position(2);
+		this.buffer.put(arg0);
+	}
+
+	public void setUB3(byte arg0) {
+		this.buffer.position(3);
+		this.buffer.put(arg0);
+	}
+
+	public short getUS0() {
+		this.buffer.position(0);
+		return this.buffer.getShort();
+	}
+
+	public int getUI() {
+		this.buffer.position(0);
+		return this.buffer.getInt();
+	}
+
+	public short getS0() {
+		this.buffer.position(0);
+		return this.buffer.getShort();
+	}
+
+	public int getI() {
+		this.buffer.position(0);
+		return this.buffer.getInt();
+	}
+
+	public float getF() {
+		this.buffer.position(0);
+		return this.buffer.getFloat();
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/JAWT_Win32DrawingSurfaceInfo.java

@@ -0,0 +1,30 @@
+package com.sun.opengl.impl.windows;
+
+import com.sun.gluegen.runtime.BufferFactory;
+import com.sun.gluegen.runtime.CPU;
+import com.sun.gluegen.runtime.StructAccessor;
+import com.sun.opengl.impl.JAWT_PlatformInfo;
+import java.nio.ByteBuffer;
+
+public abstract class JAWT_Win32DrawingSurfaceInfo implements JAWT_PlatformInfo {
+
+	StructAccessor accessor;
+
+	public static int size() {
+		return CPU.is32Bit() ? JAWT_Win32DrawingSurfaceInfo32.size() : JAWT_Win32DrawingSurfaceInfo64.size();
+	}
+
+	public static JAWT_Win32DrawingSurfaceInfo create() {
+		return create(BufferFactory.newDirectByteBuffer(size()));
+	}
+
+	public static JAWT_Win32DrawingSurfaceInfo create(ByteBuffer arg0) {
+		return CPU.is32Bit() ? new JAWT_Win32DrawingSurfaceInfo32(arg0) : new JAWT_Win32DrawingSurfaceInfo64(arg0);
+	}
+
+	JAWT_Win32DrawingSurfaceInfo(ByteBuffer arg0) {
+		this.accessor = new StructAccessor(arg0);
+	}
+
+	public abstract long hdc();
+}

gl/src/main/java/com/sun/opengl/impl/windows/JAWT_Win32DrawingSurfaceInfo32.java

@@ -0,0 +1,19 @@
+package com.sun.opengl.impl.windows;
+
+import com.sun.opengl.impl.JAWT_PlatformInfo;
+import java.nio.ByteBuffer;
+
+class JAWT_Win32DrawingSurfaceInfo32 extends JAWT_Win32DrawingSurfaceInfo implements JAWT_PlatformInfo {
+
+	public static int size() {
+		return 12;
+	}
+
+	JAWT_Win32DrawingSurfaceInfo32(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public long hdc() {
+		return (long) this.accessor.getIntAt(1);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/JAWT_Win32DrawingSurfaceInfo64.java

@@ -0,0 +1,19 @@
+package com.sun.opengl.impl.windows;
+
+import com.sun.opengl.impl.JAWT_PlatformInfo;
+import java.nio.ByteBuffer;
+
+class JAWT_Win32DrawingSurfaceInfo64 extends JAWT_Win32DrawingSurfaceInfo implements JAWT_PlatformInfo {
+
+	public static int size() {
+		return 24;
+	}
+
+	JAWT_Win32DrawingSurfaceInfo64(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public long hdc() {
+		return this.accessor.getLongAt(1);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/PIXELFORMATDESCRIPTOR.java

@@ -0,0 +1,87 @@
+package com.sun.opengl.impl.windows;
+
+import com.sun.gluegen.runtime.BufferFactory;
+import com.sun.gluegen.runtime.CPU;
+import com.sun.gluegen.runtime.StructAccessor;
+import java.nio.ByteBuffer;
+
+public abstract class PIXELFORMATDESCRIPTOR {
+
+	StructAccessor accessor;
+
+	public static int size() {
+		return CPU.is32Bit() ? PIXELFORMATDESCRIPTOR32.size() : PIXELFORMATDESCRIPTOR64.size();
+	}
+
+	public static PIXELFORMATDESCRIPTOR create() {
+		return create(BufferFactory.newDirectByteBuffer(size()));
+	}
+
+	public static PIXELFORMATDESCRIPTOR create(ByteBuffer arg0) {
+		return CPU.is32Bit() ? new PIXELFORMATDESCRIPTOR32(arg0) : new PIXELFORMATDESCRIPTOR64(arg0);
+	}
+
+	PIXELFORMATDESCRIPTOR(ByteBuffer arg0) {
+		this.accessor = new StructAccessor(arg0);
+	}
+
+	public ByteBuffer getBuffer() {
+		return this.accessor.getBuffer();
+	}
+
+	public abstract PIXELFORMATDESCRIPTOR nSize(short arg0);
+
+	public abstract PIXELFORMATDESCRIPTOR nVersion(short arg0);
+
+	public abstract PIXELFORMATDESCRIPTOR dwFlags(int arg0);
+
+	public abstract int dwFlags();
+
+	public abstract PIXELFORMATDESCRIPTOR iPixelType(byte arg0);
+
+	public abstract PIXELFORMATDESCRIPTOR cColorBits(byte arg0);
+
+	public abstract PIXELFORMATDESCRIPTOR cRedBits(byte arg0);
+
+	public abstract byte cRedBits();
+
+	public abstract PIXELFORMATDESCRIPTOR cGreenBits(byte arg0);
+
+	public abstract byte cGreenBits();
+
+	public abstract PIXELFORMATDESCRIPTOR cBlueBits(byte arg0);
+
+	public abstract byte cBlueBits();
+
+	public abstract PIXELFORMATDESCRIPTOR cAlphaBits(byte arg0);
+
+	public abstract byte cAlphaBits();
+
+	public abstract PIXELFORMATDESCRIPTOR cAccumBits(byte arg0);
+
+	public abstract PIXELFORMATDESCRIPTOR cAccumRedBits(byte arg0);
+
+	public abstract byte cAccumRedBits();
+
+	public abstract PIXELFORMATDESCRIPTOR cAccumGreenBits(byte arg0);
+
+	public abstract byte cAccumGreenBits();
+
+	public abstract PIXELFORMATDESCRIPTOR cAccumBlueBits(byte arg0);
+
+	public abstract byte cAccumBlueBits();
+
+	public abstract PIXELFORMATDESCRIPTOR cAccumAlphaBits(byte arg0);
+
+	public abstract byte cAccumAlphaBits();
+
+	public abstract PIXELFORMATDESCRIPTOR cDepthBits(byte arg0);
+
+	public abstract byte cDepthBits();
+
+	public abstract PIXELFORMATDESCRIPTOR cStencilBits(byte arg0);
+
+	public abstract byte cStencilBits();
+
+	public abstract PIXELFORMATDESCRIPTOR iLayerType(byte arg0);
+}

gl/src/main/java/com/sun/opengl/impl/windows/PIXELFORMATDESCRIPTOR32.java

@@ -0,0 +1,143 @@
+package com.sun.opengl.impl.windows;
+
+import java.nio.ByteBuffer;
+
+class PIXELFORMATDESCRIPTOR32 extends PIXELFORMATDESCRIPTOR {
+
+	public static int size() {
+		return 40;
+	}
+
+	PIXELFORMATDESCRIPTOR32(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public PIXELFORMATDESCRIPTOR nSize(short arg0) {
+		this.accessor.setShortAt(0, arg0);
+		return this;
+	}
+
+	public PIXELFORMATDESCRIPTOR nVersion(short arg0) {
+		this.accessor.setShortAt(1, arg0);
+		return this;
+	}
+
+	public PIXELFORMATDESCRIPTOR dwFlags(int arg0) {
+		this.accessor.setIntAt(1, arg0);
+		return this;
+	}
+
+	public int dwFlags() {
+		return this.accessor.getIntAt(1);
+	}
+
+	public PIXELFORMATDESCRIPTOR iPixelType(byte arg0) {
+		this.accessor.setByteAt(8, arg0);
+		return this;
+	}
+
+	public PIXELFORMATDESCRIPTOR cColorBits(byte arg0) {
+		this.accessor.setByteAt(9, arg0);
+		return this;
+	}
+
+	public PIXELFORMATDESCRIPTOR cRedBits(byte arg0) {
+		this.accessor.setByteAt(10, arg0);
+		return this;
+	}
+
+	public byte cRedBits() {
+		return this.accessor.getByteAt(10);
+	}
+
+	public PIXELFORMATDESCRIPTOR cGreenBits(byte arg0) {
+		this.accessor.setByteAt(12, arg0);
+		return this;
+	}
+
+	public byte cGreenBits() {
+		return this.accessor.getByteAt(12);
+	}
+
+	public PIXELFORMATDESCRIPTOR cBlueBits(byte arg0) {
+		this.accessor.setByteAt(14, arg0);
+		return this;
+	}
+
+	public byte cBlueBits() {
+		return this.accessor.getByteAt(14);
+	}
+
+	public PIXELFORMATDESCRIPTOR cAlphaBits(byte arg0) {
+		this.accessor.setByteAt(16, arg0);
+		return this;
+	}
+
+	public byte cAlphaBits() {
+		return this.accessor.getByteAt(16);
+	}
+
+	public PIXELFORMATDESCRIPTOR cAccumBits(byte arg0) {
+		this.accessor.setByteAt(18, arg0);
+		return this;
+	}
+
+	public PIXELFORMATDESCRIPTOR cAccumRedBits(byte arg0) {
+		this.accessor.setByteAt(19, arg0);
+		return this;
+	}
+
+	public byte cAccumRedBits() {
+		return this.accessor.getByteAt(19);
+	}
+
+	public PIXELFORMATDESCRIPTOR cAccumGreenBits(byte arg0) {
+		this.accessor.setByteAt(20, arg0);
+		return this;
+	}
+
+	public byte cAccumGreenBits() {
+		return this.accessor.getByteAt(20);
+	}
+
+	public PIXELFORMATDESCRIPTOR cAccumBlueBits(byte arg0) {
+		this.accessor.setByteAt(21, arg0);
+		return this;
+	}
+
+	public byte cAccumBlueBits() {
+		return this.accessor.getByteAt(21);
+	}
+
+	public PIXELFORMATDESCRIPTOR cAccumAlphaBits(byte arg0) {
+		this.accessor.setByteAt(22, arg0);
+		return this;
+	}
+
+	public byte cAccumAlphaBits() {
+		return this.accessor.getByteAt(22);
+	}
+
+	public PIXELFORMATDESCRIPTOR cDepthBits(byte arg0) {
+		this.accessor.setByteAt(23, arg0);
+		return this;
+	}
+
+	public byte cDepthBits() {
+		return this.accessor.getByteAt(23);
+	}
+
+	public PIXELFORMATDESCRIPTOR cStencilBits(byte arg0) {
+		this.accessor.setByteAt(24, arg0);
+		return this;
+	}
+
+	public byte cStencilBits() {
+		return this.accessor.getByteAt(24);
+	}
+
+	public PIXELFORMATDESCRIPTOR iLayerType(byte arg0) {
+		this.accessor.setByteAt(26, arg0);
+		return this;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/PIXELFORMATDESCRIPTOR64.java

@@ -0,0 +1,143 @@
+package com.sun.opengl.impl.windows;
+
+import java.nio.ByteBuffer;
+
+class PIXELFORMATDESCRIPTOR64 extends PIXELFORMATDESCRIPTOR {
+
+	public static int size() {
+		return 40;
+	}
+
+	PIXELFORMATDESCRIPTOR64(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public PIXELFORMATDESCRIPTOR nSize(short arg0) {
+		this.accessor.setShortAt(0, arg0);
+		return this;
+	}
+
+	public PIXELFORMATDESCRIPTOR nVersion(short arg0) {
+		this.accessor.setShortAt(1, arg0);
+		return this;
+	}
+
+	public PIXELFORMATDESCRIPTOR dwFlags(int arg0) {
+		this.accessor.setIntAt(1, arg0);
+		return this;
+	}
+
+	public int dwFlags() {
+		return this.accessor.getIntAt(1);
+	}
+
+	public PIXELFORMATDESCRIPTOR iPixelType(byte arg0) {
+		this.accessor.setByteAt(8, arg0);
+		return this;
+	}
+
+	public PIXELFORMATDESCRIPTOR cColorBits(byte arg0) {
+		this.accessor.setByteAt(9, arg0);
+		return this;
+	}
+
+	public PIXELFORMATDESCRIPTOR cRedBits(byte arg0) {
+		this.accessor.setByteAt(10, arg0);
+		return this;
+	}
+
+	public byte cRedBits() {
+		return this.accessor.getByteAt(10);
+	}
+
+	public PIXELFORMATDESCRIPTOR cGreenBits(byte arg0) {
+		this.accessor.setByteAt(12, arg0);
+		return this;
+	}
+
+	public byte cGreenBits() {
+		return this.accessor.getByteAt(12);
+	}
+
+	public PIXELFORMATDESCRIPTOR cBlueBits(byte arg0) {
+		this.accessor.setByteAt(14, arg0);
+		return this;
+	}
+
+	public byte cBlueBits() {
+		return this.accessor.getByteAt(14);
+	}
+
+	public PIXELFORMATDESCRIPTOR cAlphaBits(byte arg0) {
+		this.accessor.setByteAt(16, arg0);
+		return this;
+	}
+
+	public byte cAlphaBits() {
+		return this.accessor.getByteAt(16);
+	}
+
+	public PIXELFORMATDESCRIPTOR cAccumBits(byte arg0) {
+		this.accessor.setByteAt(18, arg0);
+		return this;
+	}
+
+	public PIXELFORMATDESCRIPTOR cAccumRedBits(byte arg0) {
+		this.accessor.setByteAt(19, arg0);
+		return this;
+	}
+
+	public byte cAccumRedBits() {
+		return this.accessor.getByteAt(19);
+	}
+
+	public PIXELFORMATDESCRIPTOR cAccumGreenBits(byte arg0) {
+		this.accessor.setByteAt(20, arg0);
+		return this;
+	}
+
+	public byte cAccumGreenBits() {
+		return this.accessor.getByteAt(20);
+	}
+
+	public PIXELFORMATDESCRIPTOR cAccumBlueBits(byte arg0) {
+		this.accessor.setByteAt(21, arg0);
+		return this;
+	}
+
+	public byte cAccumBlueBits() {
+		return this.accessor.getByteAt(21);
+	}
+
+	public PIXELFORMATDESCRIPTOR cAccumAlphaBits(byte arg0) {
+		this.accessor.setByteAt(22, arg0);
+		return this;
+	}
+
+	public byte cAccumAlphaBits() {
+		return this.accessor.getByteAt(22);
+	}
+
+	public PIXELFORMATDESCRIPTOR cDepthBits(byte arg0) {
+		this.accessor.setByteAt(23, arg0);
+		return this;
+	}
+
+	public byte cDepthBits() {
+		return this.accessor.getByteAt(23);
+	}
+
+	public PIXELFORMATDESCRIPTOR cStencilBits(byte arg0) {
+		this.accessor.setByteAt(24, arg0);
+		return this;
+	}
+
+	public byte cStencilBits() {
+		return this.accessor.getByteAt(24);
+	}
+
+	public PIXELFORMATDESCRIPTOR iLayerType(byte arg0) {
+		this.accessor.setByteAt(26, arg0);
+		return this;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/WGL.java

@@ -0,0 +1,48 @@
+package com.sun.opengl.impl.windows;
+
+import java.nio.ByteBuffer;
+
+public class WGL {
+
+	public static int ChoosePixelFormat(long arg0, PIXELFORMATDESCRIPTOR arg1) {
+		return ChoosePixelFormat0(arg0, arg1 == null ? null : arg1.getBuffer());
+	}
+
+	private static native int ChoosePixelFormat0(long arg0, ByteBuffer arg1);
+
+	public static native long CreateDummyWindow(int arg0, int arg1, int arg2, int arg3);
+
+	public static int DescribePixelFormat(long arg0, int arg1, int arg2, PIXELFORMATDESCRIPTOR arg3) {
+		return DescribePixelFormat0(arg0, arg1, arg2, arg3 == null ? null : arg3.getBuffer());
+	}
+
+	private static native int DescribePixelFormat0(long arg0, int arg1, int arg2, ByteBuffer arg3);
+
+	public static native boolean DestroyWindow(long arg0);
+
+	public static native long GetDC(long arg0);
+
+	public static native int GetLastError();
+
+	public static native int GetPixelFormat(long arg0);
+
+	public static native int ReleaseDC(long arg0, long arg1);
+
+	public static boolean SetPixelFormat(long arg0, int arg1, PIXELFORMATDESCRIPTOR arg2) {
+		return SetPixelFormat0(arg0, arg1, arg2 == null ? null : arg2.getBuffer());
+	}
+
+	private static native boolean SetPixelFormat0(long arg0, int arg1, ByteBuffer arg2);
+
+	public static native boolean ShowWindow(long arg0, int arg1);
+
+	public static native boolean SwapBuffers(long arg0);
+
+	public static native long wglCreateContext(long arg0);
+
+	public static native boolean wglDeleteContext(long arg0);
+
+	public static native long wglGetProcAddress(String arg0);
+
+	public static native boolean wglMakeCurrent(long arg0, long arg1);
+}

gl/src/main/java/com/sun/opengl/impl/windows/WGLExt.java

@@ -0,0 +1,14 @@
+package com.sun.opengl.impl.windows;
+
+public interface WGLExt {
+
+	boolean wglChoosePixelFormatARB(long arg0, int[] arg1, int arg2, float[] arg3, int arg4, int arg5, int[] arg6, int arg7, int[] arg8, int arg9);
+
+	String wglGetExtensionsStringEXT();
+
+	boolean wglGetPixelFormatAttribivARB(long arg0, int arg1, int arg2, int arg3, int[] arg4, int arg5, int[] arg6, int arg7);
+
+	boolean wglSwapIntervalEXT(int arg0);
+
+	boolean isExtensionAvailable(String arg0);
+}

gl/src/main/java/com/sun/opengl/impl/windows/WGLExtImpl.java

@@ -0,0 +1,72 @@
+package com.sun.opengl.impl.windows;
+
+import javax.media.opengl.GLException;
+
+public class WGLExtImpl implements WGLExt {
+
+	private WindowsGLContext _context;
+
+	private native boolean dispatch_wglChoosePixelFormatARB1(long arg0, Object arg1, int arg2, Object arg3, int arg4, int arg5, Object arg6, int arg7, Object arg8, int arg9, long arg10);
+
+	public boolean wglChoosePixelFormatARB(long arg0, int[] arg1, int arg2, float[] arg3, int arg4, int arg5, int[] arg6, int arg7, int[] arg8, int arg9) {
+		if (arg1 != null && arg1.length <= arg2) {
+			throw new GLException("array offset argument \"piAttribIList_offset\" (" + arg2 + ") equals or exceeds array length (" + arg1.length + ")");
+		} else if (arg3 != null && arg3.length <= arg4) {
+			throw new GLException("array offset argument \"pfAttribFList_offset\" (" + arg4 + ") equals or exceeds array length (" + arg3.length + ")");
+		} else if (arg6 != null && arg6.length <= arg7) {
+			throw new GLException("array offset argument \"piFormats_offset\" (" + arg7 + ") equals or exceeds array length (" + arg6.length + ")");
+		} else if (arg8 == null || arg8.length > arg9) {
+			long var12 = this._context.getWGLExtProcAddressTable()._addressof_wglChoosePixelFormatARB;
+			if (var12 == 0L) {
+				throw new GLException("Method \"wglChoosePixelFormatARB\" not available");
+			}
+			return this.dispatch_wglChoosePixelFormatARB1(arg0, arg1, arg2 * 4, arg3, arg4 * 4, arg5, arg6, arg7 * 4, arg8, arg9 * 4, var12);
+		} else {
+			throw new GLException("array offset argument \"nNumFormats_offset\" (" + arg9 + ") equals or exceeds array length (" + arg8.length + ")");
+		}
+	}
+
+	public String wglGetExtensionsStringEXT() {
+		long var1 = this._context.getWGLExtProcAddressTable()._addressof_wglGetExtensionsStringEXT;
+		if (var1 == 0L) {
+			throw new GLException("Method \"wglGetExtensionsStringEXT\" not available");
+		}
+		return this.dispatch_wglGetExtensionsStringEXT0(var1);
+	}
+
+	public native String dispatch_wglGetExtensionsStringEXT0(long arg0);
+
+	private native boolean dispatch_wglGetPixelFormatAttribivARB1(long arg0, int arg1, int arg2, int arg3, Object arg4, int arg5, Object arg6, int arg7, long arg8);
+
+	public boolean wglGetPixelFormatAttribivARB(long arg0, int arg1, int arg2, int arg3, int[] arg4, int arg5, int[] arg6, int arg7) {
+		if (arg4 != null && arg4.length <= arg5) {
+			throw new GLException("array offset argument \"piAttributes_offset\" (" + arg5 + ") equals or exceeds array length (" + arg4.length + ")");
+		} else if (arg6 == null || arg6.length > arg7) {
+			long var10 = this._context.getWGLExtProcAddressTable()._addressof_wglGetPixelFormatAttribivARB;
+			if (var10 == 0L) {
+				throw new GLException("Method \"wglGetPixelFormatAttribivARB\" not available");
+			}
+			return this.dispatch_wglGetPixelFormatAttribivARB1(arg0, arg1, arg2, arg3, arg4, arg5 * 4, arg6, arg7 * 4, var10);
+		} else {
+			throw new GLException("array offset argument \"piValues_offset\" (" + arg7 + ") equals or exceeds array length (" + arg6.length + ")");
+		}
+	}
+
+	public boolean wglSwapIntervalEXT(int arg0) {
+		long var2 = this._context.getWGLExtProcAddressTable()._addressof_wglSwapIntervalEXT;
+		if (var2 == 0L) {
+			throw new GLException("Method \"wglSwapIntervalEXT\" not available");
+		}
+		return this.dispatch_wglSwapIntervalEXT0(arg0, var2);
+	}
+
+	public native boolean dispatch_wglSwapIntervalEXT0(int arg0, long arg1);
+
+	public WGLExtImpl(WindowsGLContext arg0) {
+		this._context = arg0;
+	}
+
+	public boolean isExtensionAvailable(String arg0) {
+		return this._context.isExtensionAvailable(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/WGLExtProcAddressTable.java

@@ -0,0 +1,108 @@
+package com.sun.opengl.impl.windows;
+
+public class WGLExtProcAddressTable {
+
+	public long _addressof_wglAllocateMemoryNV;
+
+	public long _addressof_wglBeginFrameTrackingI3D;
+
+	public long _addressof_wglBindDisplayColorTableEXT;
+
+	public long _addressof_wglBindSwapBarrierNV;
+
+	public long _addressof_wglBindTexImageARB;
+
+	public long _addressof_wglChoosePixelFormatARB;
+
+	public long _addressof_wglChoosePixelFormatEXT;
+
+	public long _addressof_wglCreateAffinityDCNV;
+
+	public long _addressof_wglCreateDisplayColorTableEXT;
+
+	public long _addressof_wglCreatePbufferARB;
+
+	public long _addressof_wglCreatePbufferEXT;
+
+	public long _addressof_wglDeleteDCNV;
+
+	public long _addressof_wglDestroyDisplayColorTableEXT;
+
+	public long _addressof_wglDestroyPbufferARB;
+
+	public long _addressof_wglDestroyPbufferEXT;
+
+	public long _addressof_wglDisableFrameLockI3D;
+
+	public long _addressof_wglEnableFrameLockI3D;
+
+	public long _addressof_wglEndFrameTrackingI3D;
+
+	public long _addressof_wglEnumGpuDevicesNV;
+
+	public long _addressof_wglEnumGpusFromAffinityDCNV;
+
+	public long _addressof_wglEnumGpusNV;
+
+	public long _addressof_wglFreeMemoryNV;
+
+	public long _addressof_wglGetCurrentReadDCARB;
+
+	public long _addressof_wglGetCurrentReadDCEXT;
+
+	public long _addressof_wglGetExtensionsStringARB;
+
+	public long _addressof_wglGetExtensionsStringEXT;
+
+	public long _addressof_wglGetFrameUsageI3D;
+
+	public long _addressof_wglGetPbufferDCARB;
+
+	public long _addressof_wglGetPbufferDCEXT;
+
+	public long _addressof_wglGetPixelFormatAttribfvARB;
+
+	public long _addressof_wglGetPixelFormatAttribfvEXT;
+
+	public long _addressof_wglGetPixelFormatAttribivARB;
+
+	public long _addressof_wglGetPixelFormatAttribivEXT;
+
+	public long _addressof_wglGetSwapIntervalEXT;
+
+	public long _addressof_wglIsEnabledFrameLockI3D;
+
+	public long _addressof_wglJoinSwapGroupNV;
+
+	public long _addressof_wglLoadDisplayColorTableEXT;
+
+	public long _addressof_wglMakeContextCurrentARB;
+
+	public long _addressof_wglMakeContextCurrentEXT;
+
+	public long _addressof_wglQueryFrameCountNV;
+
+	public long _addressof_wglQueryFrameLockMasterI3D;
+
+	public long _addressof_wglQueryFrameTrackingI3D;
+
+	public long _addressof_wglQueryMaxSwapGroupsNV;
+
+	public long _addressof_wglQueryPbufferARB;
+
+	public long _addressof_wglQueryPbufferEXT;
+
+	public long _addressof_wglQuerySwapGroupNV;
+
+	public long _addressof_wglReleasePbufferDCARB;
+
+	public long _addressof_wglReleasePbufferDCEXT;
+
+	public long _addressof_wglReleaseTexImageARB;
+
+	public long _addressof_wglResetFrameCountNV;
+
+	public long _addressof_wglSetPbufferAttribARB;
+
+	public long _addressof_wglSwapIntervalEXT;
+}

gl/src/main/java/com/sun/opengl/impl/windows/WindowsDummyGLDrawable.java

@@ -0,0 +1,41 @@
+package com.sun.opengl.impl.windows;
+
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLContext;
+
+public class WindowsDummyGLDrawable extends WindowsGLDrawable {
+
+	private long hwnd;
+
+	public WindowsDummyGLDrawable() {
+		super(new GLCapabilities(), (GLCapabilitiesChooser) null);
+		synchronized (WindowsDummyGLDrawable.class) {
+			this.hwnd = WGL.CreateDummyWindow(0, 0, 1, 1);
+		}
+		this.hdc = WGL.GetDC(this.hwnd);
+		GLCapabilities var1 = new GLCapabilities();
+		var1.setDepthBits(16);
+		PIXELFORMATDESCRIPTOR var2 = glCapabilities2PFD(var1, true);
+		int var3 = WGL.ChoosePixelFormat(this.hdc, var2);
+		if (var3 == 0 || !WGL.SetPixelFormat(this.hdc, var3, var2)) {
+			this.destroy();
+		}
+	}
+
+	public GLContext createContext(GLContext arg0) {
+		return this.hdc == 0L ? null : new WindowsGLContext(this);
+	}
+
+	public void destroy() {
+		if (this.hdc != 0L) {
+			WGL.ReleaseDC(this.hwnd, this.hdc);
+			this.hdc = 0L;
+		}
+		if (this.hwnd != 0L) {
+			WGL.ShowWindow(this.hwnd, 0);
+			WGL.DestroyWindow(this.hwnd);
+			this.hwnd = 0L;
+		}
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/WindowsGLContext.java

@@ -0,0 +1,121 @@
+package com.sun.opengl.impl.windows;
+
+import com.sun.opengl.impl.GLContextImpl;
+import java.util.HashMap;
+import java.util.Map;
+import javax.media.opengl.GLException;
+
+public class WindowsGLContext extends GLContextImpl {
+
+	protected WindowsGLDrawable drawable;
+
+	protected long hglrc;
+
+	private boolean wglGetExtensionsStringEXTInitialized;
+
+	private boolean wglGetExtensionsStringEXTAvailable;
+
+	private static final Map functionNameMap = new HashMap();
+
+	private static final Map extensionNameMap;
+
+	private WGLExt wglExt;
+
+	private WGLExtProcAddressTable wglExtProcAddressTable;
+
+	public WindowsGLContext(WindowsGLDrawable arg0) {
+		this.drawable = arg0;
+	}
+
+	public Object getPlatformGLExtensions() {
+		return this.getWGLExt();
+	}
+
+	public WGLExt getWGLExt() {
+		if (this.wglExt == null) {
+			this.wglExt = new WGLExtImpl(this);
+		}
+		return this.wglExt;
+	}
+
+	protected String mapToRealGLExtensionName(String arg0) {
+		String var2 = (String) extensionNameMap.get(arg0);
+		return var2 == null ? arg0 : var2;
+	}
+
+	protected void create() {
+		if (this.drawable.getHDC() == 0L) {
+			throw new GLException("Internal error: attempted to create OpenGL context without an associated drawable");
+		}
+		this.hglrc = WGL.wglCreateContext(this.drawable.getHDC());
+		if (this.hglrc == 0L) {
+			throw new GLException("Unable to create OpenGL context for device context " + toHexString(this.drawable.getHDC()));
+		}
+	}
+
+	protected int makeCurrentImpl() throws GLException {
+		boolean var1 = false;
+		if (this.hglrc == 0L) {
+			this.create();
+			var1 = true;
+		}
+		if (!WGL.wglMakeCurrent(this.drawable.getHDC(), this.hglrc)) {
+			throw new GLException("Error making context current: " + WGL.GetLastError());
+		} else if (var1) {
+			this.resetGLFunctionAvailability();
+			return 2;
+		} else {
+			return 1;
+		}
+	}
+
+	protected void releaseImpl() throws GLException {
+		if (!WGL.wglMakeCurrent(0L, 0L)) {
+			throw new GLException("Error freeing OpenGL context: " + WGL.GetLastError());
+		}
+	}
+
+	protected void destroyImpl() throws GLException {
+		if (this.hglrc != 0L) {
+			if (!WGL.wglDeleteContext(this.hglrc)) {
+				throw new GLException("Unable to delete OpenGL context");
+			}
+			this.hglrc = 0L;
+		}
+	}
+
+	protected void resetGLFunctionAvailability() {
+		super.resetGLFunctionAvailability();
+		this.resetProcAddressTable(this.getWGLExtProcAddressTable());
+	}
+
+	public WGLExtProcAddressTable getWGLExtProcAddressTable() {
+		if (this.wglExtProcAddressTable == null) {
+			this.wglExtProcAddressTable = new WGLExtProcAddressTable();
+		}
+		return this.wglExtProcAddressTable;
+	}
+
+	public String getPlatformExtensionsString() {
+		if (!this.wglGetExtensionsStringEXTInitialized) {
+			this.wglGetExtensionsStringEXTAvailable = WGL.wglGetProcAddress("wglGetExtensionsStringEXT") != 0L;
+			this.wglGetExtensionsStringEXTInitialized = true;
+		}
+		return this.wglGetExtensionsStringEXTAvailable ? this.getWGLExt().wglGetExtensionsStringEXT() : "";
+	}
+
+	public void setSwapInterval(int arg0) {
+		WGLExt var2 = this.getWGLExt();
+		if (var2.isExtensionAvailable("WGL_EXT_swap_control")) {
+			var2.wglSwapIntervalEXT(arg0);
+		}
+	}
+
+	static {
+		functionNameMap.put("glAllocateMemoryNV", "wglAllocateMemoryNV");
+		functionNameMap.put("glFreeMemoryNV", "wglFreeMemoryNV");
+		extensionNameMap = new HashMap();
+		extensionNameMap.put("GL_ARB_pbuffer", "WGL_ARB_pbuffer");
+		extensionNameMap.put("GL_ARB_pixel_format", "WGL_ARB_pixel_format");
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/WindowsGLDrawable.java

@@ -0,0 +1,392 @@
+package com.sun.opengl.impl.windows;
+
+import com.sun.opengl.impl.GLDrawableImpl;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLException;
+
+public abstract class WindowsGLDrawable extends GLDrawableImpl {
+
+	protected long hdc;
+
+	protected GLCapabilities capabilities;
+
+	protected GLCapabilitiesChooser chooser;
+
+	protected boolean pixelFormatChosen;
+
+	public WindowsGLDrawable(GLCapabilities arg0, GLCapabilitiesChooser arg1) {
+		this.capabilities = (GLCapabilities) arg0.clone();
+		this.chooser = arg1;
+	}
+
+	public void setRealized(boolean arg0) {
+		throw new GLException("Should not call this (should only be called for onscreen GLDrawables)");
+	}
+
+	public void swapBuffers() throws GLException {
+	}
+
+	public long getHDC() {
+		return this.hdc;
+	}
+
+	protected void choosePixelFormat(boolean arg0) {
+		PIXELFORMATDESCRIPTOR var2 = null;
+		boolean var3 = false;
+		GLCapabilities var4 = null;
+		int var25;
+		if (arg0) {
+			if ((var25 = WGL.GetPixelFormat(this.hdc)) != 0) {
+				var2 = newPixelFormatDescriptor();
+				if (WGL.DescribePixelFormat(this.hdc, var25, PIXELFORMATDESCRIPTOR.size(), var2) == 0) {
+					throw new GLException("Unable to describe pixel format " + var25 + " of window set by Java2D/OpenGL pipeline");
+				}
+				this.setChosenGLCapabilities(pfd2GLCapabilities(var2));
+				this.pixelFormatChosen = true;
+				return;
+			}
+			GLCapabilities[] var5 = null;
+			int var6 = 0;
+			var2 = newPixelFormatDescriptor();
+			WindowsDummyGLDrawable var7 = null;
+			WindowsGLContext var8 = null;
+			WGLExt var9 = null;
+			if (this.capabilities.getSampleBuffers()) {
+				var7 = new WindowsDummyGLDrawable();
+				var8 = (WindowsGLContext) var7.createContext(null);
+				if (var8 != null) {
+					var8.makeCurrent();
+					var9 = (WGLExt) var8.getPlatformGLExtensions();
+				}
+			}
+			int var10 = -1;
+			boolean var11 = false;
+			boolean var12 = false;
+			boolean var13 = false;
+			if (var9 != null) {
+				try {
+					var11 = var9.isExtensionAvailable("WGL_ARB_pixel_format");
+					if (var11) {
+						var12 = var9.isExtensionAvailable("WGL_ARB_multisample");
+						int[] var14 = new int[512];
+						int[] var15 = new int[512];
+						float[] var16 = new float[1];
+						if (glCapabilities2iattributes(this.capabilities, var14, var9, null)) {
+							int[] var17 = new int[256];
+							int[] var18 = new int[1];
+							if (var9.wglChoosePixelFormatARB(this.hdc, var14, 0, var16, 0, 256, var17, 0, var18, 0)) {
+								var6 = var18[0];
+								if (var6 > 0) {
+									var10 = var17[0] - 1;
+								}
+							}
+							byte var19 = 0;
+							var14[0] = 8192;
+							if (var9.wglGetPixelFormatAttribivARB(this.hdc, 0, 0, 1, var14, 0, var15, 0)) {
+								var6 = var15[0];
+								int var35 = var19 + 1;
+								var14[var19] = 8193;
+								int var37 = var35 + 1;
+								var14[var35] = 8195;
+								int var39 = var37 + 1;
+								var14[var37] = 8208;
+								int var41 = var39 + 1;
+								var14[var39] = 8226;
+								int var44 = var41 + 1;
+								var14[var41] = 8227;
+								int var46 = var44 + 1;
+								var14[var44] = 8209;
+								int var48 = var46 + 1;
+								var14[var46] = 8210;
+								int var50 = var48 + 1;
+								var14[var48] = 8211;
+								int var52 = var50 + 1;
+								var14[var50] = 8213;
+								int var54 = var52 + 1;
+								var14[var52] = 8215;
+								int var55 = var54 + 1;
+								var14[var54] = 8217;
+								int var56 = var55 + 1;
+								var14[var55] = 8219;
+								int var57 = var56 + 1;
+								var14[var56] = 8222;
+								int var58 = var57 + 1;
+								var14[var57] = 8223;
+								int var59 = var58 + 1;
+								var14[var58] = 8224;
+								int var60 = var59 + 1;
+								var14[var59] = 8225;
+								if (var12) {
+									var14[var60++] = 8257;
+									var14[var60++] = 8258;
+								}
+								var5 = new GLCapabilities[var6];
+								for (int var20 = 0; var20 < var6; var20++) {
+									if (!var9.wglGetPixelFormatAttribivARB(this.hdc, var20 + 1, 0, var60, var14, 0, var15, 0)) {
+										throw new GLException("Error getting pixel format attributes for pixel format " + (var20 + 1) + " of device context");
+									}
+									var5[var20] = iattributes2GLCapabilities(var14, var60, var15, true);
+								}
+								var13 = true;
+							} else {
+								long var43 = (long) WGL.GetLastError();
+								if (var43 != 0L) {
+									throw new GLException("Unable to enumerate pixel formats of window using wglGetPixelFormatAttribivARB: error code " + WGL.GetLastError());
+								}
+							}
+						}
+					}
+				} finally {
+					var8.release();
+					var8.destroy();
+					var7.destroy();
+				}
+			}
+			if (!var13) {
+				var2 = glCapabilities2PFD(this.capabilities, arg0);
+				var10 = WGL.ChoosePixelFormat(this.hdc, var2) - 1;
+				var6 = WGL.DescribePixelFormat(this.hdc, 1, 0, null);
+				if (var6 == 0) {
+					throw new GLException("Unable to enumerate pixel formats of window for GLCapabilitiesChooser");
+				}
+				var5 = new GLCapabilities[var6];
+				for (int var28 = 0; var28 < var6; var28++) {
+					if (WGL.DescribePixelFormat(this.hdc, var28 + 1, PIXELFORMATDESCRIPTOR.size(), var2) == 0) {
+						throw new GLException("Error describing pixel format " + (var28 + 1) + " of device context");
+					}
+					var5[var28] = pfd2GLCapabilities(var2);
+				}
+			}
+			int var26 = this.chooser.chooseCapabilities(this.capabilities, var5, var10);
+			if (var26 < 0 || var26 >= var6) {
+				throw new GLException("Invalid result " + var26 + " from GLCapabilitiesChooser (should be between 0 and " + (var6 - 1) + ")");
+			}
+			var4 = var5[var26];
+			var25 = var26 + 1;
+			if (WGL.DescribePixelFormat(this.hdc, var25, PIXELFORMATDESCRIPTOR.size(), var2) == 0) {
+				throw new GLException("Error re-describing the chosen pixel format: " + WGL.GetLastError());
+			}
+		} else {
+			var2 = glCapabilities2PFD(this.capabilities, arg0);
+			var25 = WGL.ChoosePixelFormat(this.hdc, var2);
+		}
+		if (!WGL.SetPixelFormat(this.hdc, var25, var2)) {
+			long var27 = (long) WGL.GetLastError();
+			throw new GLException("Unable to set pixel format " + var25 + " for device context " + toHexString(this.hdc) + ": error code " + var27);
+		}
+		if (var4 == null) {
+			this.setChosenGLCapabilities(pfd2GLCapabilities(var2));
+		} else {
+			this.setChosenGLCapabilities(var4);
+		}
+		this.pixelFormatChosen = true;
+	}
+
+	protected static PIXELFORMATDESCRIPTOR glCapabilities2PFD(GLCapabilities arg0, boolean arg1) {
+		int var2 = arg0.getRedBits() + arg0.getGreenBits() + arg0.getBlueBits();
+		if (var2 < 15) {
+			throw new GLException("Bit depths < 15 (i.e., non-true-color) not supported");
+		}
+		PIXELFORMATDESCRIPTOR var3 = newPixelFormatDescriptor();
+		int var4 = 4128;
+		if (arg0.getDoubleBuffered()) {
+			var4 |= 0x1;
+		}
+		if (arg1) {
+			var4 |= 0x4;
+		} else {
+			var4 |= 0x8;
+		}
+		if (arg0.getStereo()) {
+			var4 |= 0x2;
+		}
+		var3.dwFlags(var4);
+		var3.iPixelType((byte) 0);
+		var3.cColorBits((byte) var2);
+		var3.cRedBits((byte) arg0.getRedBits());
+		var3.cGreenBits((byte) arg0.getGreenBits());
+		var3.cBlueBits((byte) arg0.getBlueBits());
+		var3.cAlphaBits((byte) arg0.getAlphaBits());
+		int var5 = arg0.getAccumRedBits() + arg0.getAccumGreenBits() + arg0.getAccumBlueBits();
+		var3.cAccumBits((byte) var5);
+		var3.cAccumRedBits((byte) arg0.getAccumRedBits());
+		var3.cAccumGreenBits((byte) arg0.getAccumGreenBits());
+		var3.cAccumBlueBits((byte) arg0.getAccumBlueBits());
+		var3.cAccumAlphaBits((byte) arg0.getAccumAlphaBits());
+		var3.cDepthBits((byte) arg0.getDepthBits());
+		var3.cStencilBits((byte) arg0.getStencilBits());
+		var3.iLayerType((byte) 0);
+		return var3;
+	}
+
+	protected static PIXELFORMATDESCRIPTOR newPixelFormatDescriptor() {
+		PIXELFORMATDESCRIPTOR var0 = PIXELFORMATDESCRIPTOR.create();
+		var0.nSize((short) PIXELFORMATDESCRIPTOR.size());
+		var0.nVersion((short) 1);
+		return var0;
+	}
+
+	protected static GLCapabilities pfd2GLCapabilities(PIXELFORMATDESCRIPTOR arg0) {
+		if ((arg0.dwFlags() & 0x20) == 0) {
+			return null;
+		}
+		GLCapabilities var1 = new GLCapabilities();
+		var1.setRedBits(arg0.cRedBits());
+		var1.setGreenBits(arg0.cGreenBits());
+		var1.setBlueBits(arg0.cBlueBits());
+		var1.setAlphaBits(arg0.cAlphaBits());
+		var1.setAccumRedBits(arg0.cAccumRedBits());
+		var1.setAccumGreenBits(arg0.cAccumGreenBits());
+		var1.setAccumBlueBits(arg0.cAccumBlueBits());
+		var1.setAccumAlphaBits(arg0.cAccumAlphaBits());
+		var1.setDepthBits(arg0.cDepthBits());
+		var1.setStencilBits(arg0.cStencilBits());
+		var1.setDoubleBuffered((arg0.dwFlags() & 0x1) != 0);
+		var1.setStereo((arg0.dwFlags() & 0x2) != 0);
+		var1.setHardwareAccelerated((arg0.dwFlags() & 0x40) == 0 || (arg0.dwFlags() & 0x1000) != 0);
+		return var1;
+	}
+
+	protected static boolean glCapabilities2iattributes(GLCapabilities arg0, int[] arg1, WGLExt arg2, int[] arg3) throws GLException {
+		if (!arg2.isExtensionAvailable("WGL_ARB_pixel_format")) {
+			return false;
+		}
+		byte var4 = 0;
+		int var5 = var4 + 1;
+		arg1[var4] = 8208;
+		int var6 = var5 + 1;
+		arg1[var5] = 1;
+		int var7 = var6 + 1;
+		arg1[var6] = 8193;
+		int var8 = var7 + 1;
+		arg1[var7] = 1;
+		int var9 = var8 + 1;
+		arg1[var8] = 8209;
+		if (arg0.getDoubleBuffered()) {
+			var5 = var9 + 1;
+			arg1[var9] = 1;
+		} else {
+			var5 = var9 + 1;
+			arg1[var9] = 0;
+		}
+		arg1[var5++] = 8210;
+		if (arg0.getStereo()) {
+			arg1[var5++] = 1;
+		} else {
+			arg1[var5++] = 0;
+		}
+		arg1[var5++] = 8226;
+		arg1[var5++] = arg0.getDepthBits();
+		arg1[var5++] = 8213;
+		arg1[var5++] = arg0.getRedBits();
+		arg1[var5++] = 8215;
+		arg1[var5++] = arg0.getGreenBits();
+		arg1[var5++] = 8217;
+		arg1[var5++] = arg0.getBlueBits();
+		arg1[var5++] = 8219;
+		arg1[var5++] = arg0.getAlphaBits();
+		arg1[var5++] = 8227;
+		arg1[var5++] = arg0.getStencilBits();
+		if (arg0.getAccumRedBits() > 0 || arg0.getAccumGreenBits() > 0 || arg0.getAccumBlueBits() > 0 || arg0.getAccumAlphaBits() > 0) {
+			arg1[var5++] = 8221;
+			arg1[var5++] = arg0.getAccumRedBits() + arg0.getAccumGreenBits() + arg0.getAccumBlueBits() + arg0.getAccumAlphaBits();
+			arg1[var5++] = 8222;
+			arg1[var5++] = arg0.getAccumRedBits();
+			arg1[var5++] = 8223;
+			arg1[var5++] = arg0.getAccumGreenBits();
+			arg1[var5++] = 8224;
+			arg1[var5++] = arg0.getAccumBlueBits();
+			arg1[var5++] = 8225;
+			arg1[var5++] = arg0.getAccumAlphaBits();
+		}
+		if (arg2.isExtensionAvailable("WGL_ARB_multisample") && arg0.getSampleBuffers()) {
+			arg1[var5++] = 8257;
+			arg1[var5++] = 1;
+			arg1[var5++] = 8258;
+			arg1[var5++] = arg0.getNumSamples();
+		}
+		arg1[var5++] = 8211;
+		arg1[var5++] = 8235;
+		return true;
+	}
+
+	protected static GLCapabilities iattributes2GLCapabilities(int[] arg0, int arg1, int[] arg2, boolean arg3) {
+		GLCapabilities var4 = new GLCapabilities();
+		for (int var5 = 0; var5 < arg1; var5++) {
+			int var6 = arg0[var5];
+			switch(var6) {
+				case 8193:
+					if (arg3 && arg2[var5] != 1) {
+						return null;
+					}
+					break;
+				case 8195:
+					var4.setHardwareAccelerated(arg2[var5] == 8231);
+					break;
+				case 8208:
+					if (arg2[var5] != 1) {
+						return null;
+					}
+					break;
+				case 8209:
+					var4.setDoubleBuffered(arg2[var5] == 1);
+					break;
+				case 8210:
+					var4.setStereo(arg2[var5] == 1);
+					break;
+				case 8211:
+					if (arg2[var5] == 8235 || arg2[var5] == 8608) {
+						var4.setPbufferFloatingPointBuffers(true);
+					}
+					break;
+				case 8213:
+					var4.setRedBits(arg2[var5]);
+					break;
+				case 8215:
+					var4.setGreenBits(arg2[var5]);
+					break;
+				case 8217:
+					var4.setBlueBits(arg2[var5]);
+					break;
+				case 8219:
+					var4.setAlphaBits(arg2[var5]);
+					break;
+				case 8222:
+					var4.setAccumRedBits(arg2[var5]);
+					break;
+				case 8223:
+					var4.setAccumGreenBits(arg2[var5]);
+					break;
+				case 8224:
+					var4.setAccumBlueBits(arg2[var5]);
+					break;
+				case 8225:
+					var4.setAccumAlphaBits(arg2[var5]);
+					break;
+				case 8226:
+					var4.setDepthBits(arg2[var5]);
+					break;
+				case 8227:
+					var4.setStencilBits(arg2[var5]);
+				case 8237:
+					break;
+				case 8257:
+					var4.setSampleBuffers(arg2[var5] != 0);
+					break;
+				case 8258:
+					var4.setNumSamples(arg2[var5]);
+					break;
+				case 8368:
+					if (arg2[var5] != 0) {
+						var4.setPbufferFloatingPointBuffers(true);
+					}
+					break;
+				default:
+					throw new GLException("Unknown pixel format attribute " + arg0[var5]);
+			}
+		}
+		return var4;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/WindowsGLDrawableFactory.java

@@ -0,0 +1,31 @@
+package com.sun.opengl.impl.windows;
+
+import com.sun.opengl.impl.GLDrawableFactoryImpl;
+import java.awt.Component;
+import javax.media.opengl.DefaultGLCapabilitiesChooser;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLDrawable;
+
+public class WindowsGLDrawableFactory extends GLDrawableFactoryImpl {
+
+	public GLDrawable getGLDrawable(Object arg0, GLCapabilities arg1, GLCapabilitiesChooser arg2) {
+		if (arg0 == null) {
+			throw new IllegalArgumentException("Null target");
+		} else if (arg0 instanceof Component) {
+			if (arg1 == null) {
+				arg1 = new GLCapabilities();
+			}
+			if (arg2 == null) {
+				arg2 = new DefaultGLCapabilitiesChooser();
+			}
+			return new WindowsOnscreenGLDrawable((Component) arg0, arg1, arg2);
+		} else {
+			throw new IllegalArgumentException("GLDrawables not supported for objects of type " + arg0.getClass().getName() + " (only Components are supported in this implementation)");
+		}
+	}
+
+	public long dynamicLookupFunction(String arg0) {
+		return WGL.wglGetProcAddress(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/WindowsOnscreenGLContext.java

@@ -0,0 +1,38 @@
+package com.sun.opengl.impl.windows;
+
+import javax.media.opengl.GLException;
+
+public class WindowsOnscreenGLContext extends WindowsGLContext {
+
+	protected WindowsOnscreenGLDrawable drawable;
+
+	public WindowsOnscreenGLContext(WindowsOnscreenGLDrawable arg0) {
+		super(arg0);
+		this.drawable = arg0;
+	}
+
+	protected int makeCurrentImpl() throws GLException {
+		int var1 = this.drawable.lockSurface();
+		if (var1 == 1) {
+			return 0;
+		}
+		int var2;
+		try {
+			if (var1 == 2) {
+				super.destroyImpl();
+			}
+			var2 = super.makeCurrentImpl();
+		} finally {
+			this.drawable.unlockSurface(false);
+		}
+		return var2;
+	}
+
+	protected void releaseImpl() throws GLException {
+		try {
+			super.releaseImpl();
+		} finally {
+			this.drawable.unlockSurface(true);
+		}
+	}
+}

gl/src/main/java/com/sun/opengl/impl/windows/WindowsOnscreenGLDrawable.java

@@ -0,0 +1,108 @@
+package com.sun.opengl.impl.windows;
+
+import com.sun.opengl.impl.JAWT;
+import com.sun.opengl.impl.JAWT_DrawingSurface;
+import com.sun.opengl.impl.JAWT_DrawingSurfaceInfo;
+import java.awt.Component;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLException;
+
+public class WindowsOnscreenGLDrawable extends WindowsGLDrawable {
+
+	private Component component;
+
+	private JAWT_DrawingSurface ds;
+
+	private JAWT_DrawingSurfaceInfo dsi;
+
+	protected boolean realized;
+
+	public WindowsOnscreenGLDrawable(Component arg0, GLCapabilities arg1, GLCapabilitiesChooser arg2) {
+		super(arg1, arg2);
+		this.component = arg0;
+	}
+
+	public GLContext createContext(GLContext arg0) {
+		return new WindowsOnscreenGLContext(this);
+	}
+
+	public void setRealized(boolean arg0) {
+		this.realized = arg0;
+		if (!arg0) {
+			this.setChosenGLCapabilities(null);
+			this.pixelFormatChosen = false;
+		}
+	}
+
+	public void swapBuffers() throws GLException {
+		int var1 = this.lockSurface();
+		if (var1 == 1) {
+			return;
+		}
+		try {
+			if (!WGL.SwapBuffers(this.hdc) && WGL.GetLastError() != 0) {
+				throw new GLException("Error swapping buffers");
+			}
+		} finally {
+			this.unlockSurface(false);
+		}
+	}
+
+	public int lockSurface() {
+		if (this.hdc != 0L) {
+			return 3;
+		} else if (this.realized) {
+			this.ds = JAWT.getJAWT().GetDrawingSurface(this.component);
+			if (this.ds == null) {
+				return 1;
+			}
+			int var1 = this.ds.Lock();
+			if ((var1 & 0x1) != 0) {
+				JAWT.getJAWT().FreeDrawingSurface(this.ds);
+				this.ds = null;
+				return 1;
+			}
+			this.dsi = this.ds.GetDrawingSurfaceInfo();
+			if (this.dsi == null) {
+				this.ds.Unlock();
+				JAWT.getJAWT().FreeDrawingSurface(this.ds);
+				this.ds = null;
+				return 1;
+			}
+			this.hdc = ((JAWT_Win32DrawingSurfaceInfo) this.dsi.platformInfo()).hdc();
+			if (this.hdc == 0L) {
+				this.ds.FreeDrawingSurfaceInfo(this.dsi);
+				this.ds.Unlock();
+				JAWT.getJAWT().FreeDrawingSurface(this.ds);
+				this.ds = null;
+				this.dsi = null;
+				return 1;
+			}
+			if (!this.pixelFormatChosen) {
+				try {
+					this.choosePixelFormat(true);
+				} catch (RuntimeException var3) {
+					this.unlockSurface(true);
+					return 1;
+				}
+			}
+			return (var1 & 0x8) == 0 ? 3 : 2;
+		} else {
+			return 1;
+		}
+	}
+
+	public void unlockSurface(boolean arg0) {
+		if (!arg0 || this.hdc == 0L) {
+			return;
+		}
+		this.ds.FreeDrawingSurfaceInfo(this.dsi);
+		this.ds.Unlock();
+		JAWT.getJAWT().FreeDrawingSurface(this.ds);
+		this.ds = null;
+		this.dsi = null;
+		this.hdc = 0L;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/DRIHack.java

@@ -0,0 +1,40 @@
+package com.sun.opengl.impl.x11;
+
+import com.sun.gluegen.runtime.NativeLibrary;
+import java.io.File;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+public class DRIHack {
+
+	private static boolean driHackNeeded;
+
+	private static NativeLibrary oglLib;
+
+	public static void begin() {
+		AccessController.doPrivileged(new PrivilegedAction() {
+
+			public Object run() {
+				String var1 = System.getProperty("os.name").toLowerCase();
+				DRIHack.driHackNeeded = var1.startsWith("linux") || (new File("/usr/lib/dri")).exists() || (new File("/usr/X11R6/lib/modules/dri")).exists();
+				if (System.getProperty("jogl.drihack.disable") != null) {
+					DRIHack.driHackNeeded = false;
+				}
+				return null;
+			}
+		});
+		if (driHackNeeded) {
+			oglLib = NativeLibrary.open("libGL.so.1", null);
+			if (oglLib == null) {
+				oglLib = NativeLibrary.open("/usr/lib/libGL.so.1", null);
+			}
+		}
+	}
+
+	public static void end() {
+		if (oglLib != null) {
+			oglLib.close();
+			oglLib = null;
+		}
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/GLX.java

@@ -0,0 +1,75 @@
+package com.sun.opengl.impl.x11;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import javax.media.opengl.GLException;
+
+public class GLX {
+
+	private static GLXProcAddressTable glxProcAddressTable = new GLXProcAddressTable();
+
+	private static native ByteBuffer XGetVisualInfo1(long arg0, long arg1, ByteBuffer arg2, Object arg3, int arg4);
+
+	public static XVisualInfo[] XGetVisualInfo(long arg0, long arg1, XVisualInfo arg2, int[] arg3, int arg4) {
+		if (arg3 != null && arg3.length <= arg4) {
+			throw new GLException("array offset argument \"arg3_offset\" (" + arg4 + ") equals or exceeds array length (" + arg3.length + ")");
+		}
+		ByteBuffer var7 = XGetVisualInfo1(arg0, arg1, arg2 == null ? null : arg2.getBuffer(), arg3, arg4 * 4);
+		if (var7 == null) {
+			return null;
+		}
+		var7.order(ByteOrder.nativeOrder());
+		XVisualInfo[] var8 = new XVisualInfo[getFirstElement(arg3, arg4)];
+		for (int var9 = 0; var9 < getFirstElement(arg3, arg4); var9++) {
+			var7.position(var9 * XVisualInfo.size());
+			var7.limit((var9 + 1) * XVisualInfo.size());
+			ByteBuffer var10 = var7.slice();
+			var10.order(ByteOrder.nativeOrder());
+			var7.position(0);
+			var7.limit(var7.capacity());
+			var8[var9] = XVisualInfo.create(var10);
+		}
+		return var8;
+	}
+
+	public static native long XOpenDisplay(String arg0);
+
+	public static native boolean XineramaEnabled(long arg0);
+
+	public static long glXCreateContext(long arg0, XVisualInfo arg1, long arg2, boolean arg3) {
+		return glXCreateContext0(arg0, arg1 == null ? null : arg1.getBuffer(), arg2, arg3);
+	}
+
+	private static native long glXCreateContext0(long arg0, ByteBuffer arg1, long arg2, boolean arg3);
+
+	public static native void glXDestroyContext(long arg0, long arg1);
+
+	public static native String glXGetClientString(long arg0, int arg1);
+
+	private static native int glXGetConfig1(long arg0, ByteBuffer arg1, int arg2, Object arg3, int arg4);
+
+	public static int glXGetConfig(long arg0, XVisualInfo arg1, int arg2, int[] arg3, int arg4) {
+		if (arg3 != null && arg3.length <= arg4) {
+			throw new GLException("array offset argument \"value_offset\" (" + arg4 + ") equals or exceeds array length (" + arg3.length + ")");
+		}
+		return glXGetConfig1(arg0, arg1 == null ? null : arg1.getBuffer(), arg2, arg3, arg4 * 4);
+	}
+
+	public static native long glXGetProcAddressARB(String arg0);
+
+	public static native boolean glXMakeCurrent(long arg0, long arg1, long arg2);
+
+	public static native String glXQueryExtensionsString(long arg0, int arg1);
+
+	public static native void glXSwapBuffers(long arg0, long arg1);
+
+	public static GLXProcAddressTable getGLXProcAddressTable() {
+		return glxProcAddressTable;
+	}
+
+	public static native int DefaultScreen(long arg0);
+
+	private static int getFirstElement(int[] arg0, int arg1) {
+		return arg0[arg1];
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/GLXExt.java

@@ -0,0 +1,8 @@
+package com.sun.opengl.impl.x11;
+
+public interface GLXExt {
+
+	int glXSwapIntervalSGI(int arg0);
+
+	boolean isExtensionAvailable(String arg0);
+}

gl/src/main/java/com/sun/opengl/impl/x11/GLXExtImpl.java

@@ -0,0 +1,26 @@
+package com.sun.opengl.impl.x11;
+
+import javax.media.opengl.GLException;
+
+public class GLXExtImpl implements GLXExt {
+
+	private X11GLContext _context;
+
+	public int glXSwapIntervalSGI(int arg0) {
+		long var2 = this._context.getGLXExtProcAddressTable()._addressof_glXSwapIntervalSGI;
+		if (var2 == 0L) {
+			throw new GLException("Method \"glXSwapIntervalSGI\" not available");
+		}
+		return this.dispatch_glXSwapIntervalSGI0(arg0, var2);
+	}
+
+	public native int dispatch_glXSwapIntervalSGI0(int arg0, long arg1);
+
+	public GLXExtImpl(X11GLContext arg0) {
+		this._context = arg0;
+	}
+
+	public boolean isExtensionAvailable(String arg0) {
+		return this._context.isExtensionAvailable(arg0);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/GLXExtProcAddressTable.java

@@ -0,0 +1,6 @@
+package com.sun.opengl.impl.x11;
+
+public class GLXExtProcAddressTable {
+
+	public long _addressof_glXSwapIntervalSGI;
+}

gl/src/main/java/com/sun/opengl/impl/x11/GLXProcAddressTable.java

@@ -0,0 +1,88 @@
+package com.sun.opengl.impl.x11;
+
+public class GLXProcAddressTable {
+
+	public long _addressof_glXBindHyperpipeSGIX;
+
+	public long _addressof_glXBindSwapBarrierNV;
+
+	public long _addressof_glXBindTexImageEXT;
+
+	public long _addressof_glXBindVideoImageNV;
+
+	public long _addressof_glXChooseFBConfig;
+
+	public long _addressof_glXCreateNewContext;
+
+	public long _addressof_glXCreatePbuffer;
+
+	public long _addressof_glXCreatePixmap;
+
+	public long _addressof_glXCreateWindow;
+
+	public long _addressof_glXDestroyHyperpipeConfigSGIX;
+
+	public long _addressof_glXDestroyPbuffer;
+
+	public long _addressof_glXDestroyPixmap;
+
+	public long _addressof_glXDestroyWindow;
+
+	public long _addressof_glXGetAGPOffsetMESA;
+
+	public long _addressof_glXGetCurrentDisplay;
+
+	public long _addressof_glXGetCurrentReadDrawable;
+
+	public long _addressof_glXGetFBConfigAttrib;
+
+	public long _addressof_glXGetFBConfigs;
+
+	public long _addressof_glXGetProcAddress;
+
+	public long _addressof_glXGetSelectedEvent;
+
+	public long _addressof_glXGetVideoDeviceNV;
+
+	public long _addressof_glXGetVideoInfoNV;
+
+	public long _addressof_glXGetVisualFromFBConfig;
+
+	public long _addressof_glXHyperpipeAttribSGIX;
+
+	public long _addressof_glXHyperpipeConfigSGIX;
+
+	public long _addressof_glXJoinSwapGroupNV;
+
+	public long _addressof_glXMakeContextCurrent;
+
+	public long _addressof_glXQueryContext;
+
+	public long _addressof_glXQueryDrawable;
+
+	public long _addressof_glXQueryFrameCountNV;
+
+	public long _addressof_glXQueryHyperpipeAttribSGIX;
+
+	public long _addressof_glXQueryHyperpipeBestAttribSGIX;
+
+	public long _addressof_glXQueryHyperpipeConfigSGIX;
+
+	public long _addressof_glXQueryHyperpipeNetworkSGIX;
+
+	public long _addressof_glXQueryMaxSwapGroupsNV;
+
+	public long _addressof_glXQuerySwapGroupNV;
+
+	public long _addressof_glXReleaseTexImageEXT;
+
+	public long _addressof_glXReleaseVideoDeviceNV;
+
+	public long _addressof_glXReleaseVideoImageNV;
+
+	public long _addressof_glXResetFrameCountNV;
+
+	public long _addressof_glXSelectEvent;
+
+	public long _addressof_glXSendPbufferToVideoNV;
+}

gl/src/main/java/com/sun/opengl/impl/x11/JAWT_X11DrawingSurfaceInfo.java

@@ -0,0 +1,34 @@
+package com.sun.opengl.impl.x11;
+
+import com.sun.gluegen.runtime.BufferFactory;
+import com.sun.gluegen.runtime.CPU;
+import com.sun.gluegen.runtime.StructAccessor;
+import com.sun.opengl.impl.JAWT_PlatformInfo;
+import java.nio.ByteBuffer;
+
+public abstract class JAWT_X11DrawingSurfaceInfo implements JAWT_PlatformInfo {
+
+	StructAccessor accessor;
+
+	public static int size() {
+		return CPU.is32Bit() ? JAWT_X11DrawingSurfaceInfo32.size() : JAWT_X11DrawingSurfaceInfo64.size();
+	}
+
+	public static JAWT_X11DrawingSurfaceInfo create() {
+		return create(BufferFactory.newDirectByteBuffer(size()));
+	}
+
+	public static JAWT_X11DrawingSurfaceInfo create(ByteBuffer arg0) {
+		return CPU.is32Bit() ? new JAWT_X11DrawingSurfaceInfo32(arg0) : new JAWT_X11DrawingSurfaceInfo64(arg0);
+	}
+
+	JAWT_X11DrawingSurfaceInfo(ByteBuffer arg0) {
+		this.accessor = new StructAccessor(arg0);
+	}
+
+	public abstract long drawable();
+
+	public abstract long display();
+
+	public abstract long visualID();
+}

gl/src/main/java/com/sun/opengl/impl/x11/JAWT_X11DrawingSurfaceInfo32.java

@@ -0,0 +1,27 @@
+package com.sun.opengl.impl.x11;
+
+import com.sun.opengl.impl.JAWT_PlatformInfo;
+import java.nio.ByteBuffer;
+
+class JAWT_X11DrawingSurfaceInfo32 extends JAWT_X11DrawingSurfaceInfo implements JAWT_PlatformInfo {
+
+	public static int size() {
+		return 24;
+	}
+
+	JAWT_X11DrawingSurfaceInfo32(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public long drawable() {
+		return (long) this.accessor.getIntAt(0);
+	}
+
+	public long display() {
+		return (long) this.accessor.getIntAt(1);
+	}
+
+	public long visualID() {
+		return (long) this.accessor.getIntAt(2);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/JAWT_X11DrawingSurfaceInfo64.java

@@ -0,0 +1,27 @@
+package com.sun.opengl.impl.x11;
+
+import com.sun.opengl.impl.JAWT_PlatformInfo;
+import java.nio.ByteBuffer;
+
+class JAWT_X11DrawingSurfaceInfo64 extends JAWT_X11DrawingSurfaceInfo implements JAWT_PlatformInfo {
+
+	public static int size() {
+		return 48;
+	}
+
+	JAWT_X11DrawingSurfaceInfo64(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public long drawable() {
+		return this.accessor.getLongAt(0);
+	}
+
+	public long display() {
+		return this.accessor.getLongAt(1);
+	}
+
+	public long visualID() {
+		return this.accessor.getLongAt(2);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/X11GLContext.java

@@ -0,0 +1,153 @@
+package com.sun.opengl.impl.x11;
+
+import com.sun.opengl.impl.GLContextImpl;
+import com.sun.opengl.impl.GLDrawableFactoryImpl;
+import java.util.HashMap;
+import java.util.Map;
+import javax.media.opengl.GLException;
+
+public abstract class X11GLContext extends GLContextImpl {
+
+	protected X11GLDrawable drawable;
+
+	protected long context;
+
+	private boolean glXQueryExtensionsStringInitialized;
+
+	private boolean glXQueryExtensionsStringAvailable;
+
+	private static final Map functionNameMap = new HashMap();
+
+	private GLXExt glXExt;
+
+	private GLXExtProcAddressTable glXExtProcAddressTable;
+
+	protected long mostRecentDisplay;
+
+	public X11GLContext(X11GLDrawable arg0) {
+		this.drawable = arg0;
+	}
+
+	public GLXExt getGLXExt() {
+		if (this.glXExt == null) {
+			this.glXExt = new GLXExtImpl(this);
+		}
+		return this.glXExt;
+	}
+
+	protected String mapToRealGLExtensionName(String arg0) {
+		return arg0;
+	}
+
+	protected abstract void create();
+
+	protected void createContext(boolean arg0) {
+		XVisualInfo var2 = this.drawable.chooseVisual(arg0);
+		long var3 = 0L;
+		this.context = GLX.glXCreateContext(this.drawable.getDisplay(), var2, var3, arg0);
+		if (this.context == 0L) {
+			throw new GLException("Unable to create OpenGL context");
+		}
+	}
+
+	protected int makeCurrentImpl() throws GLException {
+		boolean var1 = false;
+		if (this.context == 0L) {
+			this.create();
+			var1 = true;
+		}
+		if (!GLX.glXMakeCurrent(this.drawable.getDisplay(), this.drawable.getDrawable(), this.context)) {
+			throw new GLException("Error making context current");
+		}
+		this.mostRecentDisplay = this.drawable.getDisplay();
+		if (var1) {
+			this.resetGLFunctionAvailability();
+			return 2;
+		} else {
+			return 1;
+		}
+	}
+
+	protected void releaseImpl() throws GLException {
+		this.lockToolkit();
+		try {
+			if (!GLX.glXMakeCurrent(this.mostRecentDisplay, 0L, 0L)) {
+				throw new GLException("Error freeing OpenGL context");
+			}
+		} finally {
+			this.unlockToolkit();
+		}
+	}
+
+	protected void destroyImpl() throws GLException {
+		this.lockToolkit();
+		try {
+			if (this.context != 0L) {
+				GLX.glXDestroyContext(this.mostRecentDisplay, this.context);
+				this.context = 0L;
+				this.mostRecentDisplay = 0L;
+			}
+		} finally {
+			this.unlockToolkit();
+		}
+	}
+
+	protected void resetGLFunctionAvailability() {
+		super.resetGLFunctionAvailability();
+		this.resetProcAddressTable(this.getGLXExtProcAddressTable());
+	}
+
+	public GLXExtProcAddressTable getGLXExtProcAddressTable() {
+		if (this.glXExtProcAddressTable == null) {
+			this.glXExtProcAddressTable = new GLXExtProcAddressTable();
+		}
+		return this.glXExtProcAddressTable;
+	}
+
+	public synchronized String getPlatformExtensionsString() {
+		if (this.mostRecentDisplay == 0L) {
+			throw new GLException("Context not current");
+		}
+		if (!this.glXQueryExtensionsStringInitialized) {
+			this.glXQueryExtensionsStringAvailable = GLDrawableFactoryImpl.getFactoryImpl().dynamicLookupFunction("glXQueryExtensionsString") != 0L;
+			this.glXQueryExtensionsStringInitialized = true;
+		}
+		if (!this.glXQueryExtensionsStringAvailable) {
+			return "";
+		}
+		this.lockToolkit();
+		String var2;
+		try {
+			String var1 = GLX.glXQueryExtensionsString(this.mostRecentDisplay, GLX.DefaultScreen(this.mostRecentDisplay));
+			var2 = var1;
+		} finally {
+			this.unlockToolkit();
+		}
+		return var2;
+	}
+
+	public void setSwapInterval(int arg0) {
+		this.lockToolkit();
+		try {
+			GLXExt var2 = this.getGLXExt();
+			if (var2.isExtensionAvailable("GLX_SGI_swap_control")) {
+				var2.glXSwapIntervalSGI(arg0);
+			}
+		} finally {
+			this.unlockToolkit();
+		}
+	}
+
+	protected void lockToolkit() {
+		X11GLDrawableFactory.getX11Factory().lockToolkit();
+	}
+
+	protected void unlockToolkit() {
+		X11GLDrawableFactory.getX11Factory().unlockToolkit();
+	}
+
+	static {
+		functionNameMap.put("glAllocateMemoryNV", "glXAllocateMemoryNV");
+		functionNameMap.put("glFreeMemoryNV", "glXFreeMemoryNV");
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/X11GLDrawable.java

@@ -0,0 +1,96 @@
+package com.sun.opengl.impl.x11;
+
+import com.sun.opengl.impl.GLDrawableImpl;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLException;
+
+public abstract class X11GLDrawable extends GLDrawableImpl {
+
+	protected long display;
+
+	protected long drawable;
+
+	protected long visualID;
+
+	protected GLCapabilities capabilities;
+
+	protected GLCapabilitiesChooser chooser;
+
+	public X11GLDrawable(GLCapabilities arg0, GLCapabilitiesChooser arg1) {
+		this.capabilities = arg0 == null ? null : (GLCapabilities) arg0.clone();
+		this.chooser = arg1;
+	}
+
+	public void setRealized(boolean arg0) {
+		throw new GLException("Should not call this (should only be called for onscreen GLDrawables)");
+	}
+
+	public void swapBuffers() throws GLException {
+	}
+
+	public long getDisplay() {
+		return this.display;
+	}
+
+	public long getDrawable() {
+		return this.drawable;
+	}
+
+	protected XVisualInfo chooseVisual(boolean arg0) {
+		if (this.display == 0L) {
+			throw new GLException("null display");
+		}
+		XVisualInfo var3;
+		if (arg0) {
+			int[] var12 = new int[1];
+			var3 = XVisualInfo.create();
+			var3.visualid((long) this.visualID);
+			this.lockToolkit();
+			XVisualInfo[] var13 = GLX.XGetVisualInfo(this.display, 1L, var3, var12, 0);
+			this.unlockToolkit();
+			if (var13 == null || var13.length == 0) {
+				throw new GLException("Error while getting XVisualInfo for visual ID " + this.visualID);
+			}
+			return var13[0];
+		}
+		byte var2 = 0;
+		var3 = null;
+		int[] var4 = new int[1];
+		XVisualInfo var5 = XVisualInfo.create();
+		var5.screen(var2);
+		XVisualInfo[] var6 = null;
+		GLCapabilities[] var7 = null;
+		this.lockToolkit();
+		int var8;
+		try {
+			var6 = GLX.XGetVisualInfo(this.display, 2L, var5, var4, 0);
+			if (var6 == null) {
+				throw new GLException("Error while enumerating available XVisualInfos");
+			}
+			var7 = new GLCapabilities[var6.length];
+			for (var8 = 0; var8 < var6.length; var8++) {
+				var7[var8] = X11GLDrawableFactory.xvi2GLCapabilities(this.display, var6[var8]);
+			}
+		} finally {
+			this.unlockToolkit();
+		}
+		var8 = this.chooser.chooseCapabilities(this.capabilities, var7, -1);
+		if (var8 < 0 || var8 >= var7.length) {
+			throw new GLException("GLCapabilitiesChooser specified invalid index (expected 0.." + (var7.length - 1) + ")");
+		}
+		var3 = var6[var8];
+		if (var3 == null) {
+			throw new GLException("GLCapabilitiesChooser chose an invalid visual");
+		}
+		return var3;
+	}
+
+	protected void lockToolkit() {
+		X11GLDrawableFactory.getX11Factory().lockToolkit();
+	}
+
+	protected void unlockToolkit() {
+		X11GLDrawableFactory.getX11Factory().unlockToolkit();
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/X11GLDrawableFactory.java

@@ -0,0 +1,200 @@
+package com.sun.opengl.impl.x11;
+
+import com.sun.gluegen.runtime.ProcAddressHelper;
+import com.sun.opengl.impl.GLDrawableFactoryImpl;
+import com.sun.opengl.impl.JAWT;
+import java.awt.Component;
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsEnvironment;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLDrawable;
+import javax.media.opengl.GLException;
+
+public class X11GLDrawableFactory extends GLDrawableFactoryImpl {
+
+	private static boolean isHeadless = GraphicsEnvironment.isHeadless();
+
+	private static Map visualToGLCapsMap = Collections.synchronizedMap(new HashMap());
+
+	private static long staticDisplay;
+
+	private static boolean checkedMultisample;
+
+	private static boolean multisampleAvailable;
+
+	private boolean checkedXinerama;
+
+	private boolean xineramaEnabled;
+
+	public X11GLDrawableFactory() {
+		ProcAddressHelper.resetProcAddressTable(GLX.getGLXProcAddressTable(), this);
+	}
+
+	public GLDrawable getGLDrawable(Object arg0, GLCapabilities arg1, GLCapabilitiesChooser arg2) {
+		if (arg0 == null) {
+			throw new IllegalArgumentException("Null target");
+		} else if (arg0 instanceof Component) {
+			Component var4 = (Component) arg0;
+			X11OnscreenGLDrawable var5 = new X11OnscreenGLDrawable(var4);
+			GraphicsConfiguration var6 = var4.getGraphicsConfiguration();
+			if (var6 == null) {
+				throw new IllegalArgumentException("GLDrawableFactory.chooseGraphicsConfiguration() was not used when creating this Component");
+			}
+			int var7 = X11SunJDKReflection.graphicsConfigurationGetVisualID(var6);
+			int var8;
+			if (this.isXineramaEnabled()) {
+				var8 = 0;
+			} else {
+				var8 = X11SunJDKReflection.graphicsDeviceGetScreen(var6.getDevice());
+			}
+			var5.setChosenGLCapabilities((GLCapabilities) visualToGLCapsMap.get(new X11GLDrawableFactory.ScreenAndVisualIDKey(var8, (long) var7)));
+			return var5;
+		} else {
+			throw new IllegalArgumentException("GLDrawables not supported for objects of type " + arg0.getClass().getName() + " (only Components are supported in this implementation)");
+		}
+	}
+
+	public long dynamicLookupFunction(String arg0) {
+		return GLX.glXGetProcAddressARB(arg0);
+	}
+
+	public static GLCapabilities xvi2GLCapabilities(long arg0, XVisualInfo arg1) {
+		int[] var3 = new int[1];
+		int var4 = glXGetConfig(arg0, arg1, 1, var3, 0);
+		if (var4 == 0) {
+			return null;
+		}
+		var4 = glXGetConfig(arg0, arg1, 4, var3, 0);
+		if (var4 == 0) {
+			return null;
+		}
+		GLCapabilities var5 = new GLCapabilities();
+		var5.setDoubleBuffered(glXGetConfig(arg0, arg1, 5, var3, 0) != 0);
+		var5.setStereo(glXGetConfig(arg0, arg1, 6, var3, 0) != 0);
+		var5.setHardwareAccelerated(true);
+		var5.setDepthBits(glXGetConfig(arg0, arg1, 12, var3, 0));
+		var5.setStencilBits(glXGetConfig(arg0, arg1, 13, var3, 0));
+		var5.setRedBits(glXGetConfig(arg0, arg1, 8, var3, 0));
+		var5.setGreenBits(glXGetConfig(arg0, arg1, 9, var3, 0));
+		var5.setBlueBits(glXGetConfig(arg0, arg1, 10, var3, 0));
+		var5.setAlphaBits(glXGetConfig(arg0, arg1, 11, var3, 0));
+		var5.setAccumRedBits(glXGetConfig(arg0, arg1, 14, var3, 0));
+		var5.setAccumGreenBits(glXGetConfig(arg0, arg1, 15, var3, 0));
+		var5.setAccumBlueBits(glXGetConfig(arg0, arg1, 16, var3, 0));
+		var5.setAccumAlphaBits(glXGetConfig(arg0, arg1, 17, var3, 0));
+		if (isMultisampleAvailable()) {
+			var5.setSampleBuffers(glXGetConfig(arg0, arg1, 100000, var3, 0) != 0);
+			var5.setNumSamples(glXGetConfig(arg0, arg1, 100001, var3, 0));
+		}
+		return var5;
+	}
+
+	public void lockToolkit() {
+		if (!isHeadless) {
+			JAWT.getJAWT().Lock();
+		}
+	}
+
+	public void unlockToolkit() {
+		if (!isHeadless) {
+			JAWT.getJAWT().Unlock();
+		}
+	}
+
+	public static long getDisplayConnection() {
+		if (staticDisplay == 0L) {
+			getX11Factory().lockToolkit();
+			try {
+				staticDisplay = GLX.XOpenDisplay(null);
+			} finally {
+				getX11Factory().unlockToolkit();
+			}
+			if (staticDisplay == 0L) {
+				throw new GLException("Unable to open default display, needed for visual selection and offscreen surface handling");
+			}
+		}
+		return staticDisplay;
+	}
+
+	public static boolean isMultisampleAvailable() {
+		if (!checkedMultisample) {
+			long var0 = getDisplayConnection();
+			String var2 = GLX.glXGetClientString(var0, 3);
+			if (var2 != null) {
+				multisampleAvailable = var2.indexOf("GLX_ARB_multisample") >= 0;
+			}
+			checkedMultisample = true;
+		}
+		return multisampleAvailable;
+	}
+
+	private static String glXGetConfigErrorCode(int arg0) {
+		switch(arg0) {
+			case 1:
+				return "GLX_BAD_SCREEN";
+			case 2:
+				return "GLX_BAD_ATTRIBUTE";
+			case 3:
+				return "GLX_NO_EXTENSION";
+			case 4:
+				return "GLX_BAD_VISUAL";
+			default:
+				return "Unknown error code " + arg0;
+		}
+	}
+
+	public static int glXGetConfig(long arg0, XVisualInfo arg1, int arg2, int[] arg3, int arg4) {
+		if (arg0 == 0L) {
+			throw new GLException("No display connection");
+		}
+		int var6 = GLX.glXGetConfig(arg0, arg1, arg2, arg3, arg4);
+		if (var6 != 0) {
+			throw new GLException("glXGetConfig failed: error code " + glXGetConfigErrorCode(var6));
+		}
+		return arg3[arg4];
+	}
+
+	public static X11GLDrawableFactory getX11Factory() {
+		return (X11GLDrawableFactory) getFactory();
+	}
+
+	protected synchronized boolean isXineramaEnabled() {
+		if (!this.checkedXinerama) {
+			this.checkedXinerama = true;
+			this.lockToolkit();
+			long var1 = getDisplayConnection();
+			this.xineramaEnabled = GLX.XineramaEnabled(var1);
+			this.unlockToolkit();
+		}
+		return this.xineramaEnabled;
+	}
+
+	static class ScreenAndVisualIDKey {
+
+		private int screen;
+
+		private long visualID;
+
+		ScreenAndVisualIDKey(int arg0, long arg1) {
+			this.screen = arg0;
+			this.visualID = arg1;
+		}
+
+		public int hashCode() {
+			return (int) ((long) this.screen + this.visualID * 13L);
+		}
+
+		public boolean equals(Object arg0) {
+			if (arg0 != null && arg0 instanceof X11GLDrawableFactory.ScreenAndVisualIDKey) {
+				X11GLDrawableFactory.ScreenAndVisualIDKey var2 = (X11GLDrawableFactory.ScreenAndVisualIDKey) arg0;
+				return this.screen == var2.screen && this.visualID == var2.visualID;
+			} else {
+				return false;
+			}
+		}
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/X11OnscreenGLContext.java

@@ -0,0 +1,34 @@
+package com.sun.opengl.impl.x11;
+
+import javax.media.opengl.GLException;
+
+public class X11OnscreenGLContext extends X11GLContext {
+
+	protected X11OnscreenGLDrawable drawable;
+
+	public X11OnscreenGLContext(X11OnscreenGLDrawable arg0) {
+		super(arg0);
+		this.drawable = arg0;
+	}
+
+	protected int makeCurrentImpl() throws GLException {
+		int var1 = this.drawable.lockSurface();
+		if (var1 == 1) {
+			return 0;
+		}
+		int var2;
+		try {
+			if (var1 == 2) {
+				super.destroyImpl();
+			}
+			var2 = super.makeCurrentImpl();
+		} finally {
+			this.drawable.unlockSurface();
+		}
+		return var2;
+	}
+
+	protected void create() {
+		this.createContext(true);
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/X11OnscreenGLDrawable.java

@@ -0,0 +1,110 @@
+package com.sun.opengl.impl.x11;
+
+import com.sun.opengl.impl.JAWT;
+import com.sun.opengl.impl.JAWT_DrawingSurface;
+import com.sun.opengl.impl.JAWT_DrawingSurfaceInfo;
+import java.awt.Component;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLException;
+
+public class X11OnscreenGLDrawable extends X11GLDrawable {
+
+	private Component component;
+
+	private JAWT_DrawingSurface ds;
+
+	private JAWT_DrawingSurfaceInfo dsi;
+
+	protected boolean realized;
+
+	public X11OnscreenGLDrawable(Component arg0) {
+		super((GLCapabilities) null, (GLCapabilitiesChooser) null);
+		this.component = arg0;
+	}
+
+	public GLContext createContext(GLContext arg0) {
+		return new X11OnscreenGLContext(this);
+	}
+
+	public void setRealized(boolean arg0) {
+		this.realized = arg0;
+	}
+
+	public void swapBuffers() throws GLException {
+		this.lockToolkit();
+		try {
+			int var1 = this.lockSurface();
+			if (var1 == 1) {
+				return;
+			}
+			try {
+				GLX.glXSwapBuffers(this.display, this.drawable);
+			} finally {
+				this.unlockSurface();
+			}
+		} finally {
+			this.unlockToolkit();
+		}
+	}
+
+	public int lockSurface() throws GLException {
+		if (this.drawable != 0L) {
+			return 3;
+		} else if (this.realized) {
+			this.ds = JAWT.getJAWT().GetDrawingSurface(this.component);
+			if (this.ds == null) {
+				return 1;
+			}
+			int var1 = this.ds.Lock();
+			if ((var1 & 0x1) != 0) {
+				JAWT.getJAWT().FreeDrawingSurface(this.ds);
+				this.ds = null;
+				return 1;
+			}
+			this.dsi = this.ds.GetDrawingSurfaceInfo();
+			if (this.dsi == null) {
+				this.ds.Unlock();
+				JAWT.getJAWT().FreeDrawingSurface(this.ds);
+				this.ds = null;
+				return 1;
+			}
+			JAWT_X11DrawingSurfaceInfo var2 = (JAWT_X11DrawingSurfaceInfo) this.dsi.platformInfo();
+			this.display = var2.display();
+			this.drawable = var2.drawable();
+			this.visualID = var2.visualID();
+			if (this.display == 0L || this.drawable == 0L) {
+				this.ds.FreeDrawingSurfaceInfo(this.dsi);
+				this.ds.Unlock();
+				JAWT.getJAWT().FreeDrawingSurface(this.ds);
+				this.ds = null;
+				this.dsi = null;
+				this.display = 0L;
+				this.drawable = 0L;
+				this.visualID = 0L;
+				return 1;
+			} else if ((var1 & 0x8) == 0) {
+				return 3;
+			} else {
+				return 2;
+			}
+		} else {
+			return 1;
+		}
+	}
+
+	public void unlockSurface() {
+		if (this.drawable == 0L) {
+			return;
+		}
+		this.ds.FreeDrawingSurfaceInfo(this.dsi);
+		this.ds.Unlock();
+		JAWT.getJAWT().FreeDrawingSurface(this.ds);
+		this.ds = null;
+		this.dsi = null;
+		this.display = 0L;
+		this.drawable = 0L;
+		this.visualID = 0L;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/X11SunJDKReflection.java

@@ -0,0 +1,61 @@
+package com.sun.opengl.impl.x11;
+
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+public class X11SunJDKReflection {
+
+	private static Class x11GraphicsDeviceClass;
+
+	private static Method x11GraphicsDeviceGetScreenMethod;
+
+	private static Class x11GraphicsConfigClass;
+
+	private static Method x11GraphicsConfigGetVisualMethod;
+
+	private static boolean initted;
+
+	public static int graphicsDeviceGetScreen(GraphicsDevice arg0) {
+		if (!initted) {
+			return 0;
+		}
+		try {
+			return (Integer) x11GraphicsDeviceGetScreenMethod.invoke(arg0);
+		} catch (Exception var2) {
+			return 0;
+		}
+	}
+
+	public static int graphicsConfigurationGetVisualID(GraphicsConfiguration arg0) {
+		if (!initted) {
+			return 0;
+		}
+		try {
+			return (Integer) x11GraphicsConfigGetVisualMethod.invoke(arg0);
+		} catch (Exception var2) {
+			return 0;
+		}
+	}
+
+	static {
+		AccessController.doPrivileged(new PrivilegedAction() {
+
+			public Object run() {
+				try {
+					X11SunJDKReflection.x11GraphicsDeviceClass = Class.forName("sun.awt.X11GraphicsDevice");
+					X11SunJDKReflection.x11GraphicsDeviceGetScreenMethod = X11SunJDKReflection.x11GraphicsDeviceClass.getDeclaredMethod("getScreen");
+					X11SunJDKReflection.x11GraphicsDeviceGetScreenMethod.setAccessible(true);
+					X11SunJDKReflection.x11GraphicsConfigClass = Class.forName("sun.awt.X11GraphicsConfig");
+					X11SunJDKReflection.x11GraphicsConfigGetVisualMethod = X11SunJDKReflection.x11GraphicsConfigClass.getDeclaredMethod("getVisual");
+					X11SunJDKReflection.x11GraphicsConfigGetVisualMethod.setAccessible(true);
+					X11SunJDKReflection.initted = true;
+				} catch (Exception var2) {
+				}
+				return null;
+			}
+		});
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/XVisualInfo.java

@@ -0,0 +1,35 @@
+package com.sun.opengl.impl.x11;
+
+import com.sun.gluegen.runtime.BufferFactory;
+import com.sun.gluegen.runtime.CPU;
+import com.sun.gluegen.runtime.StructAccessor;
+import java.nio.ByteBuffer;
+
+public abstract class XVisualInfo {
+
+	StructAccessor accessor;
+
+	public static int size() {
+		return CPU.is32Bit() ? XVisualInfo32.size() : XVisualInfo64.size();
+	}
+
+	public static XVisualInfo create() {
+		return create(BufferFactory.newDirectByteBuffer(size()));
+	}
+
+	public static XVisualInfo create(ByteBuffer arg0) {
+		return CPU.is32Bit() ? new XVisualInfo32(arg0) : new XVisualInfo64(arg0);
+	}
+
+	XVisualInfo(ByteBuffer arg0) {
+		this.accessor = new StructAccessor(arg0);
+	}
+
+	public ByteBuffer getBuffer() {
+		return this.accessor.getBuffer();
+	}
+
+	public abstract XVisualInfo visualid(long arg0);
+
+	public abstract XVisualInfo screen(int arg0);
+}

gl/src/main/java/com/sun/opengl/impl/x11/XVisualInfo32.java

@@ -0,0 +1,24 @@
+package com.sun.opengl.impl.x11;
+
+import java.nio.ByteBuffer;
+
+class XVisualInfo32 extends XVisualInfo {
+
+	public static int size() {
+		return 40;
+	}
+
+	XVisualInfo32(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public XVisualInfo visualid(long arg0) {
+		this.accessor.setIntAt(1, (int) arg0);
+		return this;
+	}
+
+	public XVisualInfo screen(int arg0) {
+		this.accessor.setIntAt(2, arg0);
+		return this;
+	}
+}

gl/src/main/java/com/sun/opengl/impl/x11/XVisualInfo64.java

@@ -0,0 +1,24 @@
+package com.sun.opengl.impl.x11;
+
+import java.nio.ByteBuffer;
+
+class XVisualInfo64 extends XVisualInfo {
+
+	public static int size() {
+		return 64;
+	}
+
+	XVisualInfo64(ByteBuffer arg0) {
+		super(arg0);
+	}
+
+	public XVisualInfo visualid(long arg0) {
+		this.accessor.setLongAt(1, arg0);
+		return this;
+	}
+
+	public XVisualInfo screen(int arg0) {
+		this.accessor.setIntAt(4, arg0);
+		return this;
+	}
+}

gl/src/main/java/com/sun/opengl/util/BufferUtil.java

@@ -0,0 +1,52 @@
+package com.sun.opengl.util;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.nio.ShortBuffer;
+
+public class BufferUtil {
+
+	public static ByteBuffer newByteBuffer(int arg0) {
+		ByteBuffer var1 = ByteBuffer.allocateDirect(arg0);
+		var1.order(ByteOrder.nativeOrder());
+		return var1;
+	}
+
+	public static ByteBuffer copyByteBuffer(ByteBuffer arg0) {
+		ByteBuffer var1 = newByteBuffer(arg0.remaining());
+		arg0.mark();
+		var1.put(arg0);
+		arg0.reset();
+		var1.rewind();
+		return var1;
+	}
+
+	public static ByteBuffer copyFloatBufferAsByteBuffer(FloatBuffer arg0) {
+		ByteBuffer var1 = newByteBuffer(arg0.remaining() * 4);
+		arg0.mark();
+		var1.asFloatBuffer().put(arg0);
+		arg0.reset();
+		var1.rewind();
+		return var1;
+	}
+
+	public static ByteBuffer copyIntBufferAsByteBuffer(IntBuffer arg0) {
+		ByteBuffer var1 = newByteBuffer(arg0.remaining() * 4);
+		arg0.mark();
+		var1.asIntBuffer().put(arg0);
+		arg0.reset();
+		var1.rewind();
+		return var1;
+	}
+
+	public static ByteBuffer copyShortBufferAsByteBuffer(ShortBuffer arg0) {
+		ByteBuffer var1 = newByteBuffer(arg0.remaining() * 2);
+		arg0.mark();
+		var1.asShortBuffer().put(arg0);
+		arg0.reset();
+		var1.rewind();
+		return var1;
+	}
+}

gl/src/main/java/javax/media/opengl/DefaultGLCapabilitiesChooser.java

@@ -0,0 +1,91 @@
+package javax.media.opengl;
+
+public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
+
+	public int chooseCapabilities(GLCapabilities arg0, GLCapabilities[] arg1, int arg2) {
+		if (arg2 >= 0 && arg2 < arg1.length && arg1[arg2] != null) {
+			return arg2;
+		}
+		int[] var4 = new int[arg1.length];
+		int var5 = -9999999;
+		short var6 = 1000;
+		short var7 = 500;
+		byte var8 = 36;
+		byte var9 = 6;
+		byte var10 = 1;
+		byte var11 = 3;
+		int var12;
+		for (var12 = 0; var12 < var4.length; var12++) {
+			var4[var12] = var5;
+		}
+		int var20;
+		for (var12 = 0; var12 < var4.length; var12++) {
+			GLCapabilities var13 = arg1[var12];
+			if (var13 != null && arg0.getStereo() == var13.getStereo()) {
+				byte var14 = 0;
+				var20 = var14 + var8 * (var13.getRedBits() + var13.getGreenBits() + var13.getBlueBits() + var13.getAlphaBits() - arg0.getRedBits() - arg0.getGreenBits() - arg0.getBlueBits() - arg0.getAlphaBits());
+				int var21 = var20 + var9 * sign(var20) * Math.abs(var13.getDepthBits() - arg0.getDepthBits());
+				int var22 = var21 + var10 * sign(var21) * Math.abs(var13.getAccumRedBits() + var13.getAccumGreenBits() + var13.getAccumBlueBits() + var13.getAccumAlphaBits() - arg0.getAccumRedBits() - arg0.getAccumGreenBits() - arg0.getAccumBlueBits() - arg0.getAccumAlphaBits());
+				var20 = var22 + var11 * sign(var22) * (var13.getStencilBits() - arg0.getStencilBits());
+				if (var13.getDoubleBuffered() != arg0.getDoubleBuffered()) {
+					var20 += sign(var20) * var6;
+				}
+				if (arg0.getStencilBits() > 0 && var13.getStencilBits() == 0) {
+					var20 += sign(var20) * var7;
+				}
+				var4[var12] = var20;
+			}
+		}
+		boolean var18 = false;
+		int var19 = 0;
+		int var15;
+		GLCapabilities var16;
+		int var17;
+		for (var20 = 0; var20 < var4.length; var20++) {
+			var15 = var4[var20];
+			if (var15 != var5) {
+				var16 = arg1[var20];
+				if (var16.getHardwareAccelerated()) {
+					var17 = Math.abs(var15);
+					if (!var18 || var17 > var19) {
+						var18 = true;
+						var19 = var17;
+					}
+				}
+			}
+		}
+		if (var18) {
+			for (var20 = 0; var20 < var4.length; var20++) {
+				var15 = var4[var20];
+				if (var15 != var5) {
+					var16 = arg1[var20];
+					if (!var16.getHardwareAccelerated()) {
+						if (var15 <= 0) {
+							var15 -= var19;
+						} else if (var15 > 0) {
+							var15 += var19;
+						}
+						var4[var20] = var15;
+					}
+				}
+			}
+		}
+		var20 = var5;
+		var15 = -1;
+		for (int var23 = 0; var23 < var4.length; var23++) {
+			var17 = var4[var23];
+			if (var17 != var5 && (var20 == var5 || Math.abs(var17) < Math.abs(var20) && (sign(var20) < 0 || sign(var17) > 0))) {
+				var20 = var17;
+				var15 = var23;
+			}
+		}
+		if (var15 < 0) {
+			throw new GLException("Unable to select one of the provided GLCapabilities");
+		}
+		return var15;
+	}
+
+	private static int sign(int arg0) {
+		return arg0 < 0 ? -1 : 1;
+	}
+}

gl/src/main/java/javax/media/opengl/GL.java

@@ -0,0 +1,525 @@
+package javax.media.opengl;
+
+import java.nio.Buffer;
+import java.nio.FloatBuffer;
+
+public interface GL {
+
+	int GL_POINTS = 0x0;
+
+	int GL_ONE = 0x1;
+
+	int GL_LINES = 0x1;
+
+	int GL_LINE_LOOP = 0x2;
+
+	int GL_TRIANGLES = 0x4;
+
+	int GL_TRIANGLE_FAN = 0x6;
+
+	int GL_FOG_BIT = 0x80;
+
+	int GL_DEPTH_BUFFER_BIT = 0x100;
+
+	int GL_ADD = 0x104;
+
+	int GL_LEQUAL = 0x203;
+
+	int GL_GREATER = 0x204;
+
+	int GL_SRC_COLOR = 0x300;
+
+	int GL_SRC_ALPHA = 0x302;
+
+	int GL_ONE_MINUS_SRC_ALPHA = 0x303;
+
+	int GL_DST_COLOR = 0x306;
+
+	int GL_FRONT_LEFT = 0x400;
+
+	int GL_BACK_LEFT = 0x402;
+
+	int GL_FRONT = 0x404;
+
+	int GL_BACK = 0x405;
+
+	int GL_CULL_FACE = 0xB44;
+
+	int GL_LIGHTING = 0xB50;
+
+	int GL_LIGHT_MODEL_AMBIENT = 0xB53;
+
+	int GL_COLOR_MATERIAL = 0xB57;
+
+	int GL_FOG = 0xB60;
+
+	int GL_FOG_DENSITY = 0xB62;
+
+	int GL_FOG_START = 0xB63;
+
+	int GL_FOG_END = 0xB64;
+
+	int GL_FOG_MODE = 0xB65;
+
+	int GL_FOG_COLOR = 0xB66;
+
+	int GL_DEPTH_TEST = 0xB71;
+
+	int GL_ALPHA_TEST = 0xBC0;
+
+	int GL_BLEND = 0xBE2;
+
+	int GL_DRAW_BUFFER = 0xC01;
+
+	int GL_READ_BUFFER = 0xC02;
+
+	int GL_SCISSOR_TEST = 0xC11;
+
+	int GL_FOG_HINT = 0xC54;
+
+	int GL_TEXTURE_GEN_S = 0xC60;
+
+	int GL_TEXTURE_GEN_T = 0xC61;
+
+	int GL_TEXTURE_GEN_R = 0xC62;
+
+	int GL_TEXTURE_GEN_Q = 0xC63;
+
+	int GL_UNPACK_SWAP_BYTES = 0xCF0;
+
+	int GL_UNPACK_LSB_FIRST = 0xCF1;
+
+	int GL_UNPACK_ROW_LENGTH = 0xCF2;
+
+	int GL_UNPACK_SKIP_ROWS = 0xCF3;
+
+	int GL_UNPACK_SKIP_PIXELS = 0xCF4;
+
+	int GL_UNPACK_ALIGNMENT = 0xCF5;
+
+	int GL_PACK_SWAP_BYTES = 0xD00;
+
+	int GL_PACK_LSB_FIRST = 0xD01;
+
+	int GL_PACK_ROW_LENGTH = 0xD02;
+
+	int GL_PACK_SKIP_ROWS = 0xD03;
+
+	int GL_PACK_SKIP_PIXELS = 0xD04;
+
+	int GL_PACK_ALIGNMENT = 0xD05;
+
+	int GL_MAX_TEXTURE_SIZE = 0xD33;
+
+	int GL_TEXTURE_1D = 0xDE0;
+
+	int GL_TEXTURE_2D = 0xDE1;
+
+	int GL_TEXTURE_WIDTH = 0x1000;
+
+	int GL_FASTEST = 0x1101;
+
+	int GL_AMBIENT = 0x1200;
+
+	int GL_DIFFUSE = 0x1201;
+
+	int GL_POSITION = 0x1203;
+
+	int GL_CONSTANT_ATTENUATION = 0x1207;
+
+	int GL_LINEAR_ATTENUATION = 0x1208;
+
+	int GL_QUADRATIC_ATTENUATION = 0x1209;
+
+	int GL_COMPILE = 0x1300;
+
+	int GL_UNSIGNED_BYTE = 0x1401;
+
+	int GL_UNSIGNED_SHORT = 0x1403;
+
+	int GL_UNSIGNED_INT = 0x1405;
+
+	int GL_FLOAT = 0x1406;
+
+	int GL_AMBIENT_AND_DIFFUSE = 0x1602;
+
+	int GL_MODELVIEW = 0x1700;
+
+	int GL_PROJECTION = 0x1701;
+
+	int GL_TEXTURE = 0x1702;
+
+	int GL_COLOR = 0x1800;
+
+	int GL_ALPHA = 0x1906;
+
+	int GL_RGBA = 0x1908;
+
+	int GL_LUMINANCE_ALPHA = 0x190A;
+
+	int GL_FILL = 0x1B02;
+
+	int GL_SMOOTH = 0x1D01;
+
+	int GL_REPLACE = 0x1E01;
+
+	int GL_VENDOR = 0x1F00;
+
+	int GL_RENDERER = 0x1F01;
+
+	int GL_VERSION = 0x1F02;
+
+	int GL_EXTENSIONS = 0x1F03;
+
+	int GL_S = 0x2000;
+
+	int GL_ENABLE_BIT = 0x2000;
+
+	int GL_T = 0x2001;
+
+	int GL_R = 0x2002;
+
+	int GL_Q = 0x2003;
+
+	int GL_MODULATE = 0x2100;
+
+	int GL_TEXTURE_ENV_MODE = 0x2200;
+
+	int GL_TEXTURE_ENV_COLOR = 0x2201;
+
+	int GL_TEXTURE_ENV = 0x2300;
+
+	int GL_EYE_LINEAR = 0x2400;
+
+	int GL_OBJECT_LINEAR = 0x2401;
+
+	int GL_TEXTURE_GEN_MODE = 0x2500;
+
+	int GL_OBJECT_PLANE = 0x2501;
+
+	int GL_EYE_PLANE = 0x2502;
+
+	int GL_NEAREST = 0x2600;
+
+	int GL_LINEAR = 0x2601;
+
+	int GL_LINEAR_MIPMAP_LINEAR = 0x2703;
+
+	int GL_TEXTURE_MAG_FILTER = 0x2800;
+
+	int GL_TEXTURE_MIN_FILTER = 0x2801;
+
+	int GL_TEXTURE_WRAP_S = 0x2802;
+
+	int GL_TEXTURE_WRAP_T = 0x2803;
+
+	int GL_REPEAT = 0x2901;
+
+	int GL_C4UB_V3F = 0x2A23;
+
+	int GL_T2F_V3F = 0x2A27;
+
+	int GL_LIGHT0 = 0x4000;
+
+	int GL_COLOR_BUFFER_BIT = 0x4000;
+
+	int GL_LIGHT1 = 0x4001;
+
+	int GL_TEXTURE_3D = 0x806F;
+
+	int GL_TEXTURE_WRAP_R = 0x8072;
+
+	int GL_VERTEX_ARRAY = 0x8074;
+
+	int GL_NORMAL_ARRAY = 0x8075;
+
+	int GL_COLOR_ARRAY = 0x8076;
+
+	int GL_TEXTURE_COORD_ARRAY = 0x8078;
+
+	int GL_BGRA = 0x80E1;
+
+	int GL_POINT_SIZE_MIN = 0x8126;
+
+	int GL_POINT_SIZE_MAX = 0x8127;
+
+	int GL_POINT_DISTANCE_ATTENUATION = 0x8129;
+
+	int GL_CLAMP_TO_EDGE = 0x812F;
+
+	int GL_UNSIGNED_INT_8_8_8_8_REV = 0x8367;
+
+	int GL_TEXTURE0 = 0x84C0;
+
+	int GL_TEXTURE1 = 0x84C1;
+
+	int GL_TEXTURE2 = 0x84C2;
+
+	int GL_MAX_TEXTURE_UNITS = 0x84E2;
+
+	int GL_SUBTRACT = 0x84E7;
+
+	int GL_NORMAL_MAP = 0x8511;
+
+	int GL_TEXTURE_CUBE_MAP = 0x8513;
+
+	int GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
+
+	int GL_COMBINE = 0x8570;
+
+	int GL_COMBINE_RGB = 0x8571;
+
+	int GL_COMBINE_ALPHA = 0x8572;
+
+	int GL_RGB_SCALE = 0x8573;
+
+	int GL_ADD_SIGNED = 0x8574;
+
+	int GL_INTERPOLATE = 0x8575;
+
+	int GL_CONSTANT = 0x8576;
+
+	int GL_PRIMARY_COLOR = 0x8577;
+
+	int GL_PREVIOUS = 0x8578;
+
+	int GL_SRC0_RGB = 0x8580;
+
+	int GL_SRC1_RGB = 0x8581;
+
+	int GL_SRC2_RGB = 0x8582;
+
+	int GL_SRC0_ALPHA = 0x8588;
+
+	int GL_SRC1_ALPHA = 0x8589;
+
+	int GL_SRC2_ALPHA = 0x858A;
+
+	int GL_OPERAND0_RGB = 0x8590;
+
+	int GL_OPERAND1_RGB = 0x8591;
+
+	int GL_VERTEX_PROGRAM_ARB = 0x8620;
+
+	int GL_PROGRAM_ERROR_POSITION_ARB = 0x864B;
+
+	int GL_FRAGMENT_PROGRAM_ARB = 0x8804;
+
+	int GL_MAX_TEXTURE_COORDS = 0x8871;
+
+	int GL_MAX_TEXTURE_IMAGE_UNITS = 0x8872;
+
+	int GL_PROGRAM_FORMAT_ASCII_ARB = 0x8875;
+
+	int GL_ARRAY_BUFFER = 0x8892;
+
+	int GL_ELEMENT_ARRAY_BUFFER = 0x8893;
+
+	int GL_STREAM_DRAW = 0x88E0;
+
+	int GL_STATIC_DRAW = 0x88E4;
+
+	void glActiveTexture(int texture);
+
+	void glAlphaFunc(int func, float ref);
+
+	void glBegin(int mode);
+
+	void glBindBufferARB(int target, int buffer);
+
+	void glBindProgramARB(int target, int program);
+
+	void glBindTexture(int target, int texture);
+
+	void glBlendFunc(int sfactor, int dfactor);
+
+	void glBufferDataARB(int target, int size, Buffer data, int usage);
+
+	void glBufferSubDataARB(int target, int offset, int size, Buffer data);
+
+	void glCallList(int list);
+
+	void glClear(int mask);
+
+	void glClearColor(float red, float green, float blue, float alpha);
+
+	void glClearDepth(double depth);
+
+	void glClientActiveTexture(int texture);
+
+	void glColor3ub(byte red, byte green, byte blue);
+
+	void glColor4f(float red, float green, float blue, float alpha);
+
+	void glColor4fv(float[] v, int vOffset);
+
+	void glColor4ub(byte red, byte green, byte blue, byte alpha);
+
+	void glColorMaterial(int face, int mode);
+
+	void glColorPointer(int size, int type, int stride, Buffer pointer);
+
+	void glColorPointer(int size, int type, int stride, long pointer);
+
+	void glCopyPixels(int x, int y, int width, int height, int type);
+
+	void glCullFace(int mode);
+
+	void glDeleteBuffersARB(int n, int[] buffers, int buffersOffset);
+
+	void glDeleteLists(int list, int range);
+
+	void glDeleteTextures(int n, int[] textures, int texturesOffset);
+
+	void glDepthFunc(int func);
+
+	void glDepthMask(boolean flag);
+
+	void glDisable(int cap);
+
+	void glDisableClientState(int array);
+
+	void glDrawBuffer(int buf);
+
+	void glDrawElements(int mode, int count, int type, Buffer indices);
+
+	void glDrawElements(int mode, int count, int type, long indices);
+
+	void glDrawPixels(int width, int height, int format, int type, Buffer pixels);
+
+	void glEnable(int cap);
+
+	void glEnableClientState(int array);
+
+	void glEnd();
+
+	void glEndList();
+
+	void glFogf(int pname, float param);
+
+	void glFogfv(int pname, float[] params, int paramsOffset);
+
+	void glFogi(int pname, int param);
+
+	void glGenBuffersARB(int n, int[] buffers, int buffersOffset);
+
+	int glGenLists(int range);
+
+	void glGenProgramsARB(int n, int[] programs, int programsOffset);
+
+	void glGenTextures(int n, int[] textures, int texturesOffset);
+
+	void glGetFloatv(int pname, FloatBuffer data);
+
+	void glGetFloatv(int pname, float[] data, int dataOffset);
+
+	void glGetIntegerv(int pname, int[] data, int dataOffset);
+
+	String glGetString(int name);
+
+	void glGetTexLevelParameteriv(int target, int level, int pname, int[] params, int paramsOffset);
+
+	void glHint(int target, int mode);
+
+	void glInterleavedArrays(int format, int stride, Buffer pointer);
+
+	void glInterleavedArrays(int format, int stride, long pointer);
+
+	void glLightModelfv(int pname, float[] params, int paramsOffset);
+
+	void glLightf(int light, int pname, float param);
+
+	void glLightfv(int light, int pname, float[] params, int paramsOffset);
+
+	void glLoadIdentity();
+
+	void glLoadMatrixf(float[] m, int mOffset);
+
+	void glMatrixMode(int mode);
+
+	void glMultiTexCoord2f(int target, float s, float t);
+
+	void glNewList(int list, int mode);
+
+	void glNormalPointer(int type, int stride, Buffer pointer);
+
+	void glNormalPointer(int type, int stride, long pointer);
+
+	void glOrtho(double left, double right, double bottom, double top, double zNear, double zFar);
+
+	void glPixelStorei(int pname, int param);
+
+	void glPixelZoom(float xfactor, float yfactor);
+
+	void glPointParameterfARB(int pname, float param);
+
+	void glPointParameterfvARB(int pname, float[] params, int paramsOffset);
+
+	void glPolygonMode(int face, int mode);
+
+	void glPopAttrib();
+
+	void glPopMatrix();
+
+	void glProgramLocalParameter4fARB(int target, int index, float x, float y, float z, float w);
+
+	void glProgramLocalParameter4fvARB(int target, int index, FloatBuffer params);
+
+	void glProgramLocalParameter4fvARB(int target, int index, float[] params, int paramsOffset);
+
+	void glProgramStringARB(int target, int format, int len, String string);
+
+	void glPushAttrib(int mask);
+
+	void glPushMatrix();
+
+	void glRasterPos2i(int x, int y);
+
+	void glReadBuffer(int src);
+
+	void glRotatef(float angle, float x, float y, float z);
+
+	void glScalef(float x, float y, float z);
+
+	void glScissor(int x, int y, int width, int height);
+
+	void glShadeModel(int mode);
+
+	void glTexCoord2f(float s, float t);
+
+	void glTexCoordPointer(int size, int type, int stride, Buffer pointer);
+
+	void glTexCoordPointer(int size, int type, int stride, long pointer);
+
+	void glTexEnvf(int target, int pname, float param);
+
+	void glTexEnvfv(int target, int pname, float[] params, int paramsOffset);
+
+	void glTexEnvi(int target, int pname, int param);
+
+	void glTexGenfv(int coord, int pname, float[] params, int paramsOffset);
+
+	void glTexGeni(int coord, int pname, int param);
+
+	void glTexImage1D(int target, int level, int internalformat, int width, int border, int format, int type, Buffer pixels);
+
+	void glTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, Buffer pixels);
+
+	void glTexImage3D(int target, int level, int internalformat, int width, int height, int depth, int border, int format, int type, Buffer pixels);
+
+	void glTexParameteri(int target, int pname, int param);
+
+	void glTranslatef(float x, float y, float z);
+
+	void glVertex2f(float x, float y);
+
+	void glVertexPointer(int size, int type, int stride, Buffer pointer);
+
+	void glVertexPointer(int size, int type, int stride, long pointer);
+
+	void glViewport(int x, int y, int width, int height);
+
+	boolean isExtensionAvailable(String arg0);
+
+	void setSwapInterval(int arg0);
+}

gl/src/main/java/javax/media/opengl/GLCapabilities.java

@@ -0,0 +1,172 @@
+package javax.media.opengl;
+
+public class GLCapabilities implements Cloneable {
+
+	private boolean doubleBuffered = true;
+
+	private boolean stereo = false;
+
+	private boolean hardwareAccelerated = true;
+
+	private int depthBits = 24;
+
+	private int stencilBits = 0;
+
+	private int redBits = 8;
+
+	private int greenBits = 8;
+
+	private int blueBits = 8;
+
+	private int alphaBits = 0;
+
+	private int accumRedBits = 0;
+
+	private int accumGreenBits = 0;
+
+	private int accumBlueBits = 0;
+
+	private int accumAlphaBits = 0;
+
+	private boolean sampleBuffers = false;
+
+	private int numSamples = 2;
+
+	private boolean pbufferFloatingPointBuffers;
+
+	public Object clone() {
+		try {
+			return super.clone();
+		} catch (CloneNotSupportedException var2) {
+			throw new GLException(var2);
+		}
+	}
+
+	public boolean getDoubleBuffered() {
+		return this.doubleBuffered;
+	}
+
+	public void setDoubleBuffered(boolean arg0) {
+		this.doubleBuffered = arg0;
+	}
+
+	public boolean getStereo() {
+		return this.stereo;
+	}
+
+	public void setStereo(boolean arg0) {
+		this.stereo = arg0;
+	}
+
+	public boolean getHardwareAccelerated() {
+		return this.hardwareAccelerated;
+	}
+
+	public void setHardwareAccelerated(boolean arg0) {
+		this.hardwareAccelerated = arg0;
+	}
+
+	public int getDepthBits() {
+		return this.depthBits;
+	}
+
+	public void setDepthBits(int arg0) {
+		this.depthBits = arg0;
+	}
+
+	public int getStencilBits() {
+		return this.stencilBits;
+	}
+
+	public void setStencilBits(int arg0) {
+		this.stencilBits = arg0;
+	}
+
+	public int getRedBits() {
+		return this.redBits;
+	}
+
+	public void setRedBits(int arg0) {
+		this.redBits = arg0;
+	}
+
+	public int getGreenBits() {
+		return this.greenBits;
+	}
+
+	public void setGreenBits(int arg0) {
+		this.greenBits = arg0;
+	}
+
+	public int getBlueBits() {
+		return this.blueBits;
+	}
+
+	public void setBlueBits(int arg0) {
+		this.blueBits = arg0;
+	}
+
+	public int getAlphaBits() {
+		return this.alphaBits;
+	}
+
+	public void setAlphaBits(int arg0) {
+		this.alphaBits = arg0;
+	}
+
+	public int getAccumRedBits() {
+		return this.accumRedBits;
+	}
+
+	public void setAccumRedBits(int arg0) {
+		this.accumRedBits = arg0;
+	}
+
+	public int getAccumGreenBits() {
+		return this.accumGreenBits;
+	}
+
+	public void setAccumGreenBits(int arg0) {
+		this.accumGreenBits = arg0;
+	}
+
+	public int getAccumBlueBits() {
+		return this.accumBlueBits;
+	}
+
+	public void setAccumBlueBits(int arg0) {
+		this.accumBlueBits = arg0;
+	}
+
+	public int getAccumAlphaBits() {
+		return this.accumAlphaBits;
+	}
+
+	public void setAccumAlphaBits(int arg0) {
+		this.accumAlphaBits = arg0;
+	}
+
+	public void setSampleBuffers(boolean arg0) {
+		this.sampleBuffers = arg0;
+	}
+
+	public boolean getSampleBuffers() {
+		return this.sampleBuffers;
+	}
+
+	public void setNumSamples(int arg0) {
+		this.numSamples = arg0;
+	}
+
+	public int getNumSamples() {
+		return this.numSamples;
+	}
+
+	public void setPbufferFloatingPointBuffers(boolean arg0) {
+		this.pbufferFloatingPointBuffers = arg0;
+	}
+
+	public String toString() {
+		return "GLCapabilities [DoubleBuffered: " + this.doubleBuffered + ", Stereo: " + this.stereo + ", HardwareAccelerated: " + this.hardwareAccelerated + ", DepthBits: " + this.depthBits + ", StencilBits: " + this.stencilBits + ", Red: " + this.redBits + ", Green: " + this.greenBits + ", Blue: " + this.blueBits + ", Alpha: " + this.alphaBits + ", Red Accum: " + this.accumRedBits + ", Green Accum: " + this.accumGreenBits + ", Blue Accum: " + this.accumBlueBits + ", Alpha Accum: " + this.accumAlphaBits + ", Multisample: " + this.sampleBuffers + (this.sampleBuffers ? ", Num samples: " + this.numSamples : "") + " ]";
+	}
+}

gl/src/main/java/javax/media/opengl/GLCapabilitiesChooser.java

@@ -0,0 +1,6 @@
+package javax.media.opengl;
+
+public interface GLCapabilitiesChooser {
+
+	int chooseCapabilities(GLCapabilities arg0, GLCapabilities[] arg1, int arg2);
+}

gl/src/main/java/javax/media/opengl/GLContext.java

@@ -0,0 +1,22 @@
+package javax.media.opengl;
+
+public abstract class GLContext {
+
+	private static GLContext currentContext;
+
+	public abstract int makeCurrent() throws GLException;
+
+	public abstract void release() throws GLException;
+
+	public static GLContext getCurrent() {
+		return currentContext;
+	}
+
+	protected static void setCurrent(GLContext arg0) {
+		currentContext = arg0;
+	}
+
+	public abstract void destroy();
+
+	public abstract GL getGL();
+}

gl/src/main/java/javax/media/opengl/GLDrawable.java

@@ -0,0 +1,10 @@
+package javax.media.opengl;
+
+public interface GLDrawable {
+
+	GLContext createContext(GLContext arg0);
+
+	void setRealized(boolean arg0);
+
+	void swapBuffers() throws GLException;
+}

gl/src/main/java/javax/media/opengl/GLDrawableFactory.java

@@ -0,0 +1,28 @@
+package javax.media.opengl;
+
+import com.sun.opengl.impl.macosx.MacOSXGLDrawableFactory;
+import com.sun.opengl.impl.windows.WindowsGLDrawableFactory;
+import com.sun.opengl.impl.x11.X11GLDrawableFactory;
+
+public abstract class GLDrawableFactory {
+
+	private static GLDrawableFactory factory;
+
+	public static GLDrawableFactory getFactory() {
+		if (factory == null) {
+			String var0 = System.getProperty("os.name").toLowerCase();
+			if (var0.startsWith("win")) {
+				factory = new WindowsGLDrawableFactory();
+			}
+			if (var0.startsWith("mac")) {
+				factory = new MacOSXGLDrawableFactory();
+			}
+			if (var0.startsWith("linux") || var0.startsWith("sunos")) {
+				factory = new X11GLDrawableFactory();
+			}
+		}
+		return factory;
+	}
+
+	public abstract GLDrawable getGLDrawable(Object arg0, GLCapabilities arg1, GLCapabilitiesChooser arg2) throws IllegalArgumentException, GLException;
+}

gl/src/main/java/javax/media/opengl/GLException.java

@@ -0,0 +1,15 @@
+package javax.media.opengl;
+
+public class GLException extends RuntimeException {
+
+	public GLException() {
+	}
+
+	public GLException(String arg0) {
+		super(arg0);
+	}
+
+	public GLException(Throwable arg0) {
+		super(arg0);
+	}
+}