initial

author: Grant Gayed <ggayed> 2003-07-10 20:41:12 +0000
committer: Grant Gayed <ggayed> 2003-07-10 20:41:12 +0000
commit: 2bffa3862a37be63a266d84772815ad0cccee5d1 (patch)
tree: 9a9d9850e027e6ba1bddb5cde89079cef035ed0a /bundles/org.eclipse.swt.opengl
parent: 949a243710db76895ae62e7e3836ee5ccd5921de (diff)
download: eclipse.platform.swt-2bffa3862a37be63a266d84772815ad0cccee5d1.tar.gz
eclipse.platform.swt-2bffa3862a37be63a266d84772815ad0cccee5d1.tar.xz
eclipse.platform.swt-2bffa3862a37be63a266d84772815ad0cccee5d1.zip
45 files changed, 9362 insertions, 0 deletions
diff --git a/bundles/org.eclipse.swt.opengl/.classpath_gtk b/bundles/org.eclipse.swt.opengl/.classpath_gtk
new file mode 100644
index 0000000000..35d4c3497a
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/.classpath_gtk
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+    <classpathentry kind="var" path="JRE_LIB" rootpath="JRE_SRCROOT" sourcepath="JRE_SRC"/>
+    <classpathentry kind="src" path="common"/>
+    <classpathentry kind="src" path="gtk"/>
+    <classpathentry kind="src" path="/org.eclipse.swt"/>
+    <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/bundles/org.eclipse.swt.opengl/.classpath_motif b/bundles/org.eclipse.swt.opengl/.classpath_motif
new file mode 100644
index 0000000000..6f974c1516
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/.classpath_motif
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+    <classpathentry kind="var" path="JRE_LIB" rootpath="JRE_SRCROOT" sourcepath="JRE_SRC"/>
+    <classpathentry kind="src" path="common"/>
+    <classpathentry kind="src" path="motif"/>
+    <classpathentry kind="src" path="/org.eclipse.swt"/>
+    <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/bundles/org.eclipse.swt.opengl/.classpath_win32 b/bundles/org.eclipse.swt.opengl/.classpath_win32
new file mode 100644
index 0000000000..30299c85da
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/.classpath_win32
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+    <classpathentry kind="var" path="JRE_LIB" rootpath="JRE_SRCROOT" sourcepath="JRE_SRC"/>
+    <classpathentry kind="src" path="common"/>
+    <classpathentry kind="src" path="win32"/>
+    <classpathentry kind="src" path="/org.eclipse.swt"/>
+    <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/bundles/org.eclipse.swt.opengl/.cvsignore b/bundles/org.eclipse.swt.opengl/.cvsignore
new file mode 100644
index 0000000000..661113b158
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/.cvsignore
@@ -0,0 +1,3 @@
+bin
+.classpath
+ws
diff --git a/bundles/org.eclipse.swt.opengl/.project b/bundles/org.eclipse.swt.opengl/.project
new file mode 100644
index 0000000000..577537ae64
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/.project
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.swt.opengl</name>
+	<comment></comment>
+	<projects>
+		<project>org.eclipse.swt</project>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.team.cvs.core.cvsnature</nature>
+	</natures>
+</projectDescription>
diff --git a/bundles/org.eclipse.swt.opengl/about.html b/bundles/org.eclipse.swt.opengl/about.html
new file mode 100644
index 0000000000..9db411aab9
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/about.html
@@ -0,0 +1,30 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
+<html>
+<head>
+<title>About</title>
+<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>20th June, 2002</p>	
+<h3>License</h3>
+<p>Eclipse.org makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
+Common Public License Version 1.0 (&quot;CPL&quot;).  A copy of the CPL is available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>.
+For purposes of the CPL, &quot;Program&quot; will mean the Content.</p>
+
+<h3>Contributions</h3>
+
+<p>If this Content is licensed to you under the terms and conditions of the CPL, any Contributions, as defined in the CPL, uploaded, submitted, or otherwise
+made available to Eclipse.org, members of Eclipse.org and/or the host of Eclipse.org web site, by you that relate to such
+Content are provided under the terms and conditions of the CPL and can be made available to others under the terms of the CPL.</p>
+
+<p>If this Content is licensed to you under license terms and conditions other than the CPL (&quot;Other License&quot;), any modifications, enhancements and/or
+other code and/or documentation (&quot;Modifications&quot;) uploaded, submitted, or otherwise made available to Eclipse.org, members of Eclipse.org and/or the
+host of Eclipse.org, by you that relate to such Content are provided under terms and conditions of the Other License and can be made available
+to others under the terms of the Other License.  In addition, with regard to Modifications for which you are the copyright holder, you are also
+providing the Modifications under the terms and conditions of the CPL and such Modifications can be made available to others under the terms of
+the CPL.</p>
+
+</body>
+</html>
+\ No newline at end of file
diff --git a/bundles/org.eclipse.swt.opengl/common/gl_library/gl.c b/bundles/org.eclipse.swt.opengl/common/gl_library/gl.c
new file mode 100644
index 0000000000..fac5d6a4a1
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/gl_library/gl.c
@@ -0,0 +1,3342 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include <GL/gl.h>
+#include "swt.h"
+
+#define GL_NATIVE(func) Java_org_eclipse_swt_opengl_GL_##func
+
+JNIEXPORT void JNICALL GL_NATIVE(glAccum)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	DEBUG_CALL("glAccum\n") 
+
+	glAccum(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glAlphaFunc)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	DEBUG_CALL("glAlphaFunc\n")
+
+	glAlphaFunc(arg0, arg1);
+}
+
+JNIEXPORT jboolean JNICALL GL_NATIVE(glAreTexturesResident)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jbooleanArray arg2)
+{
+	jint *lparg1=NULL;
+	jboolean *lparg2=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("glAreTexturesResident\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	if (arg2) lparg2 = (*env)->GetBooleanArrayElements(env, arg2, NULL);
+	rc = (jboolean)glAreTexturesResident(arg0, (unsigned int *)lparg1, lparg2);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	if (arg2) (*env)->ReleaseBooleanArrayElements(env, arg2, lparg2, 0);
+	return rc;
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glArrayElement)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glArrayElement\n")
+
+	glArrayElement(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glBegin)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glBegin\n")
+
+	glBegin(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glBindTexture)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glBindTexture\n")
+
+	glBindTexture(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glBitmap)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2, jfloat arg3, jfloat arg4, jfloat arg5, jbyteArray arg6)
+{
+	jbyte *lparg6=NULL;
+
+	DEBUG_CALL("glBitmap\n")
+
+	if (arg6) lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL);
+	glBitmap(arg0, arg1, arg2, arg3, arg4, arg5, (unsigned char *)lparg6);
+	if (arg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glBlendFunc)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glBlendFunc\n")
+
+	glBlendFunc(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glCallList)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glCallList\n")
+
+	glCallList(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3B)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jbyteArray arg2)
+{
+	jbyte *lparg2=NULL;
+
+	DEBUG_CALL("glCallLists__II_3B\n")
+
+	if (arg2) lparg2 = (*env)->GetByteArrayElements(env, arg2, NULL);
+	glCallLists(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseByteArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3C)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jcharArray arg2)
+{
+	jchar *lparg2=NULL;
+
+	DEBUG_CALL("glCallLists__II_3C\n")
+
+	if (arg2) lparg2 = (*env)->GetCharArrayElements(env, arg2, NULL);
+	glCallLists(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseCharArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glCallLists__II_3I)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glCallLists__II_3I\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glCallLists(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glClear)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glClear\n")
+
+	glClear(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glClearAccum)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	DEBUG_CALL("glClearAccum\n")
+
+	glClearAccum(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glClearColor)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	DEBUG_CALL("glClearColor\n")
+
+	glClearColor(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glClearDepth)
+	(JNIEnv *env, jclass that, jdouble arg0)
+{
+	DEBUG_CALL("glClearDepth\n")
+
+	glClearDepth(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glClearIndex)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	DEBUG_CALL("glClearIndex\n")
+
+	glClearIndex(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glClearStencil)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glClearStencil\n")
+
+	glClearStencil(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glClipPlane)
+	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)
+{
+	jdouble *lparg1=NULL;
+
+	DEBUG_CALL("glClipPlane\n")
+
+	if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
+	glClipPlane(arg0, lparg1);
+	if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3b)
+	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)
+{
+	DEBUG_CALL("glColor3b\n")
+
+	glColor3b(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3bv)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+
+	DEBUG_CALL("glColor3bv\n")
+
+	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	glColor3bv(lparg0);
+	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	DEBUG_CALL("glColor3d\n")
+
+	glColor3d(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glColor3dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glColor3dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	DEBUG_CALL("glColor3f\n")
+
+	glColor3f(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glColor3fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glColor3fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glColor3i\n")
+
+	glColor3i(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glColor3iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glColor3iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	DEBUG_CALL("glColor3s\n")
+
+	glColor3s(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3ub)
+	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)
+{
+	DEBUG_CALL("glColor3ub\n")
+
+	glColor3ub(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3ubv)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+
+	DEBUG_CALL("glColor3ubv\n")
+
+	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	glColor3ubv((unsigned char *)lparg0);
+	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3ui)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glColor3ui\n")
+
+	glColor3ui(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3uiv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glColor3uiv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glColor3uiv((unsigned int *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3us)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	DEBUG_CALL("glColor3us\n")
+
+	glColor3us(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor3usv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glColor3usv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glColor3usv((unsigned short *)lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4b)
+	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2, jbyte arg3)
+{
+	DEBUG_CALL("glColor4b\n")
+
+	glColor4b(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4bv)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+
+	DEBUG_CALL("glColor4bv\n")
+
+	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	glColor4bv(lparg0);
+	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	DEBUG_CALL("glColor4d\n")
+
+	glColor4d(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glColor4dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glColor4dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	DEBUG_CALL("glColor4f\n")
+
+	glColor4f(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glColor4fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glColor4fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("glColor4i\n")
+
+	glColor4i(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glColor4iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glColor4iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	DEBUG_CALL("glColor4s\n")
+
+	glColor4s(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4ub)
+	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2, jbyte arg3)
+{
+	DEBUG_CALL("glColor4ub\n")
+
+	glColor4ub(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4ubv)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+
+	DEBUG_CALL("glColor4ubv\n")
+
+	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	glColor4ubv((unsigned char *)lparg0);
+	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4ui)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("glColor4ui\n")
+
+	glColor4ui(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4uiv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glColor4uiv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glColor4uiv((unsigned int *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4us)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	DEBUG_CALL("glColor4us\n")
+
+	glColor4us(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColor4usv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glColor4usv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glColor4usv((unsigned short *)lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColorMask)
+	(JNIEnv *env, jclass that, jboolean arg0, jboolean arg1, jboolean arg2, jboolean arg3)
+{
+	DEBUG_CALL("glColorMask\n")
+
+	glColorMask(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColorMaterial)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glColorMaterial\n")
+
+	glColorMaterial(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glColorPointer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
+{
+	jint *lparg3=NULL;
+
+	DEBUG_CALL("glColorPointer\n")
+
+	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	glColorPointer(arg0, arg1, arg2, lparg3);
+	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glCopyPixels)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4)
+{
+	DEBUG_CALL("glCopyPixels\n")
+
+	glCopyPixels(arg0, arg1, arg2, arg3, arg4);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glCopyTexImage1D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6)
+{
+	DEBUG_CALL("glCopyTexImage1D\n")
+
+	glCopyTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glCopyTexImage2D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7)
+{
+	DEBUG_CALL("glCopyTexImage2D\n")
+
+	glCopyTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glCopyTexSubImage1D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5)
+{
+	DEBUG_CALL("glCopyTexSubImage1D\n")
+
+	glCopyTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glCopyTexSubImage2D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7)
+{
+	DEBUG_CALL("glCopyTexSubImage2D\n")
+
+	glCopyTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glCullFace)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glCullFace\n")
+
+	glCullFace(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDeleteLists)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glDeleteLists\n")
+
+	glDeleteLists(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDeleteTextures)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+
+	DEBUG_CALL("glDeleteTextures\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glDeleteTextures(arg0, (unsigned int *)lparg1);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDepthFunc)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glDepthFunc\n")
+
+	glDepthFunc(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDepthMask)
+	(JNIEnv *env, jclass that, jboolean arg0)
+{
+	DEBUG_CALL("glDepthMask\n")
+
+	glDepthMask(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDepthRange)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
+{
+	DEBUG_CALL("glDepthRange\n")
+
+	glDepthRange(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDisable)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glDisable\n")
+
+	glDisable(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDisableClientState)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glDisableClientState\n")
+
+	glDisableClientState(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDrawArrays)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glDrawArrays\n")
+
+	glDrawArrays(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDrawBuffer)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glDrawBuffer\n")
+
+	glDrawBuffer(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDrawElements)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
+{
+	jint *lparg3=NULL;
+
+	DEBUG_CALL("glDrawElements\n")
+
+	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	glDrawElements(arg0, arg1, arg2, lparg3);
+	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glDrawPixels)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)
+{
+	jint *lparg4=NULL;
+
+	DEBUG_CALL("glDrawPixels\n")
+
+	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
+	glDrawPixels(arg0, arg1, arg2, arg3, lparg4);
+	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlag)
+	(JNIEnv *env, jclass that, jboolean arg0)
+{
+	DEBUG_CALL("glEdgeFlag\n")
+
+	glEdgeFlag(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlagPointer)
+	(JNIEnv *env, jclass that, jint arg0, jbooleanArray arg1)
+{
+	jboolean *lparg1=NULL;
+
+	DEBUG_CALL("glEdgeFlagPointer\n")
+
+	if (arg1) lparg1 = (*env)->GetBooleanArrayElements(env, arg1, NULL);
+	glEdgeFlagPointer(arg0, lparg1);
+	if (arg1) (*env)->ReleaseBooleanArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEdgeFlagv)
+	(JNIEnv *env, jclass that, jbooleanArray arg0)
+{
+	jboolean *lparg0=NULL;
+
+	DEBUG_CALL("glEdgeFlagv\n")
+
+	if (arg0) lparg0 = (*env)->GetBooleanArrayElements(env, arg0, NULL);
+	glEdgeFlagv(lparg0);
+	if (arg0) (*env)->ReleaseBooleanArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEnable)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glEnable\n")
+
+	glEnable(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEnableClientState)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glEnableClientState\n")
+
+	glEnableClientState(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEnd)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glEnd\n")
+
+	glEnd();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEndList)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glEndList\n")
+
+	glEndList();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1d)
+	(JNIEnv *env, jclass that, jdouble arg0)
+{
+	DEBUG_CALL("glEvalCoord1d\n")
+
+	glEvalCoord1d(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glEvalCoord1dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glEvalCoord1dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1f)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	DEBUG_CALL("glEvalCoord1f\n")
+
+	glEvalCoord1f(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord1fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glEvalCoord1fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glEvalCoord1fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
+{
+	DEBUG_CALL("glEvalCoord2d\n")
+
+	glEvalCoord2d(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glEvalCoord2dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glEvalCoord2dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	DEBUG_CALL("glEvalCoord2f\n")
+
+	glEvalCoord2f(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalCoord2fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glEvalCoord2fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glEvalCoord2fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalMesh1)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glEvalMesh1\n")
+
+	glEvalMesh1(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalMesh2)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4)
+{
+	DEBUG_CALL("glEvalMesh2\n")
+
+	glEvalMesh2(arg0, arg1, arg2, arg3, arg4);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalPoint1)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glEvalPoint1\n")
+
+	glEvalPoint1(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glEvalPoint2)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glEvalPoint2\n")
+
+	glEvalPoint2(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glFeedbackBuffer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glFeedbackBuffer\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glFeedbackBuffer(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glFinish)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glFinish\n")
+
+	glFinish();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glFlush)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glFlush\n")
+
+	glFlush();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glFogf)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	DEBUG_CALL("glFogf\n")
+
+	glFogf(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glFogfv)
+	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
+{
+	jfloat *lparg1=NULL;
+
+	DEBUG_CALL("glFogfv\n")
+
+	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
+	glFogfv(arg0, lparg1);
+	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glFogi)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glFogi\n")
+
+	glFogi(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glFogiv)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+
+	DEBUG_CALL("glFogiv\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glFogiv(arg0, (GLint *)lparg1);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glFrontFace)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glFrontFace\n")
+
+	glFrontFace(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glFrustum)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5)
+{
+	DEBUG_CALL("glFrustum\n")
+
+	glFrustum(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+
+JNIEXPORT jint JNICALL GL_NATIVE(glGenLists)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glGenLists\n")
+
+	return (jint)glGenLists(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGenTextures)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+
+	DEBUG_CALL("glGenTextures\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glGenTextures(arg0, (unsigned int *)lparg1);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetBooleanv)
+	(JNIEnv *env, jclass that, jint arg0, jbooleanArray arg1)
+{
+	jboolean *lparg1=NULL;
+
+	DEBUG_CALL("glGetBooleanv\n")
+
+	if (arg1) lparg1 = (*env)->GetBooleanArrayElements(env, arg1, NULL);
+	glGetBooleanv(arg0, lparg1);
+	if (arg1) (*env)->ReleaseBooleanArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetClipPlane)
+	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)
+{
+	jdouble *lparg1=NULL;
+
+	DEBUG_CALL("glGetClipPlane\n")
+
+	if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
+	glGetClipPlane(arg0, lparg1);
+	if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetDoublev)
+	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1)
+{
+	jdouble *lparg1=NULL;
+
+	DEBUG_CALL("glGetDoublev\n")
+
+	if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
+	glGetDoublev(arg0, lparg1);
+	if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT jint JNICALL GL_NATIVE(glGetError)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glGetError\n")
+
+	return (jint)glGetError();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetFloatv)
+	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
+{
+	jfloat *lparg1=NULL;
+
+	DEBUG_CALL("glGetFloatv\n")
+
+	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
+	glGetFloatv(arg0, lparg1);
+	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetIntegerv)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+
+	DEBUG_CALL("glGetIntegerv\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glGetIntegerv(arg0, (GLint *)lparg1);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetLightfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glGetLightfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glGetLightfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetLightiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glGetLightiv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glGetLightiv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetMapdv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
+{
+	jdouble *lparg2=NULL;
+
+	DEBUG_CALL("glGetMapdv\n")
+
+	if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
+	glGetMapdv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetMapfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glGetMapfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glGetMapfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetMapiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glGetMapiv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glGetMapiv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetMaterialfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glGetMaterialfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glGetMaterialfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetMaterialiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glGetMaterialiv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glGetMaterialiv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapfv)
+	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
+{
+	jfloat *lparg1=NULL;
+
+	DEBUG_CALL("glGetPixelMapfv\n")
+
+	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
+	glGetPixelMapfv(arg0, lparg1);
+	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapuiv)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+
+	DEBUG_CALL("glGetPixelMapuiv\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glGetPixelMapuiv(arg0, (unsigned int *)lparg1);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetPixelMapusv)
+	(JNIEnv *env, jclass that, jint arg0, jshortArray arg1)
+{
+	jshort *lparg1=NULL;
+
+	DEBUG_CALL("glGetPixelMapusv\n")
+
+	if (arg1) lparg1 = (*env)->GetShortArrayElements(env, arg1, NULL);
+	glGetPixelMapusv(arg0, (unsigned short *)lparg1);
+	if (arg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetPointerv)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+
+	DEBUG_CALL("glGetPointerv\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glGetPointerv(arg0, (void **)lparg1);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetPolygonStipple)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+
+	DEBUG_CALL("glGetPolygonStipple\n")
+
+	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	glGetPolygonStipple((unsigned char *)lparg0);
+	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT jint JNICALL GL_NATIVE(glGetString)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glGetString\n")
+
+	printf ("%s,\n",glGetString(arg0));
+	return 1;
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexEnvfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glGetTexEnvfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glGetTexEnvfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexEnviv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glGetTexEnviv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glGetTexEnviv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexGendv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
+{
+	jdouble *lparg2=NULL;
+
+	DEBUG_CALL("glGetTexGendv\n")
+
+	if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
+	glGetTexGendv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexGenfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glGetTexGenfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glGetTexGenfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexGeniv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glGetTexGeniv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glGetTexGeniv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexImage)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)
+{
+	jint *lparg4=NULL;
+
+	DEBUG_CALL("glGetTexImage\n")
+
+	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
+	glGetTexImage(arg0, arg1, arg2, arg3, lparg4);
+	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexLevelParameterfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jfloatArray arg3)
+{
+	jfloat *lparg3=NULL;
+
+	DEBUG_CALL("glGetTexLevelParameterfv\n")
+
+	if (arg3) lparg3 = (*env)->GetFloatArrayElements(env, arg3, NULL);
+	glGetTexLevelParameterfv(arg0, arg1, arg2, lparg3);
+	if (arg3) (*env)->ReleaseFloatArrayElements(env, arg3, lparg3, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexLevelParameteriv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
+{
+	jint *lparg3=NULL;
+
+	DEBUG_CALL("glGetTexLevelParameteriv\n")
+
+	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	glGetTexLevelParameteriv(arg0, arg1, arg2, (GLint *)lparg3);
+	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexParameterfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glGetTexParameterfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glGetTexParameterfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glGetTexParameteriv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glGetTexParameteriv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glGetTexParameteriv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glHint)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glHint\n")
+
+	glHint(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glIndexMask)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glIndexMask\n")
+
+	glIndexMask(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glIndexPointer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glIndexPointer\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glIndexPointer(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glIndexd)
+	(JNIEnv *env, jclass that, jdouble arg0)
+{
+	DEBUG_CALL("glIndexd\n")
+
+	glIndexd(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glIndexdv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glIndexdv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glIndexdv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glIndexf)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	DEBUG_CALL("glIndexf\n")
+
+	glIndexf(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glIndexfv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glIndexfv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glIndexfv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glIndexi)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glIndexi\n")
+
+	glIndexi(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glIndexiv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glIndexiv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glIndexiv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glIndexs)
+	(JNIEnv *env, jclass that, jshort arg0)
+{
+	DEBUG_CALL("glIndexs\n")
+
+	glIndexs(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glIndexsv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glIndexsv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glIndexsv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glInitNames)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glInitNames\n")
+
+	glInitNames();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glInterleavedArrays)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glInterleavedArrays\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glInterleavedArrays(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT jboolean JNICALL GL_NATIVE(glIsEnabled)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glIsEnabled\n")
+
+	return (jboolean)glIsEnabled(arg0);
+}
+
+JNIEXPORT jboolean JNICALL GL_NATIVE(glIsList)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glIsList\n")
+
+	return (jboolean)glIsList(arg0);
+}
+
+JNIEXPORT jboolean JNICALL GL_NATIVE(glIsTexture)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glIsTexture\n")
+
+	return (jboolean)glIsTexture(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLightModelf)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	DEBUG_CALL("glLightModelf\n")
+
+	glLightModelf(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLightModelfv)
+	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1)
+{
+	jfloat *lparg1=NULL;
+
+	DEBUG_CALL("glLightModelfv\n")
+
+	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
+	glLightModelfv(arg0, lparg1);
+	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLightModeli)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glLightModeli\n")
+
+	glLightModeli(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLightModeliv)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+
+	DEBUG_CALL("glLightModeliv\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glLightModeliv(arg0, (GLint *)lparg1);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLightf)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	DEBUG_CALL("glLightf\n")
+
+	glLightf(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLightfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glLightfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glLightfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+/*
+JNIEXPORT void JNICALL GL_NATIVE(glLightfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat *arg2)
+{
+	DEBUG_CALL("glLightfv\n")
+	glLightfv(arg0, arg1, arg2);
+}
+*/
+JNIEXPORT void JNICALL GL_NATIVE(glLighti)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glLighti\n")
+
+	glLighti(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLightiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glLightiv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glLightiv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLineStipple)
+	(JNIEnv *env, jclass that, jint arg0, jshort arg1)
+{
+	DEBUG_CALL("glLineStipple\n")
+
+	glLineStipple(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLineWidth)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	DEBUG_CALL("glLineWidth\n")
+
+	glLineWidth(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glListBase)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glListBase\n")
+
+	glListBase(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLoadIdentity)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glLoadIdentity\n")
+
+	glLoadIdentity();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLoadMatrixd)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glLoadMatrixd\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glLoadMatrixd(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLoadMatrixf)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glLoadMatrixf\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glLoadMatrixf(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLoadName)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glLoadName\n")
+
+	glLoadName(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glLogicOp)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glLogicOp\n")
+
+	glLogicOp(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMap2f)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jint arg4,
+	  jfloat arg5, jfloat arg6, jint arg7, jint arg8, jfloatArray arg9)
+{
+	jfloat *lparg9=NULL;
+
+	DEBUG_CALL("glMap2f\n")
+
+	if (arg9) lparg9 = (*env)->GetFloatArrayElements(env, arg9, NULL);
+	glMap2f(arg0, arg1, arg2, arg3, arg4 ,arg5, arg6, arg7, arg8, lparg9);
+	if (arg9) (*env)->ReleaseFloatArrayElements(env, arg9, lparg9, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMap2d)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4,
+	  jdouble arg5, jdouble arg6, jint arg7, jint arg8, jdoubleArray arg9)
+{
+	jdouble *lparg9=NULL;
+
+	DEBUG_CALL("glMap2d\n")
+
+	if (arg9) lparg9 = (*env)->GetDoubleArrayElements(env, arg9, NULL);
+	glMap2d(arg0, arg1, arg2, arg3, arg4 ,arg5, arg6, arg7, arg8, lparg9);
+	if (arg9) (*env)->ReleaseDoubleArrayElements(env, arg9, lparg9, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMap1d)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jdoubleArray arg5)
+{
+	jdouble *lparg5=NULL;
+
+	DEBUG_CALL("glMap1d\n")
+
+	if (arg5) lparg5 = (*env)->GetDoubleArrayElements(env, arg5, NULL);
+	glMap1d(arg0, arg1, arg2, arg3, arg4, lparg5);
+	if (arg5) (*env)->ReleaseDoubleArrayElements(env, arg5, lparg5, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMap1f)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jint arg4, jfloatArray arg5)
+{
+	jfloat *lparg5=NULL;
+
+	DEBUG_CALL("glMap1f\n")
+
+	if (arg5) lparg5 = (*env)->GetFloatArrayElements(env, arg5, NULL);
+	glMap1f(arg0, arg1, arg2, arg3, arg4, lparg5);
+	if (arg5) (*env)->ReleaseFloatArrayElements(env, arg5, lparg5, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMapGrid1d)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2)
+{
+	DEBUG_CALL("glMapGrid1d\n")
+
+	glMapGrid1d(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMapGrid1f)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2)
+{
+	DEBUG_CALL("glMapGrid1f\n")
+
+	glMapGrid1f(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMapGrid2d)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jdouble arg4, jdouble arg5)
+{
+	DEBUG_CALL("glMapGrid2d\n")
+
+	glMapGrid2d(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMapGrid2f)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1, jfloat arg2, jint arg3, jfloat arg4, jfloat arg5)
+{
+	DEBUG_CALL("glMapGrid2f\n")
+
+	glMapGrid2f(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMaterialf)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	DEBUG_CALL("glMaterialf\n")
+
+	glMaterialf(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMaterialfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glMaterialfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glMaterialfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMateriali)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glMateriali\n")
+
+	glMateriali(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMaterialiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glMaterialiv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glMaterialiv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMatrixMode)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glMatrixMode\n")
+
+	glMatrixMode(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMultMatrixd)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glMultMatrixd\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glMultMatrixd(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glMultMatrixf)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glMultMatrixf\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glMultMatrixf(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNewList)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glNewList\n")
+
+	glNewList(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3b)
+	(JNIEnv *env, jclass that, jbyte arg0, jbyte arg1, jbyte arg2)
+{
+	DEBUG_CALL("glNormal3b\n")
+
+	glNormal3b(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3bv)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+
+	DEBUG_CALL("glNormal3bv\n")
+
+	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	glNormal3bv(lparg0);
+	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	DEBUG_CALL("glNormal3d\n")
+
+	glNormal3d(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glNormal3dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glNormal3dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	DEBUG_CALL("glNormal3f\n")
+
+	glNormal3f(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glNormal3fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glNormal3fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glNormal3i\n")
+
+	glNormal3i(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glNormal3iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glNormal3iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	DEBUG_CALL("glNormal3s\n")
+
+	glNormal3s(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormal3sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glNormal3sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glNormal3sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glNormalPointer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glNormalPointer\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glNormalPointer(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glOrtho)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5)
+{
+	DEBUG_CALL("glOrtho\n")
+
+	glOrtho(arg0, arg1, arg2, arg3, arg4, arg5);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPassThrough)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	DEBUG_CALL("glPassThrough\n")
+
+	glPassThrough(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPixelMapfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glPixelMapfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glPixelMapfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPixelMapuiv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glPixelMapuiv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glPixelMapuiv(arg0, arg1, (unsigned int *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPixelMapusv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jshortArray arg2)
+{
+	jshort *lparg2=NULL;
+
+	DEBUG_CALL("glPixelMapusv\n")
+
+	if (arg2) lparg2 = (*env)->GetShortArrayElements(env, arg2, NULL);
+	glPixelMapusv(arg0, arg1, (unsigned short *)lparg2);
+	if (arg2) (*env)->ReleaseShortArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPixelStoref)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	DEBUG_CALL("glPixelStoref\n")
+
+	glPixelStoref(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPixelStorei)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glPixelStorei\n")
+
+	glPixelStorei(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPixelTransferf)
+	(JNIEnv *env, jclass that, jint arg0, jfloat arg1)
+{
+	DEBUG_CALL("glPixelTransferf\n")
+
+	glPixelTransferf(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPixelTransferi)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glPixelTransferi\n")
+
+	glPixelTransferi(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPixelZoom)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	DEBUG_CALL("glPixelZoom\n")
+
+	glPixelZoom(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPointSize)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	DEBUG_CALL("glPointSize\n")
+
+	glPointSize(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPolygonMode)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glPolygonMode\n")
+
+	glPolygonMode(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPolygonOffset)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	DEBUG_CALL("glPolygonOffset\n")
+
+	glPolygonOffset(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPolygonStipple)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+
+	DEBUG_CALL("glPolygonStipple\n")
+
+	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	glPolygonStipple((unsigned char *)lparg0);
+	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPopAttrib)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glPopAttrib\n")
+
+	glPopAttrib();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPopClientAttrib)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glPopClientAttrib\n")
+
+	glPopClientAttrib();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPopMatrix)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glPopMatrix\n")
+
+	glPopMatrix();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPopName)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glPopName\n")
+
+	glPopName();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPrioritizeTextures)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jfloatArray arg2)
+{
+	jint *lparg1=NULL;
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glPrioritizeTextures\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glPrioritizeTextures(arg0, (unsigned int *)lparg1, lparg2);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPushAttrib)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glPushAttrib\n")
+
+	glPushAttrib(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPushClientAttrib)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glPushClientAttrib\n")
+
+	glPushClientAttrib(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPushMatrix)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glPushMatrix\n")
+
+	glPushMatrix();
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glPushName)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glPushName\n")
+
+	glPushName(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
+{
+	DEBUG_CALL("glRasterPos2d\n")
+
+	glRasterPos2d(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos2dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glRasterPos2dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	DEBUG_CALL("glRasterPos2f\n")
+
+	glRasterPos2f(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos2fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glRasterPos2fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glRasterPos2i\n")
+
+	glRasterPos2i(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos2iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glRasterPos2iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)
+{
+	DEBUG_CALL("glRasterPos2s\n")
+
+	glRasterPos2s(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos2sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos2sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glRasterPos2sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	DEBUG_CALL("glRasterPos3d\n")
+
+	glRasterPos3d(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos3dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glRasterPos3dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	DEBUG_CALL("glRasterPos3f\n")
+
+	glRasterPos3f(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos3fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glRasterPos3fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glRasterPos3i\n")
+
+	glRasterPos3i(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos3iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glRasterPos3iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	DEBUG_CALL("glRasterPos3s\n")
+
+	glRasterPos3s(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos3sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos3sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glRasterPos3sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	DEBUG_CALL("glRasterPos4d\n")
+
+	glRasterPos4d(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos4dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glRasterPos4dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	DEBUG_CALL("glRasterPos4f\n")
+
+	glRasterPos4f(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos4fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glRasterPos4fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("glRasterPos4i\n")
+
+	glRasterPos4i(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos4iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glRasterPos4iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	DEBUG_CALL("glRasterPos4s\n")
+
+	glRasterPos4s(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRasterPos4sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glRasterPos4sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glRasterPos4sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glReadBuffer)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glReadBuffer\n")
+
+	glReadBuffer(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glReadPixels)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jintArray arg6)
+{
+	jint *lparg6=NULL;
+
+	DEBUG_CALL("glReadPixels\n")
+
+	if (arg6) lparg6 = (*env)->GetIntArrayElements(env, arg6, NULL);
+	glReadPixels(arg0, arg1, arg2, arg3, arg4, arg5, lparg6);
+	if (arg6) (*env)->ReleaseIntArrayElements(env, arg6, lparg6, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRectd)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	DEBUG_CALL("glRectd\n")
+
+	glRectd(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRectdv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0, jdoubleArray arg1)
+{
+	jdouble *lparg0=NULL;
+	jdouble *lparg1=NULL;
+
+	DEBUG_CALL("glRectdv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
+	glRectdv(lparg0, lparg1);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+	if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRectf)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	DEBUG_CALL("glRectf\n")
+
+	glRectf(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRectfv)
+	(JNIEnv *env, jclass that, jfloatArray arg0, jfloatArray arg1)
+{
+	jfloat *lparg0=NULL;
+	jfloat *lparg1=NULL;
+
+	DEBUG_CALL("glRectfv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
+	glRectfv(lparg0, lparg1);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRecti)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("glRecti\n")
+
+	glRecti(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRectiv)
+	(JNIEnv *env, jclass that, jintArray arg0, jintArray arg1)
+{
+	jint *lparg0=NULL;
+	jint *lparg1=NULL;
+
+	DEBUG_CALL("glRectiv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glRectiv((GLint *)lparg0, (GLint *)lparg1);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRects)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	DEBUG_CALL("glRects\n")
+
+	glRects(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRectsv)
+	(JNIEnv *env, jclass that, jshortArray arg0, jshortArray arg1)
+{
+	jshort *lparg0=NULL;
+	jshort *lparg1=NULL;
+
+	DEBUG_CALL("glRectsv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	if (arg1) lparg1 = (*env)->GetShortArrayElements(env, arg1, NULL);
+	glRectsv(lparg0, lparg1);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+	if (arg1) (*env)->ReleaseShortArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT jint JNICALL GL_NATIVE(glRenderMode)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glRenderMode\n")
+
+	return (jint)glRenderMode(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRotated)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	DEBUG_CALL("glRotated\n")
+
+	glRotated(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glRotatef)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	DEBUG_CALL("glRotatef\n")
+
+	glRotatef(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glScaled)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	DEBUG_CALL("glScaled\n")
+
+	glScaled(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glScalef)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	DEBUG_CALL("glScalef\n")
+
+	glScalef(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glScissor)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("glScissor\n")
+
+	glScissor(arg0, arg1, arg2, arg3);
+}
+
+/*
+JNIEXPORT void JNICALL GL_NATIVE(glSelectBuffer)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1)
+{
+	jint *lparg1=NULL;
+
+	DEBUG_CALL("glSelectBuffer\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	glSelectBuffer(arg0, lparg1);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+}
+*/
+ 
+ 
+JNIEXPORT void JNICALL GL_NATIVE(glSelectBuffer)
+	(JNIEnv *env, jclass that, jint arg0, jint *arg1)
+{
+	DEBUG_CALL("glSelectBuffer\n")
+	glSelectBuffer(arg0, (unsigned int *)arg1);
+}
+
+
+JNIEXPORT void JNICALL GL_NATIVE(glShadeModel)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glShadeModel\n")
+
+	glShadeModel(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glStencilFunc)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glStencilFunc\n")
+
+	glStencilFunc(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glStencilMask)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glStencilMask\n")
+
+	glStencilMask(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glStencilOp)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glStencilOp\n")
+
+	glStencilOp(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1d)
+	(JNIEnv *env, jclass that, jdouble arg0)
+{
+	DEBUG_CALL("glTexCoord1d\n")
+
+	glTexCoord1d(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord1dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glTexCoord1dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1f)
+	(JNIEnv *env, jclass that, jfloat arg0)
+{
+	DEBUG_CALL("glTexCoord1f\n")
+
+	glTexCoord1f(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord1fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glTexCoord1fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1i)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glTexCoord1i\n")
+
+	glTexCoord1i(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord1iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glTexCoord1iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1s)
+	(JNIEnv *env, jclass that, jshort arg0)
+{
+	DEBUG_CALL("glTexCoord1s\n")
+
+	glTexCoord1s(arg0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord1sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord1sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glTexCoord1sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
+{
+	DEBUG_CALL("glTexCoord2d\n")
+
+	glTexCoord2d(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord2dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glTexCoord2dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	DEBUG_CALL("glTexCoord2f\n")
+
+	glTexCoord2f(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord2fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glTexCoord2fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glTexCoord2i\n")
+
+	glTexCoord2i(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord2iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glTexCoord2iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)
+{
+	DEBUG_CALL("glTexCoord2s\n")
+
+	glTexCoord2s(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord2sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord2sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glTexCoord2sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	DEBUG_CALL("glTexCoord3d\n")
+
+	glTexCoord3d(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord3dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glTexCoord3dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	DEBUG_CALL("glTexCoord3f\n")
+
+	glTexCoord3f(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord3fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glTexCoord3fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glTexCoord3i\n")
+
+	glTexCoord3i(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord3iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glTexCoord3iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	DEBUG_CALL("glTexCoord3s\n")
+
+	glTexCoord3s(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord3sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord3sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glTexCoord3sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	DEBUG_CALL("glTexCoord4d\n")
+
+	glTexCoord4d(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord4dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glTexCoord4dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	DEBUG_CALL("glTexCoord4f\n")
+
+	glTexCoord4f(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord4fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glTexCoord4fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("glTexCoord4i\n")
+
+	glTexCoord4i(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord4iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glTexCoord4iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	DEBUG_CALL("glTexCoord4s\n")
+
+	glTexCoord4s(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoord4sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glTexCoord4sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glTexCoord4sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexCoordPointer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
+{
+	jint *lparg3=NULL;
+
+	DEBUG_CALL("glTexCoordPointer\n")
+
+	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	glTexCoordPointer(arg0, arg1, arg2, lparg3);
+	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexEnvf)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	DEBUG_CALL("glTexEnvf\n")
+
+	glTexEnvf(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexEnvfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glTexEnvfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glTexEnvfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexEnvi)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glTexEnvi\n")
+
+	glTexEnvi(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexEnviv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glTexEnviv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glTexEnviv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexGend)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdouble arg2)
+{
+	DEBUG_CALL("glTexGend\n")
+
+	glTexGend(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexGendv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
+{
+	jdouble *lparg2=NULL;
+
+	DEBUG_CALL("glTexGendv\n")
+
+	if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
+	glTexGendv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexGenf)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	DEBUG_CALL("glTexGenf\n")
+
+	glTexGenf(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexGenfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glTexGenfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glTexGenfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexGeni)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glTexGeni\n")
+
+	glTexGeni(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexGeniv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glTexGeniv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glTexGeniv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexImage1D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jintArray arg7)
+{
+	jint *lparg7=NULL;
+
+	DEBUG_CALL("glTexImage1D\n")
+
+	if (arg7) lparg7 = (*env)->GetIntArrayElements(env, arg7, NULL);
+	glTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, lparg7);
+	if (arg7) (*env)->ReleaseIntArrayElements(env, arg7, lparg7, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexImage2D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jbyteArray arg8)
+{
+	jbyte *lparg8=NULL;
+
+	DEBUG_CALL("glTexImage2D\n")
+
+	if (arg8) lparg8 = (*env)->GetByteArrayElements(env, arg8, NULL);
+	glTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, lparg8);
+	if (arg8) (*env)->ReleaseByteArrayElements(env, arg8, lparg8, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexParameterf)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	DEBUG_CALL("glTexParameterf\n")
+
+	glTexParameterf(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexParameterfv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("glTexParameterfv\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	glTexParameterfv(arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexParameteri)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glTexParameteri\n")
+
+	glTexParameteri(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexParameteriv)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+
+	DEBUG_CALL("glTexParameteriv\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	glTexParameteriv(arg0, arg1, (GLint *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexSubImage1D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jintArray arg6)
+{
+	jint *lparg6=NULL;
+
+	DEBUG_CALL("glTexSubImage1D\n")
+
+	if (arg6) lparg6 = (*env)->GetIntArrayElements(env, arg6, NULL);
+	glTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5, lparg6);
+	if (arg6) (*env)->ReleaseIntArrayElements(env, arg6, lparg6, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTexSubImage2D)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jintArray arg8)
+{
+	jint *lparg8=NULL;
+
+	DEBUG_CALL("glTexSubImage2D\n")
+
+	if (arg8) lparg8 = (*env)->GetIntArrayElements(env, arg8, NULL);
+	glTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, lparg8);
+	if (arg8) (*env)->ReleaseIntArrayElements(env, arg8, lparg8, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTranslated)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	DEBUG_CALL("glTranslated\n")
+
+	glTranslated(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glTranslatef)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	DEBUG_CALL("glTranslatef\n")
+
+	glTranslatef(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1)
+{
+	DEBUG_CALL("glVertex2d\n")
+
+	glVertex2d(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glVertex2dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glVertex2dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1)
+{
+	DEBUG_CALL("glVertex2f\n")
+
+	glVertex2f(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glVertex2fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glVertex2fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glVertex2i\n")
+
+	glVertex2i(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glVertex2iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glVertex2iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1)
+{
+	DEBUG_CALL("glVertex2s\n")
+
+	glVertex2s(arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex2sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glVertex2sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glVertex2sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2)
+{
+	DEBUG_CALL("glVertex3d\n")
+
+	glVertex3d(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3dv__I)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glVertex3dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glVertex3dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3dv)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("glVertex3dv\n")
+	glVertex3dv((double*)arg0);
+
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2)
+{
+	DEBUG_CALL("glVertex3f\n")
+
+	glVertex3f(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glVertex3fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glVertex3fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glVertex3i\n")
+
+	glVertex3i(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glVertex3iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glVertex3iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2)
+{
+	DEBUG_CALL("glVertex3s\n")
+
+	glVertex3s(arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex3sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glVertex3sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glVertex3sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4d)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	DEBUG_CALL("glVertex4d\n")
+
+	glVertex4d(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4dv)
+	(JNIEnv *env, jclass that, jdoubleArray arg0)
+{
+	jdouble *lparg0=NULL;
+
+	DEBUG_CALL("glVertex4dv\n")
+
+	if (arg0) lparg0 = (*env)->GetDoubleArrayElements(env, arg0, NULL);
+	glVertex4dv(lparg0);
+	if (arg0) (*env)->ReleaseDoubleArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4f)
+	(JNIEnv *env, jclass that, jfloat arg0, jfloat arg1, jfloat arg2, jfloat arg3)
+{
+	DEBUG_CALL("glVertex4f\n")
+
+	glVertex4f(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4fv)
+	(JNIEnv *env, jclass that, jfloatArray arg0)
+{
+	jfloat *lparg0=NULL;
+
+	DEBUG_CALL("glVertex4fv\n")
+
+	if (arg0) lparg0 = (*env)->GetFloatArrayElements(env, arg0, NULL);
+	glVertex4fv(lparg0);
+	if (arg0) (*env)->ReleaseFloatArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4i)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("glVertex4i\n")
+
+	glVertex4i(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4iv)
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+
+	DEBUG_CALL("glVertex4iv\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	glVertex4iv((GLint *)lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4s)
+	(JNIEnv *env, jclass that, jshort arg0, jshort arg1, jshort arg2, jshort arg3)
+{
+	DEBUG_CALL("glVertex4s\n")
+
+	glVertex4s(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertex4sv)
+	(JNIEnv *env, jclass that, jshortArray arg0)
+{
+	jshort *lparg0=NULL;
+
+	DEBUG_CALL("glVertex4sv\n")
+
+	if (arg0) lparg0 = (*env)->GetShortArrayElements(env, arg0, NULL);
+	glVertex4sv(lparg0);
+	if (arg0) (*env)->ReleaseShortArrayElements(env, arg0, lparg0, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glVertexPointer)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jintArray arg3)
+{
+	jint *lparg3=NULL;
+
+	DEBUG_CALL("glVertexPointer\n")
+
+	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	glVertexPointer(arg0, arg1, arg2, lparg3);
+	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+}
+
+JNIEXPORT void JNICALL GL_NATIVE(glViewport)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("glViewport\n")
+
+	glViewport(arg0, arg1, arg2, arg3);
+}
diff --git a/bundles/org.eclipse.swt.opengl/common/gl_library/glu.c b/bundles/org.eclipse.swt.opengl/common/gl_library/glu.c
new file mode 100644
index 0000000000..b1d51689ac
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/gl_library/glu.c
@@ -0,0 +1,529 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+#ifdef WIN32
+#include <windows.h>
+#endif
+#include <GL/glu.h>
+#include "swt.h"
+
+#define GLU_NATIVE(func) Java_org_eclipse_swt_opengl_GLU_##func
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluBeginCurve)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluBeginCurve\n")
+
+	gluBeginCurve((GLUnurbsObj *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluBeginPolygon)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluBeginPolygon\n")
+
+	gluBeginPolygon((GLUtesselator *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluBeginSurface)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluBeginSurface\n")
+
+	gluBeginSurface((GLUnurbs *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluBeginTrim)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluBeginTrim\n")
+
+	gluBeginTrim((GLUnurbs *)arg0);
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluBuild1DMipmaps)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5)
+{
+	DEBUG_CALL("gluBuild1DMipmaps\n")
+
+	return (jint)gluBuild1DMipmaps(arg0, arg1, arg2, arg3, arg4, (const void *)arg5);
+}
+
+/*
+JNIEXPORT jint JNICALL GLU_NATIVE(gluBuild2DMipmaps)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6)
+{
+	DEBUG_CALL("gluBuild2DMipmaps\n")
+	
+	return (jint)gluBuild2DMipmaps(arg0, arg1, arg2, arg3, arg4, arg5, (const void *)arg6);
+}
+*/
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluBuild2DMipmaps)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jbyteArray arg6)
+{
+	jbyte *lparg6=NULL;
+	jint rc;
+	
+	DEBUG_CALL("gluBuild2DMipmaps\n")
+	if (arg6) lparg6 = (*env)->GetByteArrayElements(env, arg6, NULL);
+	rc = (jint)gluBuild2DMipmaps(arg0, arg1, arg2, arg3, arg4, arg5, (const void *)lparg6);
+	if (arg6) (*env)->ReleaseByteArrayElements(env, arg6, lparg6, 0);	
+	return rc;
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluCylinder)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jdouble arg3, jint arg4, jint arg5)
+{
+	DEBUG_CALL("gluCylinder\n")
+
+	gluCylinder((GLUquadric *)arg0, arg1, arg2, arg3, arg4, arg5);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteNurbsRenderer)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluDeleteNurbsRenderer\n")
+
+	gluDeleteNurbsRenderer((GLUnurbs *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteQuadric)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluDeleteQuadric\n")
+
+	gluDeleteQuadric((GLUquadric *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluDeleteTess)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluDeleteTess\n")
+
+	gluDeleteTess((GLUtesselator *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluDisk)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4)
+{
+	DEBUG_CALL("gluDisk\n")
+
+	gluDisk((GLUquadric *)arg0, arg1, arg2, arg3, arg4);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluEndCurve)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluEndCurve\n")
+
+	gluEndCurve((GLUnurbsObj *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluEndPolygon)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluEndPolygon\n")
+
+	gluEndPolygon((GLUtesselator *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluEndSurface)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluEndSurface\n")
+
+	gluEndSurface((GLUnurbs *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluEndTrim)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluEndTrim\n")
+
+	gluEndTrim((GLUnurbs *)arg0);
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluErrorString)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluErrorString\n")
+
+	return (jint)gluErrorString(arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluGetNurbsProperty)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("gluGetNurbsProperty\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	gluGetNurbsProperty((GLUnurbs *)arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluGetString)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluGetString\n")
+
+	return (jint)gluGetString(arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluGetTessProperty)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdoubleArray arg2)
+{
+	jdouble *lparg2=NULL;
+
+	DEBUG_CALL("gluGetTessProperty\n")
+
+	if (arg2) lparg2 = (*env)->GetDoubleArrayElements(env, arg2, NULL);
+	gluGetTessProperty((GLUtesselator *)arg0, arg1, lparg2);
+	if (arg2) (*env)->ReleaseDoubleArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluLoadSamplingMatrices)
+	(JNIEnv *env, jclass that, jint arg0, jfloatArray arg1, jfloatArray arg2, jintArray arg3)
+{
+	jfloat *lparg1=NULL;
+	jfloat *lparg2=NULL;
+	jint *lparg3=NULL;
+
+	DEBUG_CALL("gluLoadSamplingMatrices\n")
+
+	if (arg1) lparg1 = (*env)->GetFloatArrayElements(env, arg1, NULL);
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	gluLoadSamplingMatrices((GLUnurbs *)arg0, lparg1, lparg2, (GLint *)lparg3);
+	if (arg1) (*env)->ReleaseFloatArrayElements(env, arg1, lparg1, 0);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluLookAt)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jdouble arg4, jdouble arg5, jdouble arg6, jdouble arg7, jdouble arg8)
+{
+	DEBUG_CALL("gluLookAt\n")
+
+	gluLookAt(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluNewNurbsRenderer)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("gluNewNurbsRenderer\n")
+
+	return (jint)gluNewNurbsRenderer();
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluNewQuadric)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("gluNewQuadric\n")
+
+	return (jint)gluNewQuadric();
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluNewTess)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("gluNewTess\n")
+
+	return (jint)gluNewTess();
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluNextContour)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("gluNextContour\n")
+
+	gluNextContour((GLUtesselator *)arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsCallback)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("gluNurbsCallback\n")
+
+	gluNurbsCallback((GLUnurbs *)arg0, arg1, (GLvoid(*))arg2);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsCurve)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2, jint arg3, jfloatArray arg4, jint arg5, jint arg6)
+{
+	jfloat *lparg2=NULL;
+	jfloat *lparg4=NULL;
+
+	DEBUG_CALL("gluNurbsCurve\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	if (arg4) lparg4 = (*env)->GetFloatArrayElements(env, arg4, NULL);
+	gluNurbsCurve((GLUnurbs *)arg0, arg1, lparg2, arg3, lparg4, arg5, arg6);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+	if (arg4) (*env)->ReleaseFloatArrayElements(env, arg4, lparg4, 0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsProperty)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	DEBUG_CALL("gluNurbsProperty\n")
+
+	gluNurbsProperty((GLUnurbs *)arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluNurbsSurface)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2, jint arg3, jfloatArray arg4, jint arg5, jint arg6, jfloatArray arg7, jint arg8, jint arg9, jint arg10)
+{
+	jfloat *lparg2=NULL;
+	jfloat *lparg4=NULL;
+	jfloat *lparg7=NULL;
+
+	DEBUG_CALL("gluNurbsSurface\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	if (arg4) lparg4 = (*env)->GetFloatArrayElements(env, arg4, NULL);
+	if (arg7) lparg7 = (*env)->GetFloatArrayElements(env, arg7, NULL);
+	gluNurbsSurface((GLUnurbs *)arg0, arg1, lparg2, arg3, lparg4, arg5, arg6, lparg7, arg8, arg9, arg10);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+	if (arg4) (*env)->ReleaseFloatArrayElements(env, arg4, lparg4, 0);
+	if (arg7) (*env)->ReleaseFloatArrayElements(env, arg7, lparg7, 0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluOrtho2D)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	DEBUG_CALL("gluOrtho2D\n")
+
+	gluOrtho2D(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluPartialDisk)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jdouble arg5, jdouble arg6)
+{
+	DEBUG_CALL("gluPartialDisk\n")
+
+	gluPartialDisk((GLUquadric *)arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluPerspective)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	DEBUG_CALL("gluPerspective\n")
+
+	gluPerspective(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluPickMatrix)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdouble arg3, jintArray arg4)
+{
+	jint *lparg4=NULL;
+
+	DEBUG_CALL("gluPickMatrix\n")
+
+	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
+	gluPickMatrix(arg0, arg1, arg2, arg3, (GLint *)lparg4);
+	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluProject)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdoubleArray arg3, jdoubleArray arg4, jintArray arg5, jdoubleArray arg6, jdoubleArray arg7, jdoubleArray arg8)
+{
+	jdouble *lparg3=NULL;
+	jdouble *lparg4=NULL;
+	jint *lparg5=NULL;
+	jdouble *lparg6=NULL;
+	jdouble *lparg7=NULL;
+	jdouble *lparg8=NULL;
+	jint rc;
+
+	DEBUG_CALL("gluProject\n")
+
+	if (arg3) lparg3 = (*env)->GetDoubleArrayElements(env, arg3, NULL);
+	if (arg4) lparg4 = (*env)->GetDoubleArrayElements(env, arg4, NULL);
+	if (arg5) lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL);
+	if (arg6) lparg6 = (*env)->GetDoubleArrayElements(env, arg6, NULL);
+	if (arg7) lparg7 = (*env)->GetDoubleArrayElements(env, arg7, NULL);
+	if (arg8) lparg8 = (*env)->GetDoubleArrayElements(env, arg8, NULL);
+	rc = (jint)gluProject(arg0, arg1, arg2, lparg3, lparg4, (GLint *)lparg5, lparg6, lparg7, lparg8);
+	if (arg3) (*env)->ReleaseDoubleArrayElements(env, arg3, lparg3, 0);
+	if (arg4) (*env)->ReleaseDoubleArrayElements(env, arg4, lparg4, 0);
+	if (arg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
+	if (arg6) (*env)->ReleaseDoubleArrayElements(env, arg6, lparg6, 0);
+	if (arg7) (*env)->ReleaseDoubleArrayElements(env, arg7, lparg7, 0);
+	if (arg8) (*env)->ReleaseDoubleArrayElements(env, arg8, lparg8, 0);
+	return rc;
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluPwlCurve)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloatArray arg2, jint arg3, jint arg4)
+{
+	jfloat *lparg2=NULL;
+
+	DEBUG_CALL("gluPwlCurve\n")
+
+	if (arg2) lparg2 = (*env)->GetFloatArrayElements(env, arg2, NULL);
+	gluPwlCurve((GLUnurbs *)arg0, arg1, lparg2, arg3, arg4);
+	if (arg2) (*env)->ReleaseFloatArrayElements(env, arg2, lparg2, 0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricCallback)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("gluQuadricCallback\n")
+
+	gluQuadricCallback((GLUquadric *)arg0, arg1, (GLvoid(*))arg2);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricDrawStyle)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("gluQuadricDrawStyle\n")
+
+	gluQuadricDrawStyle((GLUquadric *)arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricNormals)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("gluQuadricNormals\n")
+
+	gluQuadricNormals((GLUquadric *)arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricOrientation)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("gluQuadricOrientation\n")
+
+	gluQuadricOrientation((GLUquadric *)arg0, arg1);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluQuadricTexture)
+	(JNIEnv *env, jclass that, jint arg0, jboolean arg1)
+{
+	DEBUG_CALL("gluQuadricTexture\n")
+
+	gluQuadricTexture((GLUquadric *)arg0, arg1);
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluScaleImage)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7, jint arg8)
+{
+	DEBUG_CALL("gluScaleImage\n")
+
+	return (jint)gluScaleImage(arg0, arg1, arg2, arg3, (const void *)arg4, arg5, arg6, arg7, (void *)arg8);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluSphere)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("gluSphere\n")
+
+	gluSphere((GLUquadric *)arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessBeginContour)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluTessBeginContour\n")
+
+	gluTessBeginContour((GLUtesselator *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessBeginPolygon)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("gluTessBeginPolygon\n")
+
+	gluTessBeginPolygon((GLUtesselator *)arg0, (void *)arg1);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessCallback)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("gluTessCallback\n")
+
+	gluTessCallback((GLUtesselator *)arg0, arg1, (GLvoid(*))arg2);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessEndContour)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluTessEndContour\n")
+
+	gluTessEndContour((GLUtesselator *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessEndPolygon)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gluTessEndPolygon\n")
+
+	gluTessEndPolygon((GLUtesselator *)arg0);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessNormal)
+	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jdouble arg3)
+{
+	DEBUG_CALL("gluTessNormal\n")
+
+	gluTessNormal((GLUtesselator *)arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessProperty)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jfloat arg2)
+{
+	DEBUG_CALL("gluTessProperty\n")
+
+	gluTessProperty((GLUtesselator *)arg0, arg1, arg2);
+}
+
+JNIEXPORT void JNICALL GLU_NATIVE(gluTessVertex)
+	(JNIEnv *env, jclass that, jint arg0, jdoubleArray arg1, jint arg2)
+{
+	jdouble *lparg1=NULL;
+
+	DEBUG_CALL("gluTessVertex\n")
+
+	if (arg1) lparg1 = (*env)->GetDoubleArrayElements(env, arg1, NULL);
+	gluTessVertex((GLUtesselator *)arg0, lparg1, (void *)arg2);
+	if (arg1) (*env)->ReleaseDoubleArrayElements(env, arg1, lparg1, 0);
+}
+
+JNIEXPORT jint JNICALL GLU_NATIVE(gluUnProject)
+	(JNIEnv *env, jclass that, jdouble arg0, jdouble arg1, jdouble arg2, jdoubleArray arg3, jdoubleArray arg4, jintArray arg5, jdoubleArray arg6, jdoubleArray arg7, jdoubleArray arg8)
+{
+	jdouble *lparg3=NULL;
+	jdouble *lparg4=NULL;
+	jint *lparg5=NULL;
+	jdouble *lparg6=NULL;
+	jdouble *lparg7=NULL;
+	jdouble *lparg8=NULL;
+	jint rc;
+
+	DEBUG_CALL("gluUnProject\n")
+
+	if (arg3) lparg3 = (*env)->GetDoubleArrayElements(env, arg3, NULL);
+	if (arg4) lparg4 = (*env)->GetDoubleArrayElements(env, arg4, NULL);
+	if (arg5) lparg5 = (*env)->GetIntArrayElements(env, arg5, NULL);
+	if (arg6) lparg6 = (*env)->GetDoubleArrayElements(env, arg6, NULL);
+	if (arg7) lparg7 = (*env)->GetDoubleArrayElements(env, arg7, NULL);
+	if (arg8) lparg8 = (*env)->GetDoubleArrayElements(env, arg8, NULL);
+	rc = (jint)gluUnProject(arg0, arg1, arg2, lparg3, lparg4, (GLint *)lparg5, lparg6, lparg7, lparg8);
+	if (arg3) (*env)->ReleaseDoubleArrayElements(env, arg3, lparg3, 0);
+	if (arg4) (*env)->ReleaseDoubleArrayElements(env, arg4, lparg4, 0);
+	if (arg5) (*env)->ReleaseIntArrayElements(env, arg5, lparg5, 0);
+	if (arg6) (*env)->ReleaseDoubleArrayElements(env, arg6, lparg6, 0);
+	if (arg7) (*env)->ReleaseDoubleArrayElements(env, arg7, lparg7, 0);
+	if (arg8) (*env)->ReleaseDoubleArrayElements(env, arg8, lparg8, 0);
+	return rc;
+}
diff --git a/bundles/org.eclipse.swt.opengl/common/gl_library/swt.h b/bundles/org.eclipse.swt.opengl/common/gl_library/swt.h
new file mode 100644
index 0000000000..4c6e704369
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/gl_library/swt.h
@@ -0,0 +1,47 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+
+#ifndef INC_swt_H
+#define INC_swt_H
+
+#include "jni.h"
+
+/* For debugging */
+#define DEBUG_PRINTF(x)
+/*#define DEBUG_PRINTF(x) printf x; */
+
+/* define this to print out debug statements */
+/* #define DEBUG_CALL_PRINTS */
+/* #define DEBUG_CHECK_NULL_EXCEPTIONS */
+
+#ifdef DEBUG_CALL_PRINTS
+#define DEBUG_CALL(func) fprintf(stderr, func);
+#else
+#define DEBUG_CALL(func)
+#endif
+
+#ifdef DEBUG_CHECK_NULL_EXCEPTIONS
+#define DEBUG_CHECK_NULL(env, address) \
+	if (address == 0) { \
+		jclass clazz = (*env)->FindClass(env, "org/eclipse/swt/SWTError"); \
+		if (clazz != NULL) { \
+			(*env)->ThrowNew(env, clazz, "Argument cannot be NULL"); \
+		} \
+		return; \
+	}
+#else
+#define DEBUG_CHECK_NULL(env, address)
+#endif
+
+#define DECL_GLOB(pSym)
+#define PGLOB(x) x
+
+#endif /* ifndef INC_swt_H */
diff --git a/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/GL.java b/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/GL.java
new file mode 100644
index 0000000000..ba4b372784
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/GL.java
@@ -0,0 +1,1449 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl;
+
+public class GL {
+
+	public static final int GL_VERSION_1_1 = 1;
+
+	/* AccumOp */
+	public static final int GL_ACCUM = 0x0100;
+	public static final int GL_LOAD = 0x0101;
+	public static final int GL_RETURN = 0x0102;
+	public static final int GL_MULT = 0x0103;
+	public static final int GL_ADD = 0x0104;
+
+	/* AlphaFunction */
+	public static final int GL_NEVER = 0x0200;
+	public static final int GL_LESS = 0x0201;
+	public static final int GL_EQUAL = 0x0202;
+	public static final int GL_LEQUAL = 0x0203;
+	public static final int GL_GREATER = 0x0204;
+	public static final int GL_NOTEQUAL = 0x0205;
+	public static final int GL_GEQUAL = 0x0206;
+	public static final int GL_ALWAYS = 0x0207;
+
+	/* AttribMask */
+	public static final int GL_CURRENT_BIT = 0x00000001;
+	public static final int GL_POINT_BIT = 0x00000002;
+	public static final int GL_LINE_BIT = 0x00000004;
+	public static final int GL_POLYGON_BIT = 0x00000008;
+	public static final int GL_POLYGON_STIPPLE_BIT = 0x00000010;
+	public static final int GL_PIXEL_MODE_BIT = 0x00000020;
+	public static final int GL_LIGHTING_BIT = 0x00000040;
+	public static final int GL_FOG_BIT = 0x00000080;
+	public static final int GL_DEPTH_BUFFER_BIT = 0x00000100;
+	public static final int GL_ACCUM_BUFFER_BIT = 0x00000200;
+	public static final int GL_STENCIL_BUFFER_BIT = 0x00000400;
+	public static final int GL_VIEWPORT_BIT = 0x00000800;
+	public static final int GL_TRANSFORM_BIT = 0x00001000;
+	public static final int GL_ENABLE_BIT = 0x00002000;
+	public static final int GL_COLOR_BUFFER_BIT = 0x00004000;
+	public static final int GL_HINT_BIT = 0x00008000;
+	public static final int GL_EVAL_BIT = 0x00010000;
+	public static final int GL_LIST_BIT = 0x00020000;
+	public static final int GL_TEXTURE_BIT = 0x00040000;
+	public static final int GL_SCISSOR_BIT = 0x00080000;
+	public static final int GL_ALL_ATTRIB_BITS = 0x000fffff;
+
+	/* BeginMode */
+	public static final int GL_POINTS = 0x0000;
+	public static final int GL_LINES = 0x0001;
+	public static final int GL_LINE_LOOP = 0x0002;
+	public static final int GL_LINE_STRIP = 0x0003;
+	public static final int GL_TRIANGLES = 0x0004;
+	public static final int GL_TRIANGLE_STRIP = 0x0005;
+	public static final int GL_TRIANGLE_FAN = 0x0006;
+	public static final int GL_QUADS = 0x0007;
+	public static final int GL_QUAD_STRIP = 0x0008;
+	public static final int GL_POLYGON = 0x0009;
+
+	/* BlendingFactorDest */
+	public static final int GL_ZERO = 0;
+	public static final int GL_ONE = 1;
+	public static final int GL_SRC_COLOR = 0x0300;
+	public static final int GL_ONE_MINUS_SRC_COLOR = 0x0301;
+	public static final int GL_SRC_ALPHA = 0x0302;
+	public static final int GL_ONE_MINUS_SRC_ALPHA = 0x0303;
+	public static final int GL_DST_ALPHA = 0x0304;
+	public static final int GL_ONE_MINUS_DST_ALPHA = 0x0305;
+
+	/* BlendingFactorSrc */
+	/*      GL_ZERO */
+	/*      GL_ONE */
+	public static final int GL_DST_COLOR = 0x0306;
+	public static final int GL_ONE_MINUS_DST_COLOR = 0x0307;
+	public static final int GL_SRC_ALPHA_SATURATE = 0x0308;
+	/*      GL_SRC_ALPHA */
+	/*      GL_ONE_MINUS_SRC_ALPHA */
+	/*      GL_DST_ALPHA */
+	/*      GL_ONE_MINUS_DST_ALPHA */
+
+	/* Boolean */
+	public static final int GL_TRUE = 1;
+	public static final int GL_FALSE = 0;
+
+	/* ClearBufferMask */
+	/*      GL_COLOR_BUFFER_BIT */
+	/*      GL_ACCUM_BUFFER_BIT */
+	/*      GL_STENCIL_BUFFER_BIT */
+	/*      GL_DEPTH_BUFFER_BIT */
+
+	/* ClientArrayType */
+	/*      GL_VERTEX_ARRAY */
+	/*      GL_NORMAL_ARRAY */
+	/*      GL_COLOR_ARRAY */
+	/*      GL_INDEX_ARRAY */
+	/*      GL_TEXTURE_COORD_ARRAY */
+	/*      GL_EDGE_FLAG_ARRAY */
+
+	/* ClipPlaneName */
+	public static final int GL_CLIP_PLANE0 = 0x3000;
+	public static final int GL_CLIP_PLANE1 = 0x3001;
+	public static final int GL_CLIP_PLANE2 = 0x3002;
+	public static final int GL_CLIP_PLANE3 = 0x3003;
+	public static final int GL_CLIP_PLANE4 = 0x3004;
+	public static final int GL_CLIP_PLANE5 = 0x3005;
+
+	/* ColorMaterialFace */
+	/*      GL_FRONT */
+	/*      GL_BACK */
+	/*      GL_FRONT_AND_BACK */
+
+	/* ColorMaterialParameter */
+	/*      GL_AMBIENT */
+	/*      GL_DIFFUSE */
+	/*      GL_SPECULAR */
+	/*      GL_EMISSION */
+	/*      GL_AMBIENT_AND_DIFFUSE */
+
+	/* ColorPointerType */
+	/*      GL_BYTE */
+	/*      GL_UNSIGNED_BYTE */
+	/*      GL_SHORT */
+	/*      GL_UNSIGNED_SHORT */
+	/*      GL_INT */
+	/*      GL_UNSIGNED_INT */
+	/*      GL_FLOAT */
+	/*      GL_DOUBLE */
+
+	/* CullFaceMode */
+	/*      GL_FRONT */
+	/*      GL_BACK */
+	/*      GL_FRONT_AND_BACK */
+
+	/* DataType */
+	public static final int GL_BYTE = 0x1400;
+	public static final int GL_UNSIGNED_BYTE = 0x1401;
+	public static final int GL_SHORT = 0x1402;
+	public static final int GL_UNSIGNED_SHORT = 0x1403;
+	public static final int GL_INT = 0x1404;
+	public static final int GL_UNSIGNED_INT = 0x1405;
+	public static final int GL_FLOAT = 0x1406;
+	public static final int GL_2_BYTES = 0x1407;
+	public static final int GL_3_BYTES = 0x1408;
+	public static final int GL_4_BYTES = 0x1409;
+	public static final int GL_DOUBLE = 0x140A;
+
+	/* DepthFunction */
+	/*      GL_NEVER */
+	/*      GL_LESS */
+	/*      GL_EQUAL */
+	/*      GL_LEQUAL */
+	/*      GL_GREATER */
+	/*      GL_NOTEQUAL */
+	/*      GL_GEQUAL */
+	/*      GL_ALWAYS */
+
+	/* DrawBufferMode */
+	public static final int GL_NONE = 0;
+	public static final int GL_FRONT_LEFT = 0x0400;
+	public static final int GL_FRONT_RIGHT = 0x0401;
+	public static final int GL_BACK_LEFT = 0x0402;
+	public static final int GL_BACK_RIGHT = 0x0403;
+	public static final int GL_FRONT = 0x0404;
+	public static final int GL_BACK = 0x0405;
+	public static final int GL_LEFT = 0x0406;
+	public static final int GL_RIGHT = 0x0407;
+	public static final int GL_FRONT_AND_BACK = 0x0408;
+	public static final int GL_AUX0 = 0x0409;
+	public static final int GL_AUX1 = 0x040A;
+	public static final int GL_AUX2 = 0x040B;
+	public static final int GL_AUX3 = 0x040C;
+
+	/* Enable */
+	/*      GL_FOG */
+	/*      GL_LIGHTING */
+	/*      GL_TEXTURE_1D */
+	/*      GL_TEXTURE_2D */
+	/*      GL_LINE_STIPPLE */
+	/*      GL_POLYGON_STIPPLE */
+	/*      GL_CULL_FACE */
+	/*      GL_ALPHA_TEST */
+	/*      GL_BLEND */
+	/*      GL_INDEX_LOGIC_OP */
+	/*      GL_COLOR_LOGIC_OP */
+	/*      GL_DITHER */
+	/*      GL_STENCIL_TEST */
+	/*      GL_DEPTH_TEST */
+	/*      GL_CLIP_PLANE0 */
+	/*      GL_CLIP_PLANE1 */
+	/*      GL_CLIP_PLANE2 */
+	/*      GL_CLIP_PLANE3 */
+	/*      GL_CLIP_PLANE4 */
+	/*      GL_CLIP_PLANE5 */
+	/*      GL_LIGHT0 */
+	/*      GL_LIGHT1 */
+	/*      GL_LIGHT2 */
+	/*      GL_LIGHT3 */
+	/*      GL_LIGHT4 */
+	/*      GL_LIGHT5 */
+	/*      GL_LIGHT6 */
+	/*      GL_LIGHT7 */
+	/*      GL_TEXTURE_GEN_S */
+	/*      GL_TEXTURE_GEN_T */
+	/*      GL_TEXTURE_GEN_R */
+	/*      GL_TEXTURE_GEN_Q */
+	/*      GL_MAP1_VERTEX_3 */
+	/*      GL_MAP1_VERTEX_4 */
+	/*      GL_MAP1_COLOR_4 */
+	/*      GL_MAP1_INDEX */
+	/*      GL_MAP1_NORMAL */
+	/*      GL_MAP1_TEXTURE_COORD_1 */
+	/*      GL_MAP1_TEXTURE_COORD_2 */
+	/*      GL_MAP1_TEXTURE_COORD_3 */
+	/*      GL_MAP1_TEXTURE_COORD_4 */
+	/*      GL_MAP2_VERTEX_3 */
+	/*      GL_MAP2_VERTEX_4 */
+	/*      GL_MAP2_COLOR_4 */
+	/*      GL_MAP2_INDEX */
+	/*      GL_MAP2_NORMAL */
+	/*      GL_MAP2_TEXTURE_COORD_1 */
+	/*      GL_MAP2_TEXTURE_COORD_2 */
+	/*      GL_MAP2_TEXTURE_COORD_3 */
+	/*      GL_MAP2_TEXTURE_COORD_4 */
+	/*      GL_POINT_SMOOTH */
+	/*      GL_LINE_SMOOTH */
+	/*      GL_POLYGON_SMOOTH */
+	/*      GL_SCISSOR_TEST */
+	/*      GL_COLOR_MATERIAL */
+	/*      GL_NORMALIZE */
+	/*      GL_AUTO_NORMAL */
+	/*      GL_VERTEX_ARRAY */
+	/*      GL_NORMAL_ARRAY */
+	/*      GL_COLOR_ARRAY */
+	/*      GL_INDEX_ARRAY */
+	/*      GL_TEXTURE_COORD_ARRAY */
+	/*      GL_EDGE_FLAG_ARRAY */
+	/*      GL_POLYGON_OFFSET_POINT */
+	/*      GL_POLYGON_OFFSET_LINE */
+	/*      GL_POLYGON_OFFSET_FILL */
+
+	/* ErrorCode */
+	public static final int GL_NO_ERROR = 0;
+	public static final int GL_INVALID_ENUM = 0x0500;
+	public static final int GL_INVALID_VALUE = 0x0501;
+	public static final int GL_INVALID_OPERATION = 0x0502;
+	public static final int GL_STACK_OVERFLOW = 0x0503;
+	public static final int GL_STACK_UNDERFLOW = 0x0504;
+	public static final int GL_OUT_OF_MEMORY = 0x0505;
+
+	/* FeedBackMode */
+	public static final int GL_2D = 0x0600;
+	public static final int GL_3D = 0x0601;
+	public static final int GL_3D_COLOR = 0x0602;
+	public static final int GL_3D_COLOR_TEXTURE = 0x0603;
+	public static final int GL_4D_COLOR_TEXTURE = 0x0604;
+
+	/* FeedBackToken */
+	public static final int GL_PASS_THROUGH_TOKEN = 0x0700;
+	public static final int GL_POINT_TOKEN = 0x0701;
+	public static final int GL_LINE_TOKEN = 0x0702;
+	public static final int GL_POLYGON_TOKEN = 0x0703;
+	public static final int GL_BITMAP_TOKEN = 0x0704;
+	public static final int GL_DRAW_PIXEL_TOKEN = 0x0705;
+	public static final int GL_COPY_PIXEL_TOKEN = 0x0706;
+	public static final int GL_LINE_RESET_TOKEN = 0x0707;
+
+	/* FogMode */
+	/*      GL_LINEAR */
+	public static final int GL_EXP = 0x0800;
+	public static final int GL_EXP2 = 0x0801;
+
+	/* FogParameter */
+	/*      GL_FOG_COLOR */
+	/*      GL_FOG_DENSITY */
+	/*      GL_FOG_END */
+	/*      GL_FOG_INDEX */
+	/*      GL_FOG_MODE */
+	/*      GL_FOG_START */
+
+	/* FrontFaceDirection */
+	public static final int GL_CW = 0x0900;
+	public static final int GL_CCW = 0x0901;
+
+	/* GetMapTarget */
+	public static final int GL_COEFF = 0x0A00;
+	public static final int GL_ORDER = 0x0A01;
+	public static final int GL_DOMAIN = 0x0A02;
+
+	/* GetPixelMap */
+	/*      GL_PIXEL_MAP_I_TO_I */
+	/*      GL_PIXEL_MAP_S_TO_S */
+	/*      GL_PIXEL_MAP_I_TO_R */
+	/*      GL_PIXEL_MAP_I_TO_G */
+	/*      GL_PIXEL_MAP_I_TO_B */
+	/*      GL_PIXEL_MAP_I_TO_A */
+	/*      GL_PIXEL_MAP_R_TO_R */
+	/*      GL_PIXEL_MAP_G_TO_G */
+	/*      GL_PIXEL_MAP_B_TO_B */
+	/*      GL_PIXEL_MAP_A_TO_A */
+
+	/* GetPointerTarget */
+	/*      GL_VERTEX_ARRAY_POINTER */
+	/*      GL_NORMAL_ARRAY_POINTER */
+	/*      GL_COLOR_ARRAY_POINTER */
+	/*      GL_INDEX_ARRAY_POINTER */
+	/*      GL_TEXTURE_COORD_ARRAY_POINTER */
+	/*      GL_EDGE_FLAG_ARRAY_POINTER */
+
+	/* GetTarget */
+	public static final int GL_CURRENT_COLOR = 0x0B00;
+	public static final int GL_CURRENT_INDEX = 0x0B01;
+	public static final int GL_CURRENT_NORMAL = 0x0B02;
+	public static final int GL_CURRENT_TEXTURE_COORDS = 0x0B03;
+	public static final int GL_CURRENT_RASTER_COLOR = 0x0B04;
+	public static final int GL_CURRENT_RASTER_INDEX = 0x0B05;
+	public static final int GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06;
+	public static final int GL_CURRENT_RASTER_POSITION = 0x0B07;
+	public static final int GL_CURRENT_RASTER_POSITION_VALID = 0x0B08;
+	public static final int GL_CURRENT_RASTER_DISTANCE = 0x0B09;
+	public static final int GL_POINT_SMOOTH = 0x0B10;
+	public static final int GL_POINT_SIZE = 0x0B11;
+	public static final int GL_POINT_SIZE_RANGE = 0x0B12;
+	public static final int GL_POINT_SIZE_GRANULARITY = 0x0B13;
+	public static final int GL_LINE_SMOOTH = 0x0B20;
+	public static final int GL_LINE_WIDTH = 0x0B21;
+	public static final int GL_LINE_WIDTH_RANGE = 0x0B22;
+	public static final int GL_LINE_WIDTH_GRANULARITY = 0x0B23;
+	public static final int GL_LINE_STIPPLE = 0x0B24;
+	public static final int GL_LINE_STIPPLE_PATTERN = 0x0B25;
+	public static final int GL_LINE_STIPPLE_REPEAT = 0x0B26;
+	public static final int GL_LIST_MODE = 0x0B30;
+	public static final int GL_MAX_LIST_NESTING = 0x0B31;
+	public static final int GL_LIST_BASE = 0x0B32;
+	public static final int GL_LIST_INDEX = 0x0B33;
+	public static final int GL_POLYGON_MODE = 0x0B40;
+	public static final int GL_POLYGON_SMOOTH = 0x0B41;
+	public static final int GL_POLYGON_STIPPLE = 0x0B42;
+	public static final int GL_EDGE_FLAG = 0x0B43;
+	public static final int GL_CULL_FACE = 0x0B44;
+	public static final int GL_CULL_FACE_MODE = 0x0B45;
+	public static final int GL_FRONT_FACE = 0x0B46;
+	public static final int GL_LIGHTING = 0x0B50;
+	public static final int GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51;
+	public static final int GL_LIGHT_MODEL_TWO_SIDE = 0x0B52;
+	public static final int GL_LIGHT_MODEL_AMBIENT = 0x0B53;
+	public static final int GL_SHADE_MODEL = 0x0B54;
+	public static final int GL_COLOR_MATERIAL_FACE = 0x0B55;
+	public static final int GL_COLOR_MATERIAL_PARAMETER = 0x0B56;
+	public static final int GL_COLOR_MATERIAL = 0x0B57;
+	public static final int GL_FOG = 0x0B60;
+	public static final int GL_FOG_INDEX = 0x0B61;
+	public static final int GL_FOG_DENSITY = 0x0B62;
+	public static final int GL_FOG_START = 0x0B63;
+	public static final int GL_FOG_END = 0x0B64;
+	public static final int GL_FOG_MODE = 0x0B65;
+	public static final int GL_FOG_COLOR = 0x0B66;
+	public static final int GL_DEPTH_RANGE = 0x0B70;
+	public static final int GL_DEPTH_TEST = 0x0B71;
+	public static final int GL_DEPTH_WRITEMASK = 0x0B72;
+	public static final int GL_DEPTH_CLEAR_VALUE = 0x0B73;
+	public static final int GL_DEPTH_FUNC = 0x0B74;
+	public static final int GL_ACCUM_CLEAR_VALUE = 0x0B80;
+	public static final int GL_STENCIL_TEST = 0x0B90;
+	public static final int GL_STENCIL_CLEAR_VALUE = 0x0B91;
+	public static final int GL_STENCIL_FUNC = 0x0B92;
+	public static final int GL_STENCIL_VALUE_MASK = 0x0B93;
+	public static final int GL_STENCIL_FAIL = 0x0B94;
+	public static final int GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95;
+	public static final int GL_STENCIL_PASS_DEPTH_PASS = 0x0B96;
+	public static final int GL_STENCIL_REF = 0x0B97;
+	public static final int GL_STENCIL_WRITEMASK = 0x0B98;
+	public static final int GL_MATRIX_MODE = 0x0BA0;
+	public static final int GL_NORMALIZE = 0x0BA1;
+	public static final int GL_VIEWPORT = 0x0BA2;
+	public static final int GL_MODELVIEW_STACK_DEPTH = 0x0BA3;
+	public static final int GL_PROJECTION_STACK_DEPTH = 0x0BA4;
+	public static final int GL_TEXTURE_STACK_DEPTH = 0x0BA5;
+	public static final int GL_MODELVIEW_MATRIX = 0x0BA6;
+	public static final int GL_PROJECTION_MATRIX = 0x0BA7;
+	public static final int GL_TEXTURE_MATRIX = 0x0BA8;
+	public static final int GL_ATTRIB_STACK_DEPTH = 0x0BB0;
+	public static final int GL_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1;
+	public static final int GL_ALPHA_TEST = 0x0BC0;
+	public static final int GL_ALPHA_TEST_FUNC = 0x0BC1;
+	public static final int GL_ALPHA_TEST_REF = 0x0BC2;
+	public static final int GL_DITHER = 0x0BD0;
+	public static final int GL_BLEND_DST = 0x0BE0;
+	public static final int GL_BLEND_SRC = 0x0BE1;
+	public static final int GL_BLEND = 0x0BE2;
+	public static final int GL_LOGIC_OP_MODE = 0x0BF0;
+	public static final int GL_INDEX_LOGIC_OP = 0x0BF1;
+	public static final int GL_COLOR_LOGIC_OP = 0x0BF2;
+	public static final int GL_AUX_BUFFERS = 0x0C00;
+	public static final int GL_DRAW_BUFFER = 0x0C01;
+	public static final int GL_READ_BUFFER = 0x0C02;
+	public static final int GL_SCISSOR_BOX = 0x0C10;
+	public static final int GL_SCISSOR_TEST = 0x0C11;
+	public static final int GL_INDEX_CLEAR_VALUE = 0x0C20;
+	public static final int GL_INDEX_WRITEMASK = 0x0C21;
+	public static final int GL_COLOR_CLEAR_VALUE = 0x0C22;
+	public static final int GL_COLOR_WRITEMASK = 0x0C23;
+	public static final int GL_INDEX_MODE = 0x0C30;
+	public static final int GL_RGBA_MODE = 0x0C31;
+	public static final int GL_DOUBLEBUFFER = 0x0C32;
+	public static final int GL_STEREO = 0x0C33;
+	public static final int GL_RENDER_MODE = 0x0C40;
+	public static final int GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50;
+	public static final int GL_POINT_SMOOTH_HINT = 0x0C51;
+	public static final int GL_LINE_SMOOTH_HINT = 0x0C52;
+	public static final int GL_POLYGON_SMOOTH_HINT = 0x0C53;
+	public static final int GL_FOG_HINT = 0x0C54;
+	public static final int GL_TEXTURE_GEN_S = 0x0C60;
+	public static final int GL_TEXTURE_GEN_T = 0x0C61;
+	public static final int GL_TEXTURE_GEN_R = 0x0C62;
+	public static final int GL_TEXTURE_GEN_Q = 0x0C63;
+	public static final int GL_PIXEL_MAP_I_TO_I = 0x0C70;
+	public static final int GL_PIXEL_MAP_S_TO_S = 0x0C71;
+	public static final int GL_PIXEL_MAP_I_TO_R = 0x0C72;
+	public static final int GL_PIXEL_MAP_I_TO_G = 0x0C73;
+	public static final int GL_PIXEL_MAP_I_TO_B = 0x0C74;
+	public static final int GL_PIXEL_MAP_I_TO_A = 0x0C75;
+	public static final int GL_PIXEL_MAP_R_TO_R = 0x0C76;
+	public static final int GL_PIXEL_MAP_G_TO_G = 0x0C77;
+	public static final int GL_PIXEL_MAP_B_TO_B = 0x0C78;
+	public static final int GL_PIXEL_MAP_A_TO_A = 0x0C79;
+	public static final int GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0;
+	public static final int GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1;
+	public static final int GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2;
+	public static final int GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3;
+	public static final int GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4;
+	public static final int GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5;
+	public static final int GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6;
+	public static final int GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7;
+	public static final int GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8;
+	public static final int GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9;
+	public static final int GL_UNPACK_SWAP_BYTES = 0x0CF0;
+	public static final int GL_UNPACK_LSB_FIRST = 0x0CF1;
+	public static final int GL_UNPACK_ROW_LENGTH = 0x0CF2;
+	public static final int GL_UNPACK_SKIP_ROWS = 0x0CF3;
+	public static final int GL_UNPACK_SKIP_PIXELS = 0x0CF4;
+	public static final int GL_UNPACK_ALIGNMENT = 0x0CF5;
+	public static final int GL_PACK_SWAP_BYTES = 0x0D00;
+	public static final int GL_PACK_LSB_FIRST = 0x0D01;
+	public static final int GL_PACK_ROW_LENGTH = 0x0D02;
+	public static final int GL_PACK_SKIP_ROWS = 0x0D03;
+	public static final int GL_PACK_SKIP_PIXELS = 0x0D04;
+	public static final int GL_PACK_ALIGNMENT = 0x0D05;
+	public static final int GL_MAP_COLOR = 0x0D10;
+	public static final int GL_MAP_STENCIL = 0x0D11;
+	public static final int GL_INDEX_SHIFT = 0x0D12;
+	public static final int GL_INDEX_OFFSET = 0x0D13;
+	public static final int GL_RED_SCALE = 0x0D14;
+	public static final int GL_RED_BIAS = 0x0D15;
+	public static final int GL_ZOOM_X = 0x0D16;
+	public static final int GL_ZOOM_Y = 0x0D17;
+	public static final int GL_GREEN_SCALE = 0x0D18;
+	public static final int GL_GREEN_BIAS = 0x0D19;
+	public static final int GL_BLUE_SCALE = 0x0D1A;
+	public static final int GL_BLUE_BIAS = 0x0D1B;
+	public static final int GL_ALPHA_SCALE = 0x0D1C;
+	public static final int GL_ALPHA_BIAS = 0x0D1D;
+	public static final int GL_DEPTH_SCALE = 0x0D1E;
+	public static final int GL_DEPTH_BIAS = 0x0D1F;
+	public static final int GL_MAX_EVAL_ORDER = 0x0D30;
+	public static final int GL_MAX_LIGHTS = 0x0D31;
+	public static final int GL_MAX_CLIP_PLANES = 0x0D32;
+	public static final int GL_MAX_TEXTURE_SIZE = 0x0D33;
+	public static final int GL_MAX_PIXEL_MAP_TABLE = 0x0D34;
+	public static final int GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35;
+	public static final int GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36;
+	public static final int GL_MAX_NAME_STACK_DEPTH = 0x0D37;
+	public static final int GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38;
+	public static final int GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39;
+	public static final int GL_MAX_VIEWPORT_DIMS = 0x0D3A;
+	public static final int GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B;
+	public static final int GL_SUBPIXEL_BITS = 0x0D50;
+	public static final int GL_INDEX_BITS = 0x0D51;
+	public static final int GL_RED_BITS = 0x0D52;
+	public static final int GL_GREEN_BITS = 0x0D53;
+	public static final int GL_BLUE_BITS = 0x0D54;
+	public static final int GL_ALPHA_BITS = 0x0D55;
+	public static final int GL_DEPTH_BITS = 0x0D56;
+	public static final int GL_STENCIL_BITS = 0x0D57;
+	public static final int GL_ACCUM_RED_BITS = 0x0D58;
+	public static final int GL_ACCUM_GREEN_BITS = 0x0D59;
+	public static final int GL_ACCUM_BLUE_BITS = 0x0D5A;
+	public static final int GL_ACCUM_ALPHA_BITS = 0x0D5B;
+	public static final int GL_NAME_STACK_DEPTH = 0x0D70;
+	public static final int GL_AUTO_NORMAL = 0x0D80;
+	public static final int GL_MAP1_COLOR_4 = 0x0D90;
+	public static final int GL_MAP1_INDEX = 0x0D91;
+	public static final int GL_MAP1_NORMAL = 0x0D92;
+	public static final int GL_MAP1_TEXTURE_COORD_1 = 0x0D93;
+	public static final int GL_MAP1_TEXTURE_COORD_2 = 0x0D94;
+	public static final int GL_MAP1_TEXTURE_COORD_3 = 0x0D95;
+	public static final int GL_MAP1_TEXTURE_COORD_4 = 0x0D96;
+	public static final int GL_MAP1_VERTEX_3 = 0x0D97;
+	public static final int GL_MAP1_VERTEX_4 = 0x0D98;
+	public static final int GL_MAP2_COLOR_4 = 0x0DB0;
+	public static final int GL_MAP2_INDEX = 0x0DB1;
+	public static final int GL_MAP2_NORMAL = 0x0DB2;
+	public static final int GL_MAP2_TEXTURE_COORD_1 = 0x0DB3;
+	public static final int GL_MAP2_TEXTURE_COORD_2 = 0x0DB4;
+	public static final int GL_MAP2_TEXTURE_COORD_3 = 0x0DB5;
+	public static final int GL_MAP2_TEXTURE_COORD_4 = 0x0DB6;
+	public static final int GL_MAP2_VERTEX_3 = 0x0DB7;
+	public static final int GL_MAP2_VERTEX_4 = 0x0DB8;
+	public static final int GL_MAP1_GRID_DOMAIN = 0x0DD0;
+	public static final int GL_MAP1_GRID_SEGMENTS = 0x0DD1;
+	public static final int GL_MAP2_GRID_DOMAIN = 0x0DD2;
+	public static final int GL_MAP2_GRID_SEGMENTS = 0x0DD3;
+	public static final int GL_TEXTURE_1D = 0x0DE0;
+	public static final int GL_TEXTURE_2D = 0x0DE1;
+	public static final int GL_FEEDBACK_BUFFER_POINTER = 0x0DF0;
+	public static final int GL_FEEDBACK_BUFFER_SIZE = 0x0DF1;
+	public static final int GL_FEEDBACK_BUFFER_TYPE = 0x0DF2;
+	public static final int GL_SELECTION_BUFFER_POINTER = 0x0DF3;
+	public static final int GL_SELECTION_BUFFER_SIZE = 0x0DF4;
+	/*      GL_TEXTURE_BINDING_1D */
+	/*      GL_TEXTURE_BINDING_2D */
+	/*      GL_VERTEX_ARRAY */
+	/*      GL_NORMAL_ARRAY */
+	/*      GL_COLOR_ARRAY */
+	/*      GL_INDEX_ARRAY */
+	/*      GL_TEXTURE_COORD_ARRAY */
+	/*      GL_EDGE_FLAG_ARRAY */
+	/*      GL_VERTEX_ARRAY_SIZE */
+	/*      GL_VERTEX_ARRAY_TYPE */
+	/*      GL_VERTEX_ARRAY_STRIDE */
+	/*      GL_NORMAL_ARRAY_TYPE */
+	/*      GL_NORMAL_ARRAY_STRIDE */
+	/*      GL_COLOR_ARRAY_SIZE */
+	/*      GL_COLOR_ARRAY_TYPE */
+	/*      GL_COLOR_ARRAY_STRIDE */
+	/*      GL_INDEX_ARRAY_TYPE */
+	/*      GL_INDEX_ARRAY_STRIDE */
+	/*      GL_TEXTURE_COORD_ARRAY_SIZE */
+	/*      GL_TEXTURE_COORD_ARRAY_TYPE */
+	/*      GL_TEXTURE_COORD_ARRAY_STRIDE */
+	/*      GL_EDGE_FLAG_ARRAY_STRIDE */
+	/*      GL_POLYGON_OFFSET_FACTOR */
+	/*      GL_POLYGON_OFFSET_UNITS */
+
+	/* GetTextureParameter */
+	/*      GL_TEXTURE_MAG_FILTER */
+	/*      GL_TEXTURE_MIN_FILTER */
+	/*      GL_TEXTURE_WRAP_S */
+	/*      GL_TEXTURE_WRAP_T */
+	public static final int GL_TEXTURE_WIDTH = 0x1000;
+	public static final int GL_TEXTURE_HEIGHT = 0x1001;
+	public static final int GL_TEXTURE_INTERNAL_FORMAT = 0x1003;
+	public static final int GL_TEXTURE_BORDER_COLOR = 0x1004;
+	public static final int GL_TEXTURE_BORDER = 0x1005;
+	/*      GL_TEXTURE_RED_SIZE */
+	/*      GL_TEXTURE_GREEN_SIZE */
+	/*      GL_TEXTURE_BLUE_SIZE */
+	/*      GL_TEXTURE_ALPHA_SIZE */
+	/*      GL_TEXTURE_LUMINANCE_SIZE */
+	/*      GL_TEXTURE_INTENSITY_SIZE */
+	/*      GL_TEXTURE_PRIORITY */
+	/*      GL_TEXTURE_RESIDENT */
+
+	/* HintMode */
+	public static final int GL_DONT_CARE = 0x1100;
+	public static final int GL_FASTEST = 0x1101;
+	public static final int GL_NICEST = 0x1102;
+
+	/* HintTarget */
+	/*      GL_PERSPECTIVE_CORRECTION_HINT */
+	/*      GL_POINT_SMOOTH_HINT */
+	/*      GL_LINE_SMOOTH_HINT */
+	/*      GL_POLYGON_SMOOTH_HINT */
+	/*      GL_FOG_HINT */
+	/*      GL_PHONG_HINT */
+
+	/* IndexPointerType */
+	/*      GL_SHORT */
+	/*      GL_INT */
+	/*      GL_FLOAT */
+	/*      GL_DOUBLE */
+
+	/* LightModelParameter */
+	/*      GL_LIGHT_MODEL_AMBIENT */
+	/*      GL_LIGHT_MODEL_LOCAL_VIEWER */
+	/*      GL_LIGHT_MODEL_TWO_SIDE */
+
+	/* LightName */
+	public static final int GL_LIGHT0 = 0x4000;
+	public static final int GL_LIGHT1 = 0x4001;
+	public static final int GL_LIGHT2 = 0x4002;
+	public static final int GL_LIGHT3 = 0x4003;
+	public static final int GL_LIGHT4 = 0x4004;
+	public static final int GL_LIGHT5 = 0x4005;
+	public static final int GL_LIGHT6 = 0x4006;
+	public static final int GL_LIGHT7 = 0x4007;
+
+	/* LightParameter */
+	public static final int GL_AMBIENT = 0x1200;
+	public static final int GL_DIFFUSE = 0x1201;
+	public static final int GL_SPECULAR = 0x1202;
+	public static final int GL_POSITION = 0x1203;
+	public static final int GL_SPOT_DIRECTION = 0x1204;
+	public static final int GL_SPOT_EXPONENT = 0x1205;
+	public static final int GL_SPOT_CUTOFF = 0x1206;
+	public static final int GL_CONSTANT_ATTENUATION = 0x1207;
+	public static final int GL_LINEAR_ATTENUATION = 0x1208;
+	public static final int GL_QUADRATIC_ATTENUATION = 0x1209;
+
+	/* InterleavedArrays */
+	/*      GL_V2F */
+	/*      GL_V3F */
+	/*      GL_C4UB_V2F */
+	/*      GL_C4UB_V3F */
+	/*      GL_C3F_V3F */
+	/*      GL_N3F_V3F */
+	/*      GL_C4F_N3F_V3F */
+	/*      GL_T2F_V3F */
+	/*      GL_T4F_V4F */
+	/*      GL_T2F_C4UB_V3F */
+	/*      GL_T2F_C3F_V3F */
+	/*      GL_T2F_N3F_V3F */
+	/*      GL_T2F_C4F_N3F_V3F */
+	/*      GL_T4F_C4F_N3F_V4F */
+
+	/* ListMode */
+	public static final int GL_COMPILE = 0x1300;
+	public static final int GL_COMPILE_AND_EXECUTE = 0x1301;
+
+	/* ListNameType */
+	/*      GL_BYTE */
+	/*      GL_UNSIGNED_BYTE */
+	/*      GL_SHORT */
+	/*      GL_UNSIGNED_SHORT */
+	/*      GL_INT */
+	/*      GL_UNSIGNED_INT */
+	/*      GL_FLOAT */
+	/*      GL_2_BYTES */
+	/*      GL_3_BYTES */
+	/*      GL_4_BYTES */
+
+	/* LogicOp */
+	public static final int GL_CLEAR = 0x1500;
+	public static final int GL_AND = 0x1501;
+	public static final int GL_AND_REVERSE = 0x1502;
+	public static final int GL_COPY = 0x1503;
+	public static final int GL_AND_INVERTED = 0x1504;
+	public static final int GL_NOOP = 0x1505;
+	public static final int GL_XOR = 0x1506;
+	public static final int GL_OR = 0x1507;
+	public static final int GL_NOR = 0x1508;
+	public static final int GL_EQUIV = 0x1509;
+	public static final int GL_INVERT = 0x150A;
+	public static final int GL_OR_REVERSE = 0x150B;
+	public static final int GL_COPY_INVERTED = 0x150C;
+	public static final int GL_OR_INVERTED = 0x150D;
+	public static final int GL_NAND = 0x150E;
+	public static final int GL_SET = 0x150F;
+
+	/* MapTarget */
+	/*      GL_MAP1_COLOR_4 */
+	/*      GL_MAP1_INDEX */
+	/*      GL_MAP1_NORMAL */
+	/*      GL_MAP1_TEXTURE_COORD_1 */
+	/*      GL_MAP1_TEXTURE_COORD_2 */
+	/*      GL_MAP1_TEXTURE_COORD_3 */
+	/*      GL_MAP1_TEXTURE_COORD_4 */
+	/*      GL_MAP1_VERTEX_3 */
+	/*      GL_MAP1_VERTEX_4 */
+	/*      GL_MAP2_COLOR_4 */
+	/*      GL_MAP2_INDEX */
+	/*      GL_MAP2_NORMAL */
+	/*      GL_MAP2_TEXTURE_COORD_1 */
+	/*      GL_MAP2_TEXTURE_COORD_2 */
+	/*      GL_MAP2_TEXTURE_COORD_3 */
+	/*      GL_MAP2_TEXTURE_COORD_4 */
+	/*      GL_MAP2_VERTEX_3 */
+	/*      GL_MAP2_VERTEX_4 */
+
+	/* MaterialFace */
+	/*      GL_FRONT */
+	/*      GL_BACK */
+	/*      GL_FRONT_AND_BACK */
+
+	/* MaterialParameter */
+	public static final int GL_EMISSION = 0x1600;
+	public static final int GL_SHININESS = 0x1601;
+	public static final int GL_AMBIENT_AND_DIFFUSE = 0x1602;
+	public static final int GL_COLOR_INDEXES = 0x1603;
+	/*      GL_AMBIENT */
+	/*      GL_DIFFUSE */
+	/*      GL_SPECULAR */
+
+	/* MatrixMode */
+	public static final int GL_MODELVIEW = 0x1700;
+	public static final int GL_PROJECTION = 0x1701;
+	public static final int GL_TEXTURE = 0x1702;
+
+	/* MeshMode1 */
+	/*      GL_POINT */
+	/*      GL_LINE */
+
+	/* MeshMode2 */
+	/*      GL_POINT */
+	/*      GL_LINE */
+	/*      GL_FILL */
+
+	/* NormalPointerType */
+	/*      GL_BYTE */
+	/*      GL_SHORT */
+	/*      GL_INT */
+	/*      GL_FLOAT */
+	/*      GL_DOUBLE */
+
+	/* PixelCopyType */
+	public static final int GL_COLOR = 0x1800;
+	public static final int GL_DEPTH = 0x1801;
+	public static final int GL_STENCIL = 0x1802;
+
+	/* PixelFormat */
+	public static final int GL_COLOR_INDEX = 0x1900;
+	public static final int GL_STENCIL_INDEX = 0x1901;
+	public static final int GL_DEPTH_COMPONENT = 0x1902;
+	public static final int GL_RED = 0x1903;
+	public static final int GL_GREEN = 0x1904;
+	public static final int GL_BLUE = 0x1905;
+	public static final int GL_ALPHA = 0x1906;
+	public static final int GL_RGB = 0x1907;
+	public static final int GL_RGBA = 0x1908;
+	public static final int GL_LUMINANCE = 0x1909;
+	public static final int GL_LUMINANCE_ALPHA = 0x190A;
+
+	/* PixelMap */
+	/*      GL_PIXEL_MAP_I_TO_I */
+	/*      GL_PIXEL_MAP_S_TO_S */
+	/*      GL_PIXEL_MAP_I_TO_R */
+	/*      GL_PIXEL_MAP_I_TO_G */
+	/*      GL_PIXEL_MAP_I_TO_B */
+	/*      GL_PIXEL_MAP_I_TO_A */
+	/*      GL_PIXEL_MAP_R_TO_R */
+	/*      GL_PIXEL_MAP_G_TO_G */
+	/*      GL_PIXEL_MAP_B_TO_B */
+	/*      GL_PIXEL_MAP_A_TO_A */
+
+	/* PixelStore */
+	/*      GL_UNPACK_SWAP_BYTES */
+	/*      GL_UNPACK_LSB_FIRST */
+	/*      GL_UNPACK_ROW_LENGTH */
+	/*      GL_UNPACK_SKIP_ROWS */
+	/*      GL_UNPACK_SKIP_PIXELS */
+	/*      GL_UNPACK_ALIGNMENT */
+	/*      GL_PACK_SWAP_BYTES */
+	/*      GL_PACK_LSB_FIRST */
+	/*      GL_PACK_ROW_LENGTH */
+	/*      GL_PACK_SKIP_ROWS */
+	/*      GL_PACK_SKIP_PIXELS */
+	/*      GL_PACK_ALIGNMENT */
+
+	/* PixelTransfer */
+	/*      GL_MAP_COLOR */
+	/*      GL_MAP_STENCIL */
+	/*      GL_INDEX_SHIFT */
+	/*      GL_INDEX_OFFSET */
+	/*      GL_RED_SCALE */
+	/*      GL_RED_BIAS */
+	/*      GL_GREEN_SCALE */
+	/*      GL_GREEN_BIAS */
+	/*      GL_BLUE_SCALE */
+	/*      GL_BLUE_BIAS */
+	/*      GL_ALPHA_SCALE */
+	/*      GL_ALPHA_BIAS */
+	/*      GL_DEPTH_SCALE */
+	/*      GL_DEPTH_BIAS */
+
+	/* PixelType */
+	public static final int GL_BITMAP = 0x1A00;
+	/*      GL_BYTE */
+	/*      GL_UNSIGNED_BYTE */
+	/*      GL_SHORT */
+	/*      GL_UNSIGNED_SHORT */
+	/*      GL_INT */
+	/*      GL_UNSIGNED_INT */
+	/*      GL_FLOAT */
+
+	/* PolygonMode */
+	public static final int GL_POINT = 0x1B00;
+	public static final int GL_LINE = 0x1B01;
+	public static final int GL_FILL = 0x1B02;
+
+	/* ReadBufferMode */
+	/*      GL_FRONT_LEFT */
+	/*      GL_FRONT_RIGHT */
+	/*      GL_BACK_LEFT */
+	/*      GL_BACK_RIGHT */
+	/*      GL_FRONT */
+	/*      GL_BACK */
+	/*      GL_LEFT */
+	/*      GL_RIGHT */
+	/*      GL_AUX0 */
+	/*      GL_AUX1 */
+	/*      GL_AUX2 */
+	/*      GL_AUX3 */
+
+	/* RenderingMode */
+	public static final int GL_RENDER = 0x1C00;
+	public static final int GL_FEEDBACK = 0x1C01;
+	public static final int GL_SELECT = 0x1C02;
+
+	/* ShadingModel */
+	public static final int GL_FLAT = 0x1D00;
+	public static final int GL_SMOOTH = 0x1D01;
+
+	/* StencilFunction */
+	/*      GL_NEVER */
+	/*      GL_LESS */
+	/*      GL_EQUAL */
+	/*      GL_LEQUAL */
+	/*      GL_GREATER */
+	/*      GL_NOTEQUAL */
+	/*      GL_GEQUAL */
+	/*      GL_ALWAYS */
+
+	/* StencilOp */
+	/*      GL_ZERO */
+	public static final int GL_KEEP = 0x1E00;
+	public static final int GL_REPLACE = 0x1E01;
+	public static final int GL_INCR = 0x1E02;
+	public static final int GL_DECR = 0x1E03;
+	/*      GL_INVERT */
+
+	/* StringName */
+	public static final int GL_VENDOR = 0x1F00;
+	public static final int GL_RENDERER = 0x1F01;
+	public static final int GL_VERSION = 0x1F02;
+	public static final int GL_EXTENSIONS = 0x1F03;
+
+	/* TextureCoordName */
+	public static final int GL_S = 0x2000;
+	public static final int GL_T = 0x2001;
+	public static final int GL_R = 0x2002;
+	public static final int GL_Q = 0x2003;
+
+	/* TexCoordPointerType */
+	/*      GL_SHORT */
+	/*      GL_INT */
+	/*      GL_FLOAT */
+	/*      GL_DOUBLE */
+
+	/* TextureEnvMode */
+	public static final int GL_MODULATE = 0x2100;
+	public static final int GL_DECAL = 0x2101;
+	/*      GL_BLEND */
+	/*      GL_REPLACE */
+
+	/* TextureEnvParameter */
+	public static final int GL_TEXTURE_ENV_MODE = 0x2200;
+	public static final int GL_TEXTURE_ENV_COLOR = 0x2201;
+
+	/* TextureEnvTarget */
+	public static final int GL_TEXTURE_ENV = 0x2300;
+
+	/* TextureGenMode */
+	public static final int GL_EYE_LINEAR = 0x2400;
+	public static final int GL_OBJECT_LINEAR = 0x2401;
+	public static final int GL_SPHERE_MAP = 0x2402;
+
+	/* TextureGenParameter */
+	public static final int GL_TEXTURE_GEN_MODE = 0x2500;
+	public static final int GL_OBJECT_PLANE = 0x2501;
+	public static final int GL_EYE_PLANE = 0x2502;
+
+	/* TextureMagFilter */
+	public static final int GL_NEAREST = 0x2600;
+	public static final int GL_LINEAR = 0x2601;
+
+	/* TextureMinFilter */
+	/*      GL_NEAREST */
+	/*      GL_LINEAR */
+	public static final int GL_NEAREST_MIPMAP_NEAREST = 0x2700;
+	public static final int GL_LINEAR_MIPMAP_NEAREST = 0x2701;
+	public static final int GL_NEAREST_MIPMAP_LINEAR = 0x2702;
+	public static final int GL_LINEAR_MIPMAP_LINEAR = 0x2703;
+
+	/* TextureParameterName */
+	public static final int GL_TEXTURE_MAG_FILTER = 0x2800;
+	public static final int GL_TEXTURE_MIN_FILTER = 0x2801;
+	public static final int GL_TEXTURE_WRAP_S = 0x2802;
+	public static final int GL_TEXTURE_WRAP_T = 0x2803;
+	/*      GL_TEXTURE_BORDER_COLOR */
+	/*      GL_TEXTURE_PRIORITY */
+
+	/* TextureTarget */
+	/*      GL_TEXTURE_1D */
+	/*      GL_TEXTURE_2D */
+	/*      GL_PROXY_TEXTURE_1D */
+	/*      GL_PROXY_TEXTURE_2D */
+
+	/* TextureWrapMode */
+	public static final int GL_CLAMP = 0x2900;
+	public static final int GL_REPEAT = 0x2901;
+
+	/* VertexPointerType */
+	/*      GL_SHORT */
+	/*      GL_INT */
+	/*      GL_FLOAT */
+	/*      GL_DOUBLE */
+
+	/* ClientAttribMask */
+	public static final int GL_CLIENT_PIXEL_STORE_BIT = 0x00000001;
+	public static final int GL_CLIENT_VERTEX_ARRAY_BIT = 0x00000002;
+	public static final int GL_CLIENT_ALL_ATTRIB_BITS = 0xffffffff;
+
+	/* polygon_offset */
+	public static final int GL_POLYGON_OFFSET_FACTOR = 0x8038;
+	public static final int GL_POLYGON_OFFSET_UNITS = 0x2A00;
+	public static final int GL_POLYGON_OFFSET_POINT = 0x2A01;
+	public static final int GL_POLYGON_OFFSET_LINE = 0x2A02;
+	public static final int GL_POLYGON_OFFSET_FILL = 0x8037;
+
+	/* texture */
+	public static final int GL_ALPHA4 = 0x803B;
+	public static final int GL_ALPHA8 = 0x803C;
+	public static final int GL_ALPHA12 = 0x803D;
+	public static final int GL_ALPHA16 = 0x803E;
+	public static final int GL_LUMINANCE4 = 0x803F;
+	public static final int GL_LUMINANCE8 = 0x8040;
+	public static final int GL_LUMINANCE12 = 0x8041;
+	public static final int GL_LUMINANCE16 = 0x8042;
+	public static final int GL_LUMINANCE4_ALPHA4 = 0x8043;
+	public static final int GL_LUMINANCE6_ALPHA2 = 0x8044;
+	public static final int GL_LUMINANCE8_ALPHA8 = 0x8045;
+	public static final int GL_LUMINANCE12_ALPHA4 = 0x8046;
+	public static final int GL_LUMINANCE12_ALPHA12 = 0x8047;
+	public static final int GL_LUMINANCE16_ALPHA16 = 0x8048;
+	public static final int GL_INTENSITY = 0x8049;
+	public static final int GL_INTENSITY4 = 0x804A;
+	public static final int GL_INTENSITY8 = 0x804B;
+	public static final int GL_INTENSITY12 = 0x804C;
+	public static final int GL_INTENSITY16 = 0x804D;
+	public static final int GL_R3_G3_B2 = 0x2A10;
+	public static final int GL_RGB4 = 0x804F;
+	public static final int GL_RGB5 = 0x8050;
+	public static final int GL_RGB8 = 0x8051;
+	public static final int GL_RGB10 = 0x8052;
+	public static final int GL_RGB12 = 0x8053;
+	public static final int GL_RGB16 = 0x8054;
+	public static final int GL_RGBA2 = 0x8055;
+	public static final int GL_RGBA4 = 0x8056;
+	public static final int GL_RGB5_A1 = 0x8057;
+	public static final int GL_RGBA8 = 0x8058;
+	public static final int GL_RGB10_A2 = 0x8059;
+	public static final int GL_RGBA12 = 0x805A;
+	public static final int GL_RGBA16 = 0x805B;
+	public static final int GL_TEXTURE_RED_SIZE = 0x805C;
+	public static final int GL_TEXTURE_GREEN_SIZE = 0x805D;
+	public static final int GL_TEXTURE_BLUE_SIZE = 0x805E;
+	public static final int GL_TEXTURE_ALPHA_SIZE = 0x805F;
+	public static final int GL_TEXTURE_LUMINANCE_SIZE = 0x8060;
+	public static final int GL_TEXTURE_INTENSITY_SIZE = 0x8061;
+	public static final int GL_PROXY_TEXTURE_1D = 0x8063;
+	public static final int GL_PROXY_TEXTURE_2D = 0x8064;
+
+	/* texture_object */
+	public static final int GL_TEXTURE_PRIORITY = 0x8066;
+	public static final int GL_TEXTURE_RESIDENT = 0x8067;
+	public static final int GL_TEXTURE_BINDING_1D = 0x8068;
+	public static final int GL_TEXTURE_BINDING_2D = 0x8069;
+
+	/* vertex_array */
+	public static final int GL_VERTEX_ARRAY = 0x8074;
+	public static final int GL_NORMAL_ARRAY = 0x8075;
+	public static final int GL_COLOR_ARRAY = 0x8076;
+	public static final int GL_INDEX_ARRAY = 0x8077;
+	public static final int GL_TEXTURE_COORD_ARRAY = 0x8078;
+	public static final int GL_EDGE_FLAG_ARRAY = 0x8079;
+	public static final int GL_VERTEX_ARRAY_SIZE = 0x807A;
+	public static final int GL_VERTEX_ARRAY_TYPE = 0x807B;
+	public static final int GL_VERTEX_ARRAY_STRIDE = 0x807C;
+	public static final int GL_NORMAL_ARRAY_TYPE = 0x807E;
+	public static final int GL_NORMAL_ARRAY_STRIDE = 0x807F;
+	public static final int GL_COLOR_ARRAY_SIZE = 0x8081;
+	public static final int GL_COLOR_ARRAY_TYPE = 0x8082;
+	public static final int GL_COLOR_ARRAY_STRIDE = 0x8083;
+	public static final int GL_INDEX_ARRAY_TYPE = 0x8085;
+	public static final int GL_INDEX_ARRAY_STRIDE = 0x8086;
+	public static final int GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088;
+	public static final int GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089;
+	public static final int GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A;
+	public static final int GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C;
+	public static final int GL_VERTEX_ARRAY_POINTER = 0x808E;
+	public static final int GL_NORMAL_ARRAY_POINTER = 0x808F;
+	public static final int GL_COLOR_ARRAY_POINTER = 0x8090;
+	public static final int GL_INDEX_ARRAY_POINTER = 0x8091;
+	public static final int GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092;
+	public static final int GL_EDGE_FLAG_ARRAY_POINTER = 0x8093;
+	public static final int GL_V2F = 0x2A20;
+	public static final int GL_V3F = 0x2A21;
+	public static final int GL_C4UB_V2F = 0x2A22;
+	public static final int GL_C4UB_V3F = 0x2A23;
+	public static final int GL_C3F_V3F = 0x2A24;
+	public static final int GL_N3F_V3F = 0x2A25;
+	public static final int GL_C4F_N3F_V3F = 0x2A26;
+	public static final int GL_T2F_V3F = 0x2A27;
+	public static final int GL_T4F_V4F = 0x2A28;
+	public static final int GL_T2F_C4UB_V3F = 0x2A29;
+	public static final int GL_T2F_C3F_V3F = 0x2A2A;
+	public static final int GL_T2F_N3F_V3F = 0x2A2B;
+	public static final int GL_T2F_C4F_N3F_V3F = 0x2A2C;
+	public static final int GL_T4F_C4F_N3F_V4F = 0x2A2D;
+
+	/* Extensions */
+	public static final int GL_EXT_vertex_array = 1;
+	public static final int GL_EXT_bgra = 1;
+	public static final int GL_EXT_paletted_texture = 1;
+	public static final int GL_WIN_swap_hint = 1;
+	public static final int GL_WIN_draw_range_elements = 1;
+	// public static final int GL_WIN_phong_shading              = 1;
+	// public static final int GL_WIN_specular_fog               = 1;
+
+	/* EXT_vertex_array */
+	public static final int GL_VERTEX_ARRAY_EXT = 0x8074;
+	public static final int GL_NORMAL_ARRAY_EXT = 0x8075;
+	public static final int GL_COLOR_ARRAY_EXT = 0x8076;
+	public static final int GL_INDEX_ARRAY_EXT = 0x8077;
+	public static final int GL_TEXTURE_COORD_ARRAY_EXT = 0x8078;
+	public static final int GL_EDGE_FLAG_ARRAY_EXT = 0x8079;
+	public static final int GL_VERTEX_ARRAY_SIZE_EXT = 0x807A;
+	public static final int GL_VERTEX_ARRAY_TYPE_EXT = 0x807B;
+	public static final int GL_VERTEX_ARRAY_STRIDE_EXT = 0x807C;
+	public static final int GL_VERTEX_ARRAY_COUNT_EXT = 0x807D;
+	public static final int GL_NORMAL_ARRAY_TYPE_EXT = 0x807E;
+	public static final int GL_NORMAL_ARRAY_STRIDE_EXT = 0x807F;
+	public static final int GL_NORMAL_ARRAY_COUNT_EXT = 0x8080;
+	public static final int GL_COLOR_ARRAY_SIZE_EXT = 0x8081;
+	public static final int GL_COLOR_ARRAY_TYPE_EXT = 0x8082;
+	public static final int GL_COLOR_ARRAY_STRIDE_EXT = 0x8083;
+	public static final int GL_COLOR_ARRAY_COUNT_EXT = 0x8084;
+	public static final int GL_INDEX_ARRAY_TYPE_EXT = 0x8085;
+	public static final int GL_INDEX_ARRAY_STRIDE_EXT = 0x8086;
+	public static final int GL_INDEX_ARRAY_COUNT_EXT = 0x8087;
+	public static final int GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088;
+	public static final int GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089;
+	public static final int GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A;
+	public static final int GL_TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B;
+	public static final int GL_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C;
+	public static final int GL_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D;
+	public static final int GL_VERTEX_ARRAY_POINTER_EXT = 0x808E;
+	public static final int GL_NORMAL_ARRAY_POINTER_EXT = 0x808F;
+	public static final int GL_COLOR_ARRAY_POINTER_EXT = 0x8090;
+	public static final int GL_INDEX_ARRAY_POINTER_EXT = 0x8091;
+	public static final int GL_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092;
+	public static final int GL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093;
+	public static final int GL_DOUBLE_EXT = GL_DOUBLE;
+
+	/* EXT_bgra */
+	public static final int GL_BGR_EXT = 0x80E0;
+	public static final int GL_BGRA_EXT = 0x80E1;
+
+	/* EXT_paletted_texture */
+
+	/* These must match the GL_COLOR_TABLE_*_SGI enumerants */
+	public static final int GL_COLOR_TABLE_FORMAT_EXT = 0x80D8;
+	public static final int GL_COLOR_TABLE_WIDTH_EXT = 0x80D9;
+	public static final int GL_COLOR_TABLE_RED_SIZE_EXT = 0x80DA;
+	public static final int GL_COLOR_TABLE_GREEN_SIZE_EXT = 0x80DB;
+	public static final int GL_COLOR_TABLE_BLUE_SIZE_EXT = 0x80DC;
+	public static final int GL_COLOR_TABLE_ALPHA_SIZE_EXT = 0x80DD;
+	public static final int GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = 0x80DE;
+	public static final int GL_COLOR_TABLE_INTENSITY_SIZE_EXT = 0x80DF;
+
+	public static final int GL_COLOR_INDEX1_EXT = 0x80E2;
+	public static final int GL_COLOR_INDEX2_EXT = 0x80E3;
+	public static final int GL_COLOR_INDEX4_EXT = 0x80E4;
+	public static final int GL_COLOR_INDEX8_EXT = 0x80E5;
+	public static final int GL_COLOR_INDEX12_EXT = 0x80E6;
+	public static final int GL_COLOR_INDEX16_EXT = 0x80E7;
+
+	/* WIN_draw_range_elements */
+	public static final int GL_MAX_ELEMENTS_VERTICES_WIN = 0x80E8;
+	public static final int GL_MAX_ELEMENTS_INDICES_WIN = 0x80E9;
+
+	/* WIN_phong_shading */
+	public static final int GL_PHONG_WIN = 0x80EA;
+	public static final int GL_PHONG_HINT_WIN = 0x80EB;
+
+	/* WIN_specular_fog */
+	public static final int GL_FOG_SPECULAR_TEXTURE_WIN = 0x80EC;
+
+	/* For compatibility with OpenGL v1.0 */
+	public static final int GL_LOGIC_OP = GL_INDEX_LOGIC_OP;
+	public static final int GL_TEXTURE_COMPONENTS = GL_TEXTURE_INTERNAL_FORMAT;
+
+	public static final native void glAccum (int op, float value);
+	public static final native void glAlphaFunc (int func, float ref);
+	public static final native boolean glAreTexturesResident (int n, int[] textures, boolean[] residences);
+	public static final native void glArrayElement (int index);
+	public static final native int glBegin (int mode);
+	public static final native int glEnd ();
+	public static final native void glBindTexture (int target, int texture);
+	public static final native void glBitmap (int width, int height, float xorig, float yorig, float xmove, float ymove, byte[] bitmap);
+	public static final native void glBlendFunc (int sfactor, int dfactor);
+	public static final native void glCallList (int list);
+	public static final native void glCallLists (int n, int type, byte[] lists);
+	public static final native void glCallLists (int n, int type, char[] lists);
+	public static final native void glCallLists (int n, int type, int[] lists);
+	public static final native void glClear (int mask);
+	public static final native void glClearAccum (float red, float green, float blue, float alpha);
+	public static final native void glClearColor (float red, float green, float blue, float alpha);
+	public static final native void glClearDepth (double depth);
+	public static final native void glClearIndex (float c);
+	public static final native void glClearStencil (int s);
+	public static final native void glClipPlane (int plane, double[] equation);
+	public static final native void glColor3b (byte red, byte green, byte blue);
+	public static final native void glColor3d (double red, double green, double blue);
+	public static final native void glColor3f (float red, float green, float blue);
+	public static final native void glColor3i (int red, int green, int blue);
+	public static final native void glColor3s (short red, short green, short blue);
+	public static final native void glColor3ub (byte red, byte green, byte blue);
+	public static final native void glColor3ui (int red, int green, int blue);
+	public static final native void glColor3us (short red, short green, short blue);
+	public static final native void glColor4b (byte red, byte green, byte blue, byte alpha);
+	public static final native void glColor4d (double red, double green, double blue, double alpha);
+	public static final native void glColor4f (float red, float green, float blue, float alpha);
+	public static final native void glColor4i (int red, int green, int blue, int alpha);
+	public static final native void glColor4s (short red, short green, short blue, short alpha);
+	public static final native void glColor4ub (byte red, byte green, byte blue, byte alpha);
+	public static final native void glColor4ui (int red, int green, int blue, int alpha);
+	public static final native void glColor4us (short red, short green, short blue, short alpha);
+	public static final native void glColor3bv (byte[] v);
+	public static final native void glColor3dv (double[] v);
+	public static final native void glColor3fv (float[] v);
+	public static final native void glColor3iv (int[] v);
+	public static final native void glColor3sv (short[] v);
+	public static final native void glColor3ubv (byte[] v);
+	public static final native void glColor3uiv (int[] v);
+	public static final native void glColor3usv (short[] v);
+	public static final native void glColor4bv (byte[] v);
+	public static final native void glColor4dv (double[] v);
+	public static final native void glColor4fv (float[] v);
+	public static final native void glColor4iv (int[] v);
+	public static final native void glColor4ubv (byte[] v);
+	public static final native void glColor4uiv (int[] v);
+	public static final native void glColor4usv (short[] v);
+	public static final native void glColor4ubv (short[] v);
+	public static final native void glColorMask (boolean red, boolean green, boolean blue, boolean alpha);
+	public static final native void glColorMaterial (int face, int mode);
+	public static final native void glColorPointer (int size, int type, int stride, int[] pointer);
+	//public static final native void glColorTableEXT (int target, int internalFormat, int width, int format, int type, int[] data);
+	//public static final native void glColorSubTableEXT (int target, int start, int count, int format, int type, int[] data);
+	public static final native void glCopyPixels (int x, int y, int width, int height, int type);
+	public static final native void glCopyTexImage1D (int target, int level, int internalFormat, int x, int y, int width, int border);
+	public static final native void glCopyTexImage2D (int target, int level, int internalFormat, int x, int y, int width, int height, int border);
+	public static final native void glCopyTexSubImage1D (int target, int level, int xoffset, int x, int y, int width); 
+	public static final native void glCopyTexSubImage2D (int target, int level, int xoffset, int yoffset, int x, int y, int width, int height);
+	public static final native void glCullFace (int mode);
+	public static final native void glDeleteLists (int list, int range);
+	public static final native void glDeleteTextures (int n, int[] textures);
+	public static final native void glDepthFunc (int func);
+	public static final native void glDepthMask (boolean flag);
+	public static final native void glDepthRange (double znear, double zfar);
+	public static final native void glDrawArrays (int mode, int first, int count);
+	public static final native void glDrawBuffer (int mode);
+	public static final native void glDrawElements (int mode, int count, int type, int[] indices); /* MULTIPLES TYPES */
+	public static final native void glDrawPixels (int width, int height, int format, int type, int[] pixels); /* MULTIPLES TYPES */
+	public static final native void glEdgeFlag (boolean flag);
+	public static final native void glEdgeFlagv (boolean[] flag);
+	public static final native void glEdgeFlagPointer (int stride, boolean[] pointer);
+	public static final native void glEnable (int cap);
+	public static final native void glDisable (int cap);
+	public static final native void glEnableClientState (int array);
+	public static final native void glDisableClientState (int array);
+	public static final native void glEvalCoord1d (double u);
+	public static final native void glEvalCoord1f (float u);
+	public static final native void glEvalCoord2d (double u, double v);
+	public static final native void glEvalCoord2f (float u, float v);
+	public static final native void glEvalCoord1dv (double[] u);
+	public static final native void glEvalCoord1fv (float[] u);
+	public static final native void glEvalCoord2dv (double[] u);
+	public static final native void glEvalCoord2fv (float[] u);
+	public static final native void glEvalMesh1 (int mode, int i1, int i2);
+	public static final native void glEvalMesh2 (int mode, int i1, int i2, int j1, int j2);
+	public static final native void glEvalPoint1 (int i);
+	public static final native void glEvalPoint2 (int i, int j);
+	public static final native void glFeedbackBuffer (int size, int type, float[] buffer);
+	public static final native void glFinish ();
+	public static final native void glFlush ();
+	public static final native void glFogf (int pname, float param);
+	public static final native void glFogi (int pname, int param);
+	public static final native void glFogfv (int pname, float[] params);
+	public static final native void glFogiv (int pname, int[] params);
+	public static final native void glFrontFace (int mode);
+	public static final native void glFrustum (double left, double right, double bottom, double top, double znear, double zfar);
+	public static final native int glGenLists (int range);
+	public static final native void glGenTextures (int n, int[] textures);
+	public static final native void glGetBooleanv (int pname, boolean[] params);
+	public static final native void glGetDoublev (int pname, double[] params);
+	public static final native void glGetFloatv (int pname, float[] params);
+	public static final native void glGetIntegerv (int pname, int[] params);
+	public static final native void glGetClipPlane (int plane, double[] equation);
+	//public static final native void glGetColorTableEXT (int target, int format, int type, int[] data);
+	//public static final native void glGetColorTableParameterfvEXT (int target, int pname, float[] params);
+	//public static final native void glGetColorTableParameterivEXT (int target, int pname, int[] params);
+	public static final native int glGetError ();
+	public static final native void glGetLightfv (int light, int pname, float[] params);
+	public static final native void glGetLightiv (int light, int pname, int[] params);
+	public static final native void glGetMapdv (int tagert, int query, double[] v);
+	public static final native void glGetMapfv (int tagert, int query, float[] v);
+	public static final native void glGetMapiv (int tagert, int query, int[] v);
+	public static final native void glGetMaterialfv (int face, int pname, float[] params);
+	public static final native void glGetMaterialiv (int face, int pname, int[] params);
+	public static final native void glGetPixelMapfv (int map, float[] values);
+	public static final native void glGetPixelMapuiv (int map, int[] values);
+	public static final native void glGetPixelMapusv (int map, short[] values);
+	public static final native void glGetPointerv (int pname, int[] params);
+	/* TEST */
+	public static final native void glGetPolygonStipple (byte[] mask);
+	public static final native int glGetString (int name);
+	/* SHOULD RETURN A STRING */
+	public static final native void glGetTexEnvfv (int target, int pname, float[] params);
+	public static final native void glGetTexEnviv (int target, int pname, int[] params);
+	public static final native void glGetTexGendv (int coord, int pname, double[] params);
+	public static final native void glGetTexGenfv (int coord, int pname, float[] params);
+	public static final native void glGetTexGeniv (int coord, int pname, int[] params);
+	public static final native void glGetTexImage (int target, int level, int format, int type, int[] pixels); /* MULTIPLES TYPES ARRAY */
+	public static final native void glGetTexLevelParameterfv (int target, int level, int pname, float[] params);
+	public static final native void glGetTexLevelParameteriv (int target, int level, int pname, int[] params);
+	public static final native void glGetTexParameterfv (int target, int pname, float[] params);
+	public static final native void glGetTexParameteriv (int target, int pname, int[] params);
+	public static final native void glHint (int target, int mode);
+	public static final native void glIndexd (double c);
+	public static final native void glIndexf (float c);
+	public static final native void glIndexi (int c);
+	public static final native void glIndexs (short c);
+	public static final native void glIndexdv (double[] c);
+	public static final native void glIndexfv (float[] c);
+	public static final native void glIndexiv (int[] c);
+	public static final native void glIndexsv (short[] c);
+	public static final native void glIndexMask (int mask);
+	public static final native void glIndexPointer (int type, int stride, int[] pointer);
+	/* MULTIPLES TYPES */
+	public static final native void glInitNames ();
+	public static final native void glInterleavedArrays (int format, int stride, int[] pointer);
+	/* CHECK */
+	public static final native boolean glIsEnabled (int cap);
+	public static final native boolean glIsList (int list);
+	public static final native boolean glIsTexture (int texture);
+	public static final native void glLightf (int light, int pname, float param);
+	public static final native void glLighti (int light, int pname, int param);
+	public static final native void glLightfv (int light, int pname, float[] param);
+	//public static final native void glLightfv (int light, int pname, int param);
+	public static final native void glLightiv (int light, int pname, int[] param);
+	public static final native void glLightModelf (int pname, float param);
+	public static final native void glLightModeli (int pname, int param);
+	public static final native void glLightModelfv (int pname, float[] param);
+	public static final native void glLightModeliv (int pname, int[] param);
+	public static final native void glLineStipple (int factor, short pattern);
+	public static final native void glLineWidth (float width);
+	public static final native void glListBase (int base);
+	public static final native void glLoadIdentity ();
+	public static final native void glLoadMatrixd (double[] m);
+	public static final native void glLoadMatrixf (float[] m);
+	public static final native void glLoadName (int name);
+	public static final native void glLogicOp (int opcode);
+	public static final native void glMap1d (int target, double u1, double u2, int stride, int order, double[] points);
+	public static final native void glMap1f (int target, float u1, float u2, int stride, int order, float[] points);
+	public static final native void glMap2d (int target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points);
+	public static final native void glMap2f (int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points);
+	public static final native void glMapGrid1d (int un, double u1, double u2);
+	public static final native void glMapGrid1f (int un, float u1, float u2);
+	public static final native void glMapGrid2d (int un, double u1, double u2, int vm, double v1, double v2);
+	public static final native void glMapGrid2f (int un, float u1, float u2, int vm, float v1, float v2);
+	public static final native void glMaterialf (int face, int pname, float param);
+	public static final native void glMateriali (int face, int pname, int param);
+	public static final native void glMaterialfv (int face, int pname, float[] param);
+	public static final native void glMaterialiv (int face, int pname, int[] param);
+	public static final native void glMatrixMode (int mode);
+	public static final native void glMultMatrixd (double[] m);
+	public static final native void glMultMatrixf (float[] m);
+	public static final native void glNewList (int list, int mode);
+	public static final native void glEndList ();
+	public static final native void glNormal3b (byte nx, byte ny, byte nz);
+	public static final native void glNormal3d (double nx, double ny, double nz);
+	public static final native void glNormal3f (float nx, float ny, float nz);
+	public static final native void glNormal3i (int nx, int ny, int nz);
+	public static final native void glNormal3s (short nx, short ny, short nz);
+	public static final native void glNormal3bv (byte[] v);
+	public static final native void glNormal3dv (double[] v);
+	public static final native void glNormal3fv (float[] v);
+	public static final native void glNormal3iv (int[] v);
+	public static final native void glNormal3sv (short[] v);
+	public static final native void glNormalPointer (int type, int stride, int[] pointer); /* MULTIPLES TYPES ARRAY */
+	public static final native void glOrtho (double left, double right, double bottom, double top, double znear, double zfar);
+	public static final native void glPassThrough (float token);
+	public static final native void glPixelMapfv (int map, int mapsize, float[] values);
+	public static final native void glPixelMapuiv (int map, int mapsize, int[] values);
+	public static final native void glPixelMapusv (int map, int mapsize, short[] values);
+	public static final native void glPixelStoref (int pname, float param);
+	public static final native void glPixelStorei (int pname, int param);
+	public static final native void glPixelTransferf (int pname, float param);
+	public static final native void glPixelTransferi (int pname, int param);
+	public static final native void glPixelZoom (float xfactor, float yfactor);
+	public static final native void glPointSize (float size);
+	public static final native void glPolygonMode (int face, int mode);
+	public static final native void glPolygonOffset (float factor, float units);
+	public static final native void glPolygonStipple (byte[] mask);
+	public static final native void glPrioritizeTextures (int n, int[] textures, float[] priorities);
+	public static final native void glPushAttrib (int mask);
+	public static final native void glPopAttrib ();
+	public static final native void glPushClientAttrib (int mask);
+	public static final native void glPopClientAttrib ();
+	public static final native void glPushMatrix ();
+	public static final native void glPopMatrix ();
+	public static final native void glPushName (int name);
+	public static final native void glPopName ();
+	public static final native void glRasterPos2d (double x, double y);
+	public static final native void glRasterPos2f (float x, float y);
+	public static final native void glRasterPos2i (int x, int y);
+	public static final native void glRasterPos2s (short x, short y);
+	public static final native void glRasterPos3d (double x, double y, double z);
+	public static final native void glRasterPos3f (float x, float y, float z);
+	public static final native void glRasterPos3i (int x, int y, int z);
+	public static final native void glRasterPos3s (short x, short y, short z);
+	public static final native void glRasterPos4d (double x, double y, double z, double w);
+	public static final native void glRasterPos4f (float x, float y, float z, float w);
+	public static final native void glRasterPos4i (int x, int y, int z, int w);
+	public static final native void glRasterPos4s (short x, short y, short z, short w);
+	public static final native void glRasterPos2dv (double[] v);
+	public static final native void glRasterPos2fv (float[] v);
+	public static final native void glRasterPos2iv (int[] v);
+	public static final native void glRasterPos2sv (short[] v);
+	public static final native void glRasterPos3dv (double[] v);
+	public static final native void glRasterPos3fv (float[] v);
+	public static final native void glRasterPos3iv (int[] v);
+	public static final native void glRasterPos3sv (short[] v);
+	public static final native void glRasterPos4dv (double[] v);
+	public static final native void glRasterPos4fv (float[] v);
+	public static final native void glRasterPos4iv (int[] v);
+	public static final native void glRasterPos4sv (short[] v);
+	public static final native void glReadBuffer (int mode);
+	public static final native void glReadPixels (int x, int y, int width, int height, int format, int type, int[] pixels); /* MULTIPLES TYPES ARRAY */
+	public static final native void glRectd (double x1, double y1, double x2, double y2);
+	public static final native void glRectf (float x1, float y1, float x2, float y2);
+	public static final native void glRecti (int x1, int y1, int x2, int y2);
+	public static final native void glRects (short x1, short y1, short x2, short y2);
+	public static final native void glRectdv (double[] v1, double[] v2);
+	public static final native void glRectfv (float[] v1, float[] v2);
+	public static final native void glRectiv (int[] v1, int[] v2);
+	public static final native void glRectsv (short[] v, short[] v2);
+	public static final native int glRenderMode (int mode);
+	public static final native void glRotated (double angle, double x, double y, double z);
+	public static final native void glRotatef (float angle, float x, float y, float z);
+	public static final native void glScaled (double x, double y, double z);
+	public static final native void glScalef (float x, float y, float z);
+	public static final native void glScissor (int x, int y, int width, int height);
+	//public static final native void glSelectBuffer (int size, int[] buffer);
+	public static final native void glSelectBuffer (int size, int buffer);
+	public static final native void glShadeModel (int mode);
+	public static final native void glStencilFunc (int func, int ref, int mask);
+	public static final native void glStencilMask (int mask);
+	public static final native void glStencilOp (int fail, int zfail, int zpass);
+	public static final native void glTexCoord1d (double s);
+	public static final native void glTexCoord1f (float s);
+	public static final native void glTexCoord1i (int s);
+	public static final native void glTexCoord1s (short s);
+	public static final native void glTexCoord2d (double s, double t);
+	public static final native void glTexCoord2f (float s, float t);
+	public static final native void glTexCoord2i (int s, int t);
+	public static final native void glTexCoord2s (short s, short t);
+	public static final native void glTexCoord3d (double s, double t, double r);
+	public static final native void glTexCoord3f (float s, float t, float r);
+	public static final native void glTexCoord3i (int s, int t, int r);
+	public static final native void glTexCoord3s (short s, short t, short r);
+	public static final native void glTexCoord4d (double s, double t, double r, double q);
+	public static final native void glTexCoord4f (float s, float t, float r, float q);
+	public static final native void glTexCoord4i (int s, int t, int r, int q);
+	public static final native void glTexCoord4s (short s, short t, short r, short q);
+	public static final native void glTexCoord1dv (double[] v);
+	public static final native void glTexCoord1fv (float[] v);
+	public static final native void glTexCoord1iv (int[] v);
+	public static final native void glTexCoord1sv (short[] v);
+	public static final native void glTexCoord2dv (double[] v);
+	public static final native void glTexCoord2fv (float[] v);
+	public static final native void glTexCoord2iv (int[] v);
+	public static final native void glTexCoord2sv (short[] v);
+	public static final native void glTexCoord3dv (double[] v);
+	public static final native void glTexCoord3fv (float[] v);
+	public static final native void glTexCoord3iv (int[] v);
+	public static final native void glTexCoord3sv (short[] v);
+	public static final native void glTexCoord4dv (double[] v);
+	public static final native void glTexCoord4fv (float[] v);
+	public static final native void glTexCoord4iv (int[] v);
+	public static final native void glTexCoord4sv (short[] v);
+	public static final native void glTexCoordPointer (int size, int type, int stride, int[] pointer); /*MULTIPLES ARRAYS - CHECK MSDK, COUNT PARAM MISSING */
+	public static final native void glTexEnvf (int target, int pname, float param);
+	public static final native void glTexEnvi (int target, int pname, int param);
+	public static final native void glTexEnvfv (int target, int pname, float[] params);
+	public static final native void glTexEnviv (int target, int pname, int[] params);
+	public static final native void glTexGend (int coord, int pname, double param);
+	public static final native void glTexGenf (int coord, int pname, float param);
+	public static final native void glTexGeni (int coord, int pname, int param);
+	public static final native void glTexGendv (int coord, int pname, double[] params);
+	public static final native void glTexGenfv (int coord, int pname, float[] params);
+	public static final native void glTexGeniv (int coord, int pname, int[] params);
+	public static final native void glTexImage1D (int target, int level, int internalFormat, int width, int border, int format, int type, int[] pixels); /* MULTIPLES ARRAYS */
+	public static final native void glTexImage2D (int target, int level, int internalFormat, int width, int height, int border, int format, int type, byte[] pixels); /* MULTIPLES ARRAYS */
+	public static final native void glTexParameterf (int target, int pname, float param);
+	public static final native void glTexParameteri (int target, int pname, int param);
+	public static final native void glTexParameterfv (int target, int pname, float[] params);
+	public static final native void glTexParameteriv (int target, int pname, int[] params);
+	public static final native void glTexSubImage1D (int target, int level, int xoffset, int width, int format, int type, int[] pixels); /* MULTIPLES ARRAYS */
+	public static final native void glTexSubImage2D (int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, int[] pixels); /* MULTIPLES ARRAYS */
+	public static final native void glTranslated (double x, double y, double z);
+	public static final native void glTranslatef (float x, float y, float z);
+	public static final native void glVertex2d (double x, double y);
+	public static final native void glVertex2f (float x, float y);
+	public static final native void glVertex2i (int x, int y);
+	public static final native void glVertex2s (short x, short y);
+	public static final native void glVertex3d (double x, double y, double z);
+	public static final native void glVertex3f (float x, float y, float z);
+	public static final native void glVertex3i (int x, int y, int z);
+	public static final native void glVertex3s (short x, short y, short z);
+	public static final native void glVertex4d (double x, double y, double z, double w);
+	public static final native void glVertex4f (float x, float y, float z, float w);
+	public static final native void glVertex4i (int x, int y, int z, int w);
+	public static final native void glVertex4s (short x, short y, short z, short w);
+	public static final native void glVertex2dv (double[] v);
+	public static final native void glVertex2fv (float[] v);
+	public static final native void glVertex2iv (int[] v);
+	public static final native void glVertex2sv (short[] v);
+	public static final native int glVertex3dv (double[] v);
+	public static final native int glVertex3dv (int v);
+	public static final native void glVertex3fv (float[] v);
+	public static final native void glVertex3iv (int[] v);
+	public static final native void glVertex3sv (short[] v);
+	public static final native int glVertex4dv (double[] v);
+	public static final native void glVertex4fv (float[] v);
+	public static final native void glVertex4iv (int[] v);
+	public static final native void glVertex4sv (short[] v);
+	public static final native void glVertexPointer (int size, int type, int stride, int[] pointer); /* MULTIPLES ARRAYS */
+	public static final native void glViewport (int x, int y, int width, int height);
+}
+\ No newline at end of file
diff --git a/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/GLU.java b/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/GLU.java
new file mode 100644
index 0000000000..2f837004a2
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/GLU.java
@@ -0,0 +1,245 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl;
+
+
+public class GLU {
+
+	/* Version */
+	public static final int GLU_VERSION_1_1 = 1;
+	public static final int GLU_VERSION_1_2 = 1;
+	
+	/* Errors: (return value 0 = no error) */
+	public static final int GLU_INVALID_ENUM = 100900;
+	public static final int GLU_INVALID_VALUE = 100901;
+	public static final int GLU_OUT_OF_MEMORY = 100902;
+	public static final int GLU_INCOMPATIBLE_GL_VERSION = 100903;
+	
+	/* StringName */
+	public static final int GLU_VERSION = 100800;
+	public static final int GLU_EXTENSIONS = 100801;
+	
+	
+	/****           Quadric constants               ****/
+	
+	/* QuadricNormal */
+	public static final int GLU_SMOOTH = 100000;
+	public static final int GLU_FLAT = 100001;
+	public static final int GLU_NONE = 100002;
+	
+	/* QuadricDrawStyle */
+	public static final int GLU_POINT = 100010;
+	public static final int GLU_LINE = 100011;
+	public static final int GLU_FILL = 100012;
+	public static final int GLU_SILHOUETTE = 100013;
+	
+	/* QuadricOrientation */
+	public static final int GLU_OUTSIDE = 100020;
+	public static final int GLU_INSIDE = 100021;
+	
+	/* Callback types: */
+	/*      GLU_ERROR               100103 */
+	
+	
+	/****           Tesselation constants           ****/
+	
+	public static final double GLU_TESS_MAX_COORD = 1.0e150;
+	
+	/* TessProperty */
+	public static final int GLU_TESS_WINDING_RULE = 100140;
+	public static final int GLU_TESS_BOUNDARY_ONLY = 100141;
+	public static final int GLU_TESS_TOLERANCE = 100142;
+	
+	/* TessWinding */
+	public static final int GLU_TESS_WINDING_ODD = 100130;
+	public static final int GLU_TESS_WINDING_NONZERO = 100131;
+	public static final int GLU_TESS_WINDING_POSITIVE = 100132;
+	public static final int GLU_TESS_WINDING_NEGATIVE = 100133;
+	public static final int GLU_TESS_WINDING_ABS_GEQ_TWO = 100134;
+	
+	/* TessCallback */
+	public static final int GLU_TESS_BEGIN = 100100;  /* void (CALLBACK*)(GLenum    type)  */
+	public static final int GLU_TESS_VERTEX = 100101;  /* void (CALLBACK*)(void      *data) */
+	public static final int GLU_TESS_END = 100102;  /* void (CALLBACK*)(void)            */
+	public static final int GLU_TESS_ERROR = 100103;  /* void (CALLBACK*)(GLenum    errno) */
+	public static final int GLU_TESS_EDGE_FLAG = 100104;  /* void (CALLBACK*)(GLboolean boundaryEdge)  */
+	public static final int GLU_TESS_COMBINE = 100105;  /* void (CALLBACK*)(GLdouble  coords[3],
+	                                                            void      *data[4],
+	                                                            GLfloat   weight[4],
+	                                                            void      **dataOut)     */
+	public static final int GLU_TESS_BEGIN_DATA = 100106;  /* void (CALLBACK*)(GLenum    type,  
+	                                                            void      *polygon_data) */
+	public static final int GLU_TESS_VERTEX_DATA = 100107;  /* void (CALLBACK*)(void      *data, 
+	                                                            void      *polygon_data) */
+	public static final int GLU_TESS_END_DATA = 100108;  /* void (CALLBACK*)(void      *polygon_data) */
+	public static final int GLU_TESS_ERROR_DATA = 100109;  /* void (CALLBACK*)(GLenum    errno, 
+	                                                            void      *polygon_data) */
+	public static final int GLU_TESS_EDGE_FLAG_DATA = 100110;  /* void (CALLBACK*)(GLboolean boundaryEdge,
+	                                                            void      *polygon_data) */
+	public static final int GLU_TESS_COMBINE_DATA = 100111;  /* void (CALLBACK*)(GLdouble  coords[3],
+	                                                            void      *data[4],
+	                                                            GLfloat   weight[4],
+	                                                            void      **dataOut,
+	                                                            void      *polygon_data) */
+	
+	/* TessError */
+	public static final int GLU_TESS_ERROR1 = 100151;
+	public static final int GLU_TESS_ERROR2 = 100152;
+	public static final int GLU_TESS_ERROR3 = 100153;
+	public static final int GLU_TESS_ERROR4 = 100154;
+	public static final int GLU_TESS_ERROR5 = 100155;
+	public static final int GLU_TESS_ERROR6 = 100156;
+	public static final int GLU_TESS_ERROR7 = 100157;
+	public static final int GLU_TESS_ERROR8 = 100158;
+	
+	public static final int GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_ERROR1;
+	public static final int GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_ERROR2;
+	public static final int GLU_TESS_MISSING_END_POLYGON = GLU_TESS_ERROR3;
+	public static final int GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_ERROR4;
+	public static final int GLU_TESS_COORD_TOO_LARGE = GLU_TESS_ERROR5;
+	public static final int GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_ERROR6;
+	
+	/****           NURBS constants                 ****/
+	
+	/* NurbsProperty */
+	public static final int GLU_AUTO_LOAD_MATRIX = 100200;
+	public static final int GLU_CULLING = 100201;
+	public static final int GLU_SAMPLING_TOLERANCE = 100203;
+	public static final int GLU_DISPLAY_MODE = 100204;
+	public static final int GLU_PARAMETRIC_TOLERANCE = 100202;
+	public static final int GLU_SAMPLING_METHOD = 100205;
+	public static final int GLU_U_STEP = 100206;
+	public static final int GLU_V_STEP = 100207;
+	
+	/* NurbsSampling */
+	public static final int GLU_PATH_LENGTH = 100215;
+	public static final int GLU_PARAMETRIC_ERROR = 100216;
+	public static final int GLU_DOMAIN_DISTANCE = 100217;
+	
+	
+	/* NurbsTrim */
+	public static final int GLU_MAP1_TRIM_2 = 100210;
+	public static final int GLU_MAP1_TRIM_3 = 100211;
+	
+	/* NurbsDisplay */
+	/*      GLU_FILL                100012 */
+	public static final int GLU_OUTLINE_POLYGON = 100240;
+	public static final int GLU_OUTLINE_PATCH = 100241;
+	
+	/* NurbsCallback */
+	/*      GLU_ERROR               100103 */
+	
+	/* NurbsErrors */
+	public static final int GLU_NURBS_ERROR1 = 100251;
+	public static final int GLU_NURBS_ERROR2 = 100252;
+	public static final int GLU_NURBS_ERROR3 = 100253;
+	public static final int GLU_NURBS_ERROR4 = 100254;
+	public static final int GLU_NURBS_ERROR5 = 100255;
+	public static final int GLU_NURBS_ERROR6 = 100256;
+	public static final int GLU_NURBS_ERROR7 = 100257;
+	public static final int GLU_NURBS_ERROR8 = 100258;
+	public static final int GLU_NURBS_ERROR9 = 100259;
+	public static final int GLU_NURBS_ERROR10 = 100260;
+	public static final int GLU_NURBS_ERROR11 = 100261;
+	public static final int GLU_NURBS_ERROR12 = 100262;
+	public static final int GLU_NURBS_ERROR13 = 100263;
+	public static final int GLU_NURBS_ERROR14 = 100264;
+	public static final int GLU_NURBS_ERROR15 = 100265;
+	public static final int GLU_NURBS_ERROR16 = 100266;
+	public static final int GLU_NURBS_ERROR17 = 100267;
+	public static final int GLU_NURBS_ERROR18 = 100268;
+	public static final int GLU_NURBS_ERROR19 = 100269;
+	public static final int GLU_NURBS_ERROR20 = 100270;
+	public static final int GLU_NURBS_ERROR21 = 100271;
+	public static final int GLU_NURBS_ERROR22 = 100272;
+	public static final int GLU_NURBS_ERROR23 = 100273;
+	public static final int GLU_NURBS_ERROR24 = 100274;
+	public static final int GLU_NURBS_ERROR25 = 100275;
+	public static final int GLU_NURBS_ERROR26 = 100276;
+	public static final int GLU_NURBS_ERROR27 = 100277;
+	public static final int GLU_NURBS_ERROR28 = 100278;
+	public static final int GLU_NURBS_ERROR29 = 100279;
+	public static final int GLU_NURBS_ERROR30 = 100280;
+	public static final int GLU_NURBS_ERROR31 = 100281;
+	public static final int GLU_NURBS_ERROR32 = 100282;
+	public static final int GLU_NURBS_ERROR33 = 100283;
+	public static final int GLU_NURBS_ERROR34 = 100284;
+	public static final int GLU_NURBS_ERROR35 = 100285;
+	public static final int GLU_NURBS_ERROR36 = 100286;
+	public static final int GLU_NURBS_ERROR37 = 100287;
+	
+	/* Contours types -- obsolete! */
+	public static final int GLU_CW = 100120;
+	public static final int GLU_CCW = 100121;
+	public static final int GLU_INTERIOR = 100122;
+	public static final int GLU_EXTERIOR = 100123;
+	public static final int GLU_UNKNOWN = 100124;
+	
+	/* Names without "TESS_" prefix */
+	public static final int GLU_BEGIN = GLU_TESS_BEGIN;
+	public static final int GLU_VERTEX = GLU_TESS_VERTEX;
+	public static final int GLU_END = GLU_TESS_END;
+	public static final int GLU_ERROR = GLU_TESS_ERROR;
+	public static final int GLU_EDGE_FLAG = GLU_TESS_EDGE_FLAG;
+	
+	
+	public static final native void gluBeginCurve (int nobj);
+	public static final native void gluEndCurve (int nobj);
+	public static final native void gluBeginPolygon (int tess);
+	public static final native void gluEndPolygon (int tess);
+	public static final native void gluBeginSurface (int nobj);
+	public static final native void gluEndSurface (int nobj);
+	public static final native void gluBeginTrim (int nobj);
+	public static final native void gluEndTrim (int nobj);
+	public static final native int gluBuild1DMipmaps (int target, int componenets, int width, int format, int type, int data); /* MULTIPLES TYPES ARRAY */
+	public static final native int gluBuild2DMipmaps (int target, int componenets, int width, int height, int format, int type, byte[] data); /* MULTIPLES TYPES ARRAY */
+	public static final native void gluCylinder (int qobj, double baseRadius, double topRadius, double height, int slices, int stacks);
+	public static final native void gluDeleteNurbsRenderer (int nobj);
+	public static final native void gluDeleteQuadric (int qobj);
+	public static final native void gluDeleteTess (int tess);
+	public static final native void gluDisk (int qobj, double innerRadius, double outerRadius, int slices, int loops);
+	public static final native int gluErrorString (int errCode);  /* SHOULD RETURN A STRING */
+	public static final native void gluGetNurbsProperty (int nobj, int property, float[] value);
+	public static final native int gluGetString (int name); /* SHOULD RETURN A STRING */
+	public static final native void gluGetTessProperty (int tess, int which, double[] value);
+	public static final native void gluLoadSamplingMatrices (int nobj, float[] modelMatrix, float[] projMatrix, int[] viewport);
+	public static final native void gluLookAt (double eyex, double eyey, double eyez, double centerx, double centery, double centerz, double upx, double upy, double upz);
+	public static final native int gluNewNurbsRenderer ();
+	public static final native int gluNewQuadric ();
+	public static final native int gluNewTess ();
+	public static final native void gluNextContour (int tess, int type);
+	public static final native void gluNurbsCallback (int nobj, int which, int fn);
+	public static final native void gluNurbsCurve (int nobj, int nknots, float[] knot, int stride, float[] ctlarray, int order, int type);
+	public static final native void gluNurbsProperty (int nobj, int property, float value);
+	public static final native void gluNurbsSurface (int nobj, int sknot_count, float[] sknot, int tknot_count, float[] tknot, int s_stride, int t_stride, float[] ctlarray, int sorder, int torder, int type);
+	public static final native void gluOrtho2D (double left, double right, double bottom, double top);
+	public static final native void gluPartialDisk (int qobj, double innerRadius, double outerRadius, int slices, int loops, double startAngle, double sweepAngle);
+	public static final native void gluPerspective (double fovy, double aspect, double zNear, double zFar);
+	public static final native void gluPickMatrix (double x, double y, double width, double height, int[] viewport);
+	public static final native int gluProject (double objx, double objy, double objz,double[] modelMatrix, double[] projMatrix, int[] viewport, double[] winx, double[] winy, double[] winz);
+	public static final native void gluPwlCurve (int nobj, int count, float[] array, int stride, int type);
+	public static final native void gluQuadricCallback (int qobj, int which, int fn);
+	public static final native void gluQuadricDrawStyle (int qobj, int drawStyle);
+	public static final native void gluQuadricNormals (int qobj, int normals);
+	public static final native void gluQuadricOrientation (int qobj, int orientation);
+	public static final native void gluQuadricTexture (int qobj, boolean textureCoords);
+	public static final native int gluScaleImage (int format, int widthin, int heightin, int typein, int datain, int widthout, int heightout, int typeout, int dataout); /*MULTIPLES TYPES ARRAYS*/
+	public static final native void gluSphere (int qobj, double radius, int slices, int stacks);
+	public static final native void gluTessBeginContour (int tess);
+	public static final native void gluTessEndContour (int tess);
+	public static final native void gluTessBeginPolygon (int tess, int polygon_data);
+	public static final native void gluTessEndPolygon (int tess);
+	public static final native void gluTessCallback (int tess, int which, int fn);
+	public static final native void gluTessNormal (int tess, double x, double y, double z);
+	public static final native void gluTessProperty (int tess, int property, double value); /* CHECK MSDN, VALUE'S TYPE IS DOUBLE */
+	public static final native void gluTessVertex (int tess, double[] coords, int data);
+	public static final native int gluUnProject (double winx, double winy, double winz, double[] modelMatrix, double[] projMatrix, int[] viewport, double[] objx, double[] objy, double[] objz);
+}
diff --git a/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/GLYPHMETRICSFLOAT.java b/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/GLYPHMETRICSFLOAT.java
new file mode 100644
index 0000000000..4da0a94c4b
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/GLYPHMETRICSFLOAT.java
@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl;
+
+
+public class GLYPHMETRICSFLOAT {
+    public float gmfBlackBoxX;
+    public float gmfBlackBoxY;
+    public float gmfptGlyphOrigin_x;
+    public float gmfptGlyphOrigin_y;
+    public float gmfCellIncX;
+    public float gmfCellIncY;
+	public static final int sizeof = 24;
+}
diff --git a/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/ImageDataUtil.java b/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/ImageDataUtil.java
new file mode 100644
index 0000000000..d9002851c4
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/ImageDataUtil.java
@@ -0,0 +1,524 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl;
+
+
+public class ImageDataUtil {
+	/**
+	 * Alpha mode, values 0 - 255 specify global alpha level
+	 */
+	static final int
+		ALPHA_OPAQUE = 255,           // Fully opaque (ignores any alpha data)
+		ALPHA_TRANSPARENT = 0,        // Fully transparent (ignores any alpha data)
+		ALPHA_CHANNEL_SEPARATE = -1,  // Use alpha channel from separate alphaData
+		ALPHA_CHANNEL_SOURCE = -2,    // Use alpha channel embedded in sourceData
+		ALPHA_MASK_UNPACKED = -3,     // Use transparency mask formed by bytes in alphaData (non-zero is opaque)
+		ALPHA_MASK_PACKED = -4,       // Use transparency mask formed by packed bits in alphaData
+		ALPHA_MASK_INDEX = -5,        // Consider source palette indices transparent if in alphaData array
+		ALPHA_MASK_RGB = -6;          // Consider source RGBs transparent if in RGB888 format alphaData array
+		
+	/**
+	 * Data types (internal)
+	 */
+	private static final int
+		// direct / true color formats with arbitrary masks & shifts
+		TYPE_GENERIC_8 = 0,
+		TYPE_GENERIC_16_MSB = 1,
+		TYPE_GENERIC_16_LSB = 2,
+		TYPE_GENERIC_24 = 3,
+		TYPE_GENERIC_32_MSB = 4,
+		TYPE_GENERIC_32_LSB = 5,
+		// palette indexed color formats
+		TYPE_INDEX_8 = 6,
+		TYPE_INDEX_4 = 7,
+		TYPE_INDEX_2 = 8,
+		TYPE_INDEX_1_MSB = 9,
+		TYPE_INDEX_1_LSB = 10;
+		
+	/**
+	 * Byte and bit order constants.
+	 */
+	static final int LSB_FIRST = 0;
+	static final int MSB_FIRST = 1;
+	
+	/**
+	 * Blit operation bits to be OR'ed together to specify the desired operation.
+	 */
+	static final int
+		BLIT_SRC = 1,     // copy source directly, else applies logic operations
+		BLIT_ALPHA = 2,   // enable alpha blending
+		BLIT_DITHER = 4;  // enable dithering in low color modes
+		
+	/**
+	 * Arbitrary channel width data to 8-bit conversion table.
+	 */
+	static final byte[][] ANY_TO_EIGHT = new byte[9][];
+	static {
+		for (int b = 0; b < 9; ++b) {
+			byte[] data = ANY_TO_EIGHT[b] = new byte[1 << b];
+			if (b == 0) continue;
+			int inc = 0;
+			for (int bit = 0x10000; (bit >>= b) != 0;) inc |= bit;
+			for (int v = 0, p = 0; v < 0x10000; v+= inc) data[p++] = (byte)(v >> 8);
+		}
+	}
+
+	/**
+	 * Blits a direct palette image into a direct palette image.
+	 * <p>
+	 * Note: When the source and destination depth, order and masks
+	 * are pairwise equal and the blitter operation is BLIT_SRC,
+	 * the masks are ignored.  Hence when not changing the image
+	 * data format, 0 may be specified for the masks.
+	 * </p>
+	 * 
+	 * @param op the blitter operation: a combination of BLIT_xxx flags
+	 *        (see BLIT_xxx constants)
+	 * @param srcData the source byte array containing image data
+	 * @param srcDepth the source depth: one of 8, 16, 24, 32
+	 * @param srcStride the source number of bytes per line
+	 * @param srcOrder the source byte ordering: one of MSB_FIRST or LSB_FIRST;
+	 *        ignored if srcDepth is not 16 or 32
+	 * @param srcX the top-left x-coord of the source blit region
+	 * @param srcY the top-left y-coord of the source blit region
+	 * @param srcWidth the width of the source blit region
+	 * @param srcHeight the height of the source blit region
+	 * @param srcRedMask the source red channel mask
+	 * @param srcGreenMask the source green channel mask
+	 * @param srcBlueMask the source blue channel mask
+	 * @param alphaMode the alpha blending or mask mode, may be
+	 *        an integer 0-255 for global alpha; ignored if BLIT_ALPHA
+	 *        not specified in the blitter operations
+	 *        (see ALPHA_MODE_xxx constants)
+	 * @param alphaData the alpha blending or mask data, varies depending
+	 *        on the value of alphaMode and sometimes ignored
+	 * @param alphaStride the alpha data number of bytes per line
+	 * @param alphaX the top-left x-coord of the alpha blit region
+	 * @param alphaY the top-left y-coord of the alpha blit region
+	 * @param destData the destination byte array containing image data
+	 * @param destDepth the destination depth: one of 8, 16, 24, 32
+	 * @param destStride the destination number of bytes per line
+	 * @param destOrder the destination byte ordering: one of MSB_FIRST or LSB_FIRST;
+	 *        ignored if destDepth is not 16 or 32
+	 * @param destX the top-left x-coord of the destination blit region
+	 * @param destY the top-left y-coord of the destination blit region
+	 * @param destWidth the width of the destination blit region
+	 * @param destHeight the height of the destination blit region
+	 * @param destRedMask the destination red channel mask
+	 * @param destGreenMask the destination green channel mask
+	 * @param destBlueMask the destination blue channel mask
+	 * @param flipX if true the resulting image is flipped along the vertical axis
+	 * @param flipY if true the resulting image is flipped along the horizontal axis
+	 */
+	static void blit(int op,
+		byte[] srcData, int srcDepth, int srcStride, int srcOrder,
+		int srcX, int srcY, int srcWidth, int srcHeight,
+		int srcRedMask, int srcGreenMask, int srcBlueMask,
+		int alphaMode, byte[] alphaData, int alphaStride, int alphaX, int alphaY,
+		byte[] destData, int destDepth, int destStride, int destOrder,
+		int destX, int destY, int destWidth, int destHeight,
+		int destRedMask, int destGreenMask, int destBlueMask,
+		boolean flipX, boolean flipY) {
+		if ((destWidth <= 0) || (destHeight <= 0) || (alphaMode == ALPHA_TRANSPARENT)) return;
+
+		// these should be supplied as params later
+		final int srcAlphaMask = 0, destAlphaMask = 0;
+
+		/*** Prepare scaling data ***/
+		final int dwm1 = destWidth - 1;
+		final int sfxi = (dwm1 != 0) ? (int)((((long)srcWidth << 16) - 1) / dwm1) : 0;
+		final int dhm1 = destHeight - 1;
+		final int sfyi = (dhm1 != 0) ? (int)((((long)srcHeight << 16) - 1) / dhm1) : 0;
+
+		/*** Prepare source-related data ***/
+		final int sbpp, stype;
+		switch (srcDepth) {
+			case 8:
+				sbpp = 1;
+				stype = TYPE_GENERIC_8;
+				break;
+			case 16:
+				sbpp = 2;
+				stype = (srcOrder == MSB_FIRST) ? TYPE_GENERIC_16_MSB : TYPE_GENERIC_16_LSB;
+				break;
+			case 24:
+				sbpp = 3;
+				stype = TYPE_GENERIC_24;
+				break;
+			case 32:
+				sbpp = 4;
+				stype = (srcOrder == MSB_FIRST) ? TYPE_GENERIC_32_MSB : TYPE_GENERIC_32_LSB;
+				break;
+			default:
+				//throw new IllegalArgumentException("Invalid source type");
+				return;
+		}			
+		int spr = srcY * srcStride + srcX * sbpp;
+
+		/*** Prepare destination-related data ***/
+		final int dbpp, dtype;
+		switch (destDepth) {
+			case 8:
+				dbpp = 1;
+				dtype = TYPE_GENERIC_8;
+				break;
+			case 16:
+				dbpp = 2;
+				dtype = (destOrder == MSB_FIRST) ? TYPE_GENERIC_16_MSB : TYPE_GENERIC_16_LSB;
+				break;
+			case 24:
+				dbpp = 3;
+				dtype = TYPE_GENERIC_24;
+				break;
+			case 32:
+				dbpp = 4;
+				dtype = (destOrder == MSB_FIRST) ? TYPE_GENERIC_32_MSB : TYPE_GENERIC_32_LSB;
+				break;
+			default:
+				//throw new IllegalArgumentException("Invalid destination type");
+				return;
+		}			
+		int dpr = ((flipY) ? destY + dhm1 : destY) * destStride + ((flipX) ? destX + dwm1 : destX) * dbpp;
+		final int dprxi = (flipX) ? -dbpp : dbpp;
+		final int dpryi = (flipY) ? -destStride : destStride;
+
+		/*** Prepare special processing data ***/
+		int apr;
+		if ((op & BLIT_ALPHA) != 0) {
+			switch (alphaMode) {
+				case ALPHA_MASK_UNPACKED:
+				case ALPHA_CHANNEL_SEPARATE:
+					if (alphaData == null) alphaMode = 0x10000;
+					apr = alphaY * alphaStride + alphaX;
+					break;
+				case ALPHA_MASK_PACKED:
+					if (alphaData == null) alphaMode = 0x10000;
+					alphaStride <<= 3;
+					apr = alphaY * alphaStride + alphaX;
+					break;
+				case ALPHA_MASK_INDEX:
+					//throw new IllegalArgumentException("Invalid alpha type");
+					return;
+				case ALPHA_MASK_RGB:
+					if (alphaData == null) alphaMode = 0x10000;
+					apr = 0;
+					break;
+				default:
+					alphaMode = (alphaMode << 16) / 255; // prescale
+				case ALPHA_CHANNEL_SOURCE:
+					apr = 0;
+					break;
+			}
+		} else {
+			alphaMode = 0x10000;
+			apr = 0;
+		}
+
+		/*** Blit ***/
+		int dp = dpr;
+		int sp = spr;
+		if ((alphaMode == 0x10000) && (stype == dtype) &&
+			(srcRedMask == destRedMask) && (srcGreenMask == destGreenMask) &&
+			(srcBlueMask == destBlueMask) && (srcAlphaMask == destAlphaMask)) {
+			/*** Fast blit (straight copy) ***/
+			switch (sbpp) {
+				case 1:
+					for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+						for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+							destData[dp] = srcData[sp];
+							sp += (sfx >>> 16);
+						}
+					}
+					break;					
+				case 2:
+					for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+						for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+							destData[dp] = srcData[sp];
+							destData[dp + 1] = srcData[sp + 1];
+							sp += (sfx >>> 16) * 2;
+						}
+					}
+					break;
+				case 3:
+					for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+						for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+							destData[dp] = srcData[sp];
+							destData[dp + 1] = srcData[sp + 1];
+							destData[dp + 2] = srcData[sp + 2];
+							sp += (sfx >>> 16) * 3;
+						}
+					}
+					break;
+				case 4:
+					for (int dy = destHeight, sfy = sfyi; dy > 0; --dy, sp = spr += (sfy >>> 16) * srcStride, sfy = (sfy & 0xffff) + sfyi, dp = dpr += dpryi) {
+						for (int dx = destWidth, sfx = sfxi; dx > 0; --dx, dp += dprxi, sfx = (sfx & 0xffff) + sfxi) {
+							destData[dp] = srcData[sp];
+							destData[dp + 1] = srcData[sp + 1];
+							destData[dp + 2] = srcData[sp + 2];
+							destData[dp + 3] = srcData[sp + 3];
+							sp += (sfx >>> 16) * 4;
+						}
+					}
+					break;
+			}
+			return;
+		}
+		/*** Comprehensive blit (apply transformations) ***/
+		final int srcRedShift = getChannelShift(srcRedMask);
+		final byte[] srcReds = ANY_TO_EIGHT[getChannelWidth(srcRedMask, srcRedShift)];
+		final int srcGreenShift = getChannelShift(srcGreenMask);
+		final byte[] srcGreens = ANY_TO_EIGHT[getChannelWidth(srcGreenMask, srcGreenShift)];
+		final int srcBlueShift = getChannelShift(srcBlueMask);
+		final byte[] srcBlues = ANY_TO_EIGHT[getChannelWidth(srcBlueMask, srcBlueShift)];
+		final int srcAlphaShift = getChannelShift(srcAlphaMask);
+		final byte[] srcAlphas = ANY_TO_EIGHT[getChannelWidth(srcAlphaMask, srcAlphaShift)];
+
+		final int destRedShift = getChannelShift(destRedMask);
+		final int destRedWidth = getChannelWidth(destRedMask, destRedShift);
+		final byte[] destReds = ANY_TO_EIGHT[destRedWidth];
+		final int destRedPreShift = 8 - destRedWidth;
+		final int destGreenShift = getChannelShift(destGreenMask);
+		final int destGreenWidth = getChannelWidth(destGreenMask, destGreenShift);
+		final byte[] destGreens = ANY_TO_EIGHT[destGreenWidth];
+		final int destGreenPreShift = 8 - destGreenWidth;
+		final int destBlueShift = getChannelShift(destBlueMask);
+		final int destBlueWidth = getChannelWidth(destBlueMask, destBlueShift);
+		final byte[] destBlues = ANY_TO_EIGHT[destBlueWidth];
+		final int destBluePreShift = 8 - destBlueWidth;
+		final int destAlphaShift = getChannelShift(destAlphaMask);
+		final int destAlphaWidth = getChannelWidth(destAlphaMask, destAlphaShift);
+		final byte[] destAlphas = ANY_TO_EIGHT[destAlphaWidth];
+		final int destAlphaPreShift = 8 - destAlphaWidth;
+
+		int ap = apr, alpha = alphaMode;
+		int r = 0, g = 0, b = 0, a = 0;
+		int rq = 0, gq = 0, bq = 0, aq = 0;
+		for (int dy = destHeight, sfy = sfyi; dy > 0; --dy,
+				sp = spr += (sfy >>> 16) * srcStride,
+				ap = apr += (sfy >>> 16) * alphaStride,
+				sfy = (sfy & 0xffff) + sfyi,
+				dp = dpr += dpryi) {
+			for (int dx = destWidth, sfx = sfxi; dx > 0; --dx,
+					dp += dprxi,
+					sfx = (sfx & 0xffff) + sfxi) {
+				/*** READ NEXT PIXEL ***/
+				switch (stype) {
+					case TYPE_GENERIC_8: {
+						final int data = srcData[sp] & 0xff;
+						sp += (sfx >>> 16);
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+					case TYPE_GENERIC_16_MSB: {
+						final int data = ((srcData[sp] & 0xff) << 8) | (srcData[sp + 1] & 0xff);
+						sp += (sfx >>> 16) * 2;
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+					case TYPE_GENERIC_16_LSB: {
+						final int data = ((srcData[sp + 1] & 0xff) << 8) | (srcData[sp] & 0xff);
+						sp += (sfx >>> 16) * 2;
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+					case TYPE_GENERIC_24: {
+						final int data = (( ((srcData[sp] & 0xff) << 8) |
+							(srcData[sp + 1] & 0xff)) << 8) |
+							(srcData[sp + 2] & 0xff);
+						sp += (sfx >>> 16) * 3;
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+					case TYPE_GENERIC_32_MSB: {
+						final int data = (( (( ((srcData[sp] & 0xff) << 8) |
+							(srcData[sp + 1] & 0xff)) << 8) |
+							(srcData[sp + 2] & 0xff)) << 8) |
+							(srcData[sp + 3] & 0xff);
+						sp += (sfx >>> 16) * 4;
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+					case TYPE_GENERIC_32_LSB: {
+						final int data = (( (( ((srcData[sp + 3] & 0xff) << 8) |
+							(srcData[sp + 2] & 0xff)) << 8) |
+							(srcData[sp + 1] & 0xff)) << 8) |
+							(srcData[sp] & 0xff);
+						sp += (sfx >>> 16) * 4;
+						r = srcReds[(data & srcRedMask) >>> srcRedShift] & 0xff;
+						g = srcGreens[(data & srcGreenMask) >>> srcGreenShift] & 0xff;
+						b = srcBlues[(data & srcBlueMask) >>> srcBlueShift] & 0xff;
+						a = srcAlphas[(data & srcAlphaMask) >>> srcAlphaShift] & 0xff;
+					} break;
+				}
+
+				/*** DO SPECIAL PROCESSING IF REQUIRED ***/
+				switch (alphaMode) {
+					case ALPHA_CHANNEL_SEPARATE:
+						alpha = ((alphaData[ap] & 0xff) << 16) / 255;
+						ap += (sfx >> 16);
+						break;
+					case ALPHA_CHANNEL_SOURCE:
+						alpha = (a << 16) / 255;
+						break;
+					case ALPHA_MASK_UNPACKED:
+						alpha = (alphaData[ap] != 0) ? 0x10000 : 0;
+						ap += (sfx >> 16);
+						break;						
+					case ALPHA_MASK_PACKED:
+						alpha = (alphaData[ap >> 3] << ((ap & 7) + 9)) & 0x10000;
+						ap += (sfx >> 16);
+						break;
+					case ALPHA_MASK_RGB:
+						alpha = 0x10000;
+						for (int i = 0; i < alphaData.length; i += 3) {
+							if ((r == alphaData[i]) && (g == alphaData[i + 1]) && (b == alphaData[i + 2])) {
+								alpha = 0x0000;
+								break;
+							}
+						}
+						break;
+				}
+				if (alpha != 0x10000) {
+					if (alpha == 0x0000) continue;
+					switch (dtype) {
+						case TYPE_GENERIC_8: {
+							final int data = destData[dp] & 0xff;
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+						case TYPE_GENERIC_16_MSB: {
+							final int data = ((destData[dp] & 0xff) << 8) | (destData[dp + 1] & 0xff);
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+						case TYPE_GENERIC_16_LSB: {
+							final int data = ((destData[dp + 1] & 0xff) << 8) | (destData[dp] & 0xff);
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+						case TYPE_GENERIC_24: {
+							final int data = (( ((destData[dp] & 0xff) << 8) |
+								(destData[dp + 1] & 0xff)) << 8) |
+								(destData[dp + 2] & 0xff);
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+						case TYPE_GENERIC_32_MSB: {
+							final int data = (( (( ((destData[dp] & 0xff) << 8) |
+								(destData[dp + 1] & 0xff)) << 8) |
+								(destData[dp + 2] & 0xff)) << 8) |
+								(destData[dp + 3] & 0xff);
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+						case TYPE_GENERIC_32_LSB: {
+							final int data = (( (( ((destData[dp + 3] & 0xff) << 8) |
+								(destData[dp + 2] & 0xff)) << 8) |
+								(destData[dp + 1] & 0xff)) << 8) |
+								(destData[dp] & 0xff);
+							rq = destReds[(data & destRedMask) >>> destRedShift] & 0xff;
+							gq = destGreens[(data & destGreenMask) >>> destGreenShift] & 0xff;
+							bq = destBlues[(data & destBlueMask) >>> destBlueShift] & 0xff;
+							aq = destAlphas[(data & destAlphaMask) >>> destAlphaShift] & 0xff;
+						} break;
+					}
+					// Perform alpha blending
+					a = aq + ((a - aq) * alpha >> 16);
+					r = rq + ((r - rq) * alpha >> 16);
+					g = gq + ((g - gq) * alpha >> 16);
+					b = bq + ((b - bq) * alpha >> 16);
+				}
+
+				/*** WRITE NEXT PIXEL ***/
+				final int data = 
+					(r >>> destRedPreShift << destRedShift) |
+					(g >>> destGreenPreShift << destGreenShift) |
+					(b >>> destBluePreShift << destBlueShift) |
+					(a >>> destAlphaPreShift << destAlphaShift);
+				switch (dtype) {
+					case TYPE_GENERIC_8: {
+						destData[dp] = (byte) data;
+					} break;
+					case TYPE_GENERIC_16_MSB: {
+						destData[dp] = (byte) (data >>> 8);
+						destData[dp + 1] = (byte) (data & 0xff);
+					} break;
+					case TYPE_GENERIC_16_LSB: {
+						destData[dp] = (byte) (data & 0xff);
+						destData[dp + 1] = (byte) (data >>> 8);
+					} break;
+					case TYPE_GENERIC_24: {
+						destData[dp] = (byte) (data >>> 16);
+						destData[dp + 1] = (byte) (data >>> 8);
+						destData[dp + 2] = (byte) (data & 0xff);
+					} break;
+					case TYPE_GENERIC_32_MSB: {
+						destData[dp] = (byte) (data >>> 24);
+						destData[dp + 1] = (byte) (data >>> 16);
+						destData[dp + 2] = (byte) (data >>> 8);
+						destData[dp + 3] = (byte) (data & 0xff);
+					} break;
+					case TYPE_GENERIC_32_LSB: {
+						destData[dp] = (byte) (data & 0xff);
+						destData[dp + 1] = (byte) (data >>> 8);
+						destData[dp + 2] = (byte) (data >>> 16);
+						destData[dp + 3] = (byte) (data >>> 24);
+					} break;
+				}
+			}
+		}			
+	}
+
+	/**
+	 * Computes the required channel shift from a mask.
+	 */
+	static int getChannelShift(int mask) {
+		if (mask == 0) return 0;
+		int i;
+		for (i = 0; ((mask & 1) == 0) && (i < 32); ++i) {
+			mask >>>= 1;
+		}
+		return i;
+	}
+	
+	/**
+	 * Computes the required channel width (depth) from a mask.
+	 */
+	static int getChannelWidth(int mask, int shift) {
+		if (mask == 0) return 0;
+		int i;
+		mask >>>= shift;
+		for (i = shift; ((mask & 1) != 0) && (i < 32); ++i) {
+			mask >>>= 1;
+		}
+		return i - shift;
+	}
+}
diff --git a/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/Library.java b/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/Library.java
new file mode 100644
index 0000000000..7a486e3eca
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/common/org/eclipse/swt/opengl/Library.java
@@ -0,0 +1,60 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl;
+
+
+public class Library {
+
+/**
+ * Returns the platform name.
+ *
+ * @return the platform name of the currently running SWT
+ */
+static String getPlatform () {
+	String [] names = new String [] {"motif", "gtk", "win32", "photon", "carbon"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
+	for (int i = 0; i < names.length; i++) {
+		try {
+			Class.forName("org.eclipse.swt.internal."+names[i]+".OS"); //$NON-NLS-1$ //$NON-NLS-2$
+			return names[i];
+		} catch (ClassNotFoundException e) {
+		}
+	}
+	return "unknown"; //$NON-NLS-1$
+}
+
+/**
+ * Loads the shared library that matches the version of the
+ * Java code which is currently running.  SWT shared libraries
+ * follow an encoding scheme where the major, minor and revision
+ * numbers are embedded in the library name and this along with
+ * <code>name</code> is used to load the library.  If this fails,
+ * <code>name</code> is used in another attempt to load the library,
+ * this time ignoring the SWT version encoding scheme.
+ *
+ * @param name the name of the library to load
+ */
+public static void loadLibrary (String name) {
+	/*
+     * Include platform name to support different windowing systems
+     * on same operating system.
+	 */
+	String platform = getPlatform ();
+	
+	try {
+		String newName = name + "-" + platform; //$NON-NLS-1$ //$NON-NLS-2$
+		System.loadLibrary (newName);
+		return;
+	} catch (UnsatisfiedLinkError e1) {		
+		throw e1;
+	}
+}
+
+}
diff --git a/bundles/org.eclipse.swt.opengl/gtk/gl_library/build.sh b/bundles/org.eclipse.swt.opengl/gtk/gl_library/build.sh
new file mode 100644
index 0000000000..176fd076f6
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/gtk/gl_library/build.sh
@@ -0,0 +1,32 @@
+#*******************************************************************************
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials 
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+#     Kevin Cornell (Rational Software Corporation)
+#     Tom Tromey (Red Hat, Inc.)
+#*******************************************************************************
+
+#!/bin/sh
+
+# Some UNIX/Linux compilers don't like <CR>'s in files (DOS format).
+fixup_files=`grep -l "\
+" *.[ch]`
+if test -n "$fixup_files"; then
+    echo "Converting files from DOS to UNIX format:"
+    for file in $fixup_files; do
+	echo "    $file"
+	ex $file << EOF 2> /dev/null
+g/\$/s///
+w
+EOF
+    done
+fi
+
+# Determine the operating system being built
+
+make -f make_gtk.mak ${1+"$@"}
diff --git a/bundles/org.eclipse.swt.opengl/gtk/gl_library/gtkglext.c b/bundles/org.eclipse.swt.opengl/gtk/gl_library/gtkglext.c
new file mode 100644
index 0000000000..7d6c122afd
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/gtk/gl_library/gtkglext.c
@@ -0,0 +1,179 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+#include "swt.h"
+#include <gtk/gtkgl.h>
+#include <gdk/gdkgl.h>
+
+#ifndef NO_gdk_1gl_1config_1new
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gdk_1gl_1config_1new
+	(JNIEnv *env, jclass that, jintArray arg0)
+{
+	jint *lparg0=NULL;
+	jint rc;
+
+	DEBUG_CALL("gdk_1gl_1config_1new\n")
+
+	if (arg0) lparg0 = (*env)->GetIntArrayElements(env, arg0, NULL);
+	rc = (jint)gdk_gl_config_new(lparg0);
+	if (arg0) (*env)->ReleaseIntArrayElements(env, arg0, lparg0, 0);
+	return rc;
+}
+#endif
+
+#ifndef NO_gdk_1gl_1config_1new_1by_1mode
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gdk_1gl_1config_1new_1by_1mode
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gdk_1gl_1config_1new_1by_1mode\n")
+
+	return (jint)gdk_gl_config_new_by_mode(arg0);
+}
+#endif
+
+#ifndef NO_gdk_1gl_1context_1destroy
+JNIEXPORT void JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gdk_1gl_1context_1destroy
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gdk_1gl_1context_1destroy\n")
+
+	gdk_gl_context_destroy((GdkGLContext *)arg0);
+}
+#endif
+
+#ifndef NO_gdk_1gl_1context_1get_1current
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gdk_1gl_1context_1get_1current
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("gdk_1gl_1context_1get_1current\n")
+
+	return (jint)gdk_gl_context_get_current();
+}
+#endif
+
+#ifndef NO_gdk_1gl_1context_1get_1gl_1drawable
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gdk_1gl_1context_1get_1gl_1drawable
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gdk_1gl_1context_1get_1gl_1drawable\n")
+
+	return (jint)gdk_gl_context_get_gl_drawable((GdkGLContext *)arg0);
+}
+#endif
+
+#ifndef NO_gdk_1gl_1drawable_1gl_1begin
+JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gdk_1gl_1drawable_1gl_1begin
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("gdk_1gl_1drawable_1gl_1begin\n")
+
+	return (jboolean)gdk_gl_drawable_gl_begin((GdkGLDrawable *)arg0, (GdkGLContext *)arg1);
+}
+#endif
+
+#ifndef NO_gdk_1gl_1drawable_1gl_1end
+JNIEXPORT void JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gdk_1gl_1drawable_1gl_1end
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gdk_1gl_1drawable_1gl_1end\n")
+
+	gdk_gl_drawable_gl_end((GdkGLDrawable *)arg0);
+}
+#endif
+
+#ifndef NO_gdk_1gl_1drawable_1make_1current
+JNIEXPORT void JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gdk_1gl_1drawable_1make_1current
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("gdk_1gl_1drawable_1make_1current\n")
+
+	gdk_gl_drawable_make_current((GdkGLDrawable *)arg0, (GdkGLContext *)arg1);
+}
+#endif
+
+#ifndef NO_gdk_1gl_1drawable_1swap_1buffers
+JNIEXPORT void JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gdk_1gl_1drawable_1swap_1buffers
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gdk_1gl_1drawable_1swap_1buffers\n")
+
+	gdk_gl_drawable_swap_buffers((GdkGLDrawable *)arg0);
+}
+#endif
+
+#ifndef NO_gdk_1gl_1font_1use_1pango_1font
+JNIEXPORT void JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gdk_1gl_1font_1use_1pango_1font
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("gdk_1gl_1font_1use_1pango_1font\n")
+
+	gdk_gl_font_use_pango_font((PangoFontDescription *)arg0, arg1, arg2, arg3);
+}
+#endif
+
+#ifndef NO_gtk_1gl_1init
+JNIEXPORT void JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gtk_1gl_1init
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("gtk_1gl_1init\n")
+
+	gtk_gl_init((int *)arg0, (char ***)arg1);
+}
+#endif
+
+#ifndef NO_gtk_1widget_1create_1gl_1context
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gtk_1widget_1create_1gl_1context
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2, jint arg3)
+{
+	DEBUG_CALL("gtk_1widget_1create_1gl_1context\n")
+
+	return (jint)gtk_widget_create_gl_context((GtkWidget *)arg0, (GdkGLContext *)arg1, arg2, arg3);
+}
+#endif
+
+#ifndef NO_gtk_1widget_1get_1gl_1context
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gtk_1widget_1get_1gl_1context
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gtk_1widget_1get_1gl_1context\n")
+
+	return (jint)gtk_widget_get_gl_context((GtkWidget *)arg0);
+}
+#endif
+
+#ifndef NO_gtk_1widget_1get_1gl_1drawable
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gtk_1widget_1get_1gl_1drawable
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gtk_1widget_1get_1gl_1drawable\n")
+
+	return (jint)gtk_widget_get_gl_drawable((GtkWidget *)arg0);
+}
+#endif
+
+#ifndef NO_gtk_1widget_1get_1gl_1window
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gtk_1widget_1get_1gl_1window
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("gtk_1widget_1get_1gl_1window\n")
+
+	return (jint)gtk_widget_get_gl_window((GtkWidget *)arg0);
+}
+#endif
+
+#ifndef NO_gtk_1widget_1set_1gl_1capability
+JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_opengl_internal_gtk_GTKGLEXT_gtk_1widget_1set_1gl_1capability
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jboolean arg3, jint arg4)
+{
+	DEBUG_CALL("gtk_1widget_1set_1gl_1capability\n")
+
+	return (jboolean)gtk_widget_set_gl_capability((GtkWidget *)arg0, (GdkGLConfig *)arg1, (GdkGLContext *)arg2, arg3, arg4);
+}
+#endif
diff --git a/bundles/org.eclipse.swt.opengl/gtk/gl_library/make_gtk.mak b/bundles/org.eclipse.swt.opengl/gtk/gl_library/make_gtk.mak
new file mode 100644
index 0000000000..f6302df68f
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/gtk/gl_library/make_gtk.mak
@@ -0,0 +1,41 @@
+#*******************************************************************************
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials 
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+#*******************************************************************************
+
+# Define the installation directories for various products.
+JAVA_HOME   = /bluebird/teamswt/swt-builddir/ive/bin
+
+# Define the various shared libraries to be made.
+SWT_PREFIX   = gl
+WS_PREFIX    = gtk
+SWT_DLL      = lib$(SWT_PREFIX)-$(WS_PREFIX).so
+SWT_OBJ      = gl.c glu.c gtkglext.c
+
+GTKLIBS = `pkg-config --libs gthread-2.0 gtk+-2.0 gdkglext-1.0 gtkglext-1.0` -L/usr/X11R6/lib -lGL -lGLU -lm 
+GTKCFLAGS = `pkg-config --cflags gtk+-2.0 gdkglext-1.0 gtkglext-1.0`
+
+#
+# The following CFLAGS are for compiling the SWT OpenGL library.
+#
+CFLAGS = -O -s -shared \
+	-I./ \
+	-I$(JAVA_HOME)/include \
+	$(GTKCFLAGS) \
+	-Wall
+
+all: make_swt
+
+make_swt: $(SWT_DLL)
+
+$(SWT_DLL): $(SWT_OBJ)
+	gcc  $(CFLAGS) $(GTKLIBS) -o $(SWT_DLL) $(SWT_OBJ)
+	
+clean:
+	rm -f *.so *.o
diff --git a/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/GLContext.class b/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/GLContext.class
new file mode 100644
index 0000000000..976534792a
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/GLContext.class
diff --git a/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/GLContext.java b/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/GLContext.java
new file mode 100644
index 0000000000..73fba4e0b7
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/GLContext.java
@@ -0,0 +1,296 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl;
+
+
+import org.eclipse.swt.*;
+import org.eclipse.swt.graphics.*;
+import org.eclipse.swt.internal.gtk.*;
+import org.eclipse.swt.opengl.internal.gtk.*;
+import org.eclipse.swt.widgets.*;
+
+/**
+ * Instances of <code>GLContext</code> are used to draw on swt <code>Drawable</code>s 
+ * through invocations of provided OpenGL functions.
+ * <p>
+ * Application code must explicitly invoke the <code>GLContext.dispose ()</code> 
+ * method to release the operating system resources managed by each instance
+ * when those instances are no longer required. This is <em>particularly</em>
+ * important on Windows95 and Windows98 where the operating system has a limited
+ * number of device contexts available.
+ * </p>
+ */
+public class GLContext {
+	int handle;
+	int gc;
+	GCData data;
+	Widget widget;
+	int selectBufferPtr = 0;
+
+	static final int MSB_FIRST = 1;
+	static final int LSB_FIRST = 2;
+
+	/**
+	 * Constructs a new instance of this class which has been
+	 * configured to draw on the specified drawable.
+	 * <p>
+	 * You must dispose the <code>GLContext</code> when it is no longer required. 
+	 * </p>
+	 * 
+	 * @param drawable the drawable to draw on
+	 * @exception IllegalArgumentException <ul>
+	 *    <li>ERROR_NULL_ARGUMENT - if the drawable is null</li>
+	 * </ul>
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for gc creation</li>
+	 *    <li>ERROR_UNSUPPORTED_DEPTH - if the current display depth is not supported</li>
+	 * </ul>
+	 */
+	public GLContext (Drawable drawable) {
+		if (drawable == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);
+		this.data = new GCData ();
+		gc = drawable.internal_new_GC (data);
+		if (gc == 0) SWT.error (SWT.ERROR_NO_HANDLES);
+
+//		int attrib [] = {
+////			GTKGLEXT.GLX_LEVEL,
+////			0,
+////			GTKGLEXT.GDK_GL_MODE_RGBA,
+//			GTKGLEXT.GDK_GL_MODE_DOUBLE,
+//			GTKGLEXT.GDK_GL_MODE_DEPTH,
+//			24,//			depth,
+//			0
+//		};
+
+		// adding to next line causes badness: XGL.GDK_GL_MODE_INDEX |
+		int mode = GTKGLEXT.GDK_GL_MODE_RGB | GTKGLEXT.GDK_GL_MODE_DOUBLE | GTKGLEXT.GDK_GL_MODE_DEPTH;
+		int glconfig = GTKGLEXT.gdk_gl_config_new_by_mode (mode);
+//		int glconfig = GTKGLEXT.gdk_gl_config_new (attrib);
+		// for now assume that the Drawable is a Widget
+		this.widget = (Widget) drawable;
+
+		OS.gtk_widget_unrealize (widget.handle);
+		boolean success = GTKGLEXT.gtk_widget_set_gl_capability (
+			widget.handle,
+			glconfig,
+			0,
+			true,
+			GTKGLEXT.GDK_GL_RGBA_TYPE);
+		OS.gtk_widget_realize(widget.handle);
+		
+		handle = GTKGLEXT.gtk_widget_create_gl_context (widget.handle, 0, true, GTKGLEXT.GDK_GL_RGBA_TYPE);
+		if (handle == 0) SWT.error (SWT.ERROR_NO_HANDLES);
+	}
+	
+	public ImageData convertImageData (ImageData source) {
+		PaletteData palette = new PaletteData (0xff0000, 0xff00, 0xff);
+		ImageData newSource = new ImageData (source.width, source.height, 24, palette);
+		ImageDataUtil.blit (
+			1,
+			source.data,
+			source.depth,
+			source.bytesPerLine,
+			(source.depth != 16) ? MSB_FIRST : LSB_FIRST,
+			0,
+			0,
+			source.width,
+			source.height,
+			source.palette.redMask,
+			source.palette.greenMask,
+			source.palette.blueMask,
+			255,
+			null,
+			0,
+			0,
+			0,
+			newSource.data,
+			newSource.depth,
+			newSource.bytesPerLine,
+			(newSource.depth != 16) ? MSB_FIRST : LSB_FIRST,
+			0,
+			0,
+			newSource.width,
+			newSource.height,
+			newSource.palette.redMask,
+			newSource.palette.greenMask,
+			newSource.palette.blueMask,
+			false,
+			true);
+
+		return newSource;
+	}
+
+	/**
+	 * Disposes of the operating system resources associated with
+	 * the receiver. Applications must dispose of all <code>GLContext</code>s
+	 * that they allocate.
+	 */
+	public void dispose () {
+		if (handle == 0) return;
+
+// the following causes problems
+//		int current = GTKGLEXT.gdk_gl_context_get_current ();  
+//		if (current == handle) {
+//			GTKGLEXT.gdk_gl_drawable_make_current (0, 0);
+//		}
+		
+//		int xDisplay = data.display;
+//		if (XGL.glXGetCurrentContext () == handle) {
+//			XGL.glXMakeCurrent (xDisplay, 0, 0);
+//		}
+		if (selectBufferPtr != 0) OS.g_free(selectBufferPtr);
+		GTKGLEXT.gdk_gl_context_destroy (handle); 		
+//		XGL.glXDestroyContext (xDisplay, handle);
+
+		handle = 0;
+//		gdkDrawable = 0;
+		// drawable may be disposed
+		try {
+			((Drawable)widget).internal_dispose_GC (gc, data);
+		} catch (SWTException e) {
+		}
+		gc = 0;
+		data.context = data.drawable = data.layout = 0;
+		data.font = data.clipRgn = data.lineStyle = 0;
+		widget = null;
+		data.device = null;
+		data.image = null;
+		data = null;
+	}
+
+	public int[] getSelectBuffer (int selectBufferPtr, int[] selectBuffer) {
+		OS.memmove (selectBuffer, selectBufferPtr, selectBuffer.length * 4);
+		return selectBuffer;
+	}
+
+	public int getSelectBufferPtr (int[] selectBuffer) {
+		if (selectBufferPtr == 0) {
+			selectBufferPtr = OS.g_malloc (selectBuffer.length * 4);
+		}
+		OS.memmove (selectBufferPtr, selectBuffer, selectBuffer.length * 4);
+		return selectBufferPtr;
+	}
+
+	/**
+	 * Returns a boolean indicating whether the receiver is the current
+	 * <code>GLContext</code>.
+	 *  
+	 * @return true if the receiver is the current <code>GLContext</code>,
+	 * false otherwise
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_GRAPHIC_DISPOSED if the receiver is disposed</li>
+	 * </ul>
+	 */
+	public boolean isCurrent () {
+		if (isDisposed ()) 	SWT.error (SWT.ERROR_GRAPHIC_DISPOSED);
+		return GTKGLEXT.gdk_gl_context_get_current () == handle;  
+	}
+
+	/**
+	 * Returns a boolean indicating whether the <code>GLContext</code> has been
+	 * disposed.
+	 * <p>
+	 * This method gets the dispose state for the <code>GLContext</code>.
+	 * When a <code>GLContext</code> has been disposed, it is an error to
+	 * invoke any other method using the <code>GLContext</code>.
+	 *
+	 * @return true if the <code>GLContext</code> is disposed, false otherwise
+	 */
+	public boolean isDisposed () {
+		return handle == 0;
+	}
+
+	/**
+	 * Loads the specified bitmap font.
+	 * 
+	 * @param fdata
+	 * @param device
+	 * @param base
+	 * @param first
+	 * @param count
+	 */
+	public void loadBitmapFont (FontData fdata, Device device, int base, int startIndex, int length) {
+		Font font = new Font (device, fdata);
+//		int oldFont = OS.SelectObject (hDC, font.handle);
+		GTKGLEXT.gdk_gl_font_use_pango_font (font.handle, startIndex, length, base);
+//		OS.SelectObject (hDC, oldFont);
+		font.dispose ();
+	}
+
+	/**
+	 * Loads the specified outline font.
+	 * 
+	 * @param fdata
+	 * @param device
+	 * @param base
+	 * @param first
+	 * @param count
+	 * @param deviation
+	 * @param extrusion
+	 * @param format
+	 * @param lpgmf
+	 */
+	public void loadOutlineFont (FontData fdata, Device device, int base, int first,
+	int count, float deviation, float extrusion, int format, GLYPHMETRICSFLOAT[] lpgmf) {
+		// stub
+	}
+
+	/**
+	 * Resizes the receiver.
+	 * 
+	 * @param x
+	 * @param y
+	 * @param width
+	 * @param height
+	 */
+	public void resize (int x, int y, int width, int height) {
+		if (height == 0) height = 1;
+		GL.glViewport (x, y, width, height);
+		GL.glMatrixMode (GL.GL_PROJECTION);
+		GL.glLoadIdentity ();
+		GLU.gluPerspective (45.0f, (float) width / (float) height, 0.1f, 100.0f);
+		GL.glMatrixMode (GL.GL_MODELVIEW);
+		GL.glLoadIdentity ();
+	}
+
+	/**
+	 * Sets the receiver to be the current <code>GLContext</code>.
+	 * 
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_GRAPHIC_DISPOSED if the receiver is disposed</li>
+	 * </ul>
+	 */
+	public void setCurrent () {
+		if (isDisposed ()) SWT.error (SWT.ERROR_GRAPHIC_DISPOSED);
+		int currentContext = GTKGLEXT.gdk_gl_context_get_current ();
+		if (currentContext == handle) return;
+		if (currentContext != 0) {
+			int drawable = GTKGLEXT.gdk_gl_context_get_gl_drawable(currentContext);
+			GTKGLEXT.gdk_gl_drawable_gl_end (drawable);
+		}
+		int gdkDrawable = GTKGLEXT.gtk_widget_get_gl_drawable (widget.handle);
+		GTKGLEXT.gdk_gl_drawable_gl_begin (gdkDrawable, handle);
+		GTKGLEXT.gdk_gl_drawable_make_current (gdkDrawable, handle);
+	}
+
+	/**
+	 * Swaps the receiver's buffers.
+	 * 
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_GRAPHIC_DISPOSED if the receiver is disposed</li>
+	 * </ul>
+	 */
+	public void swapBuffers () {
+		if (isDisposed ()) SWT.error (SWT.ERROR_GRAPHIC_DISPOSED);
+		int gdkDrawable = GTKGLEXT.gtk_widget_get_gl_drawable (widget.handle); 
+		GTKGLEXT.gdk_gl_drawable_swap_buffers (gdkDrawable);
+	}
+}
diff --git a/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/internal/gtk/GTKEXT.class b/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/internal/gtk/GTKEXT.class
new file mode 100644
index 0000000000..5b71e55639
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/internal/gtk/GTKEXT.class
diff --git a/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/internal/gtk/GTKGLEXT.java b/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/internal/gtk/GTKGLEXT.java
new file mode 100644
index 0000000000..8e1c3e3742
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/gtk/org/eclipse/swt/opengl/internal/gtk/GTKGLEXT.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl.internal.gtk;
+
+import org.eclipse.swt.opengl.Library;
+
+public class GTKGLEXT {
+	
+	static {
+		Library.loadLibrary("gl");
+		GTKGLEXT.gtk_gl_init (0, 0);
+	}
+
+	public static final native int gdk_gl_config_new (int [] mode);
+	public static final native int gdk_gl_config_new_by_mode (int mode);
+	public static final native void gdk_gl_context_destroy (int glContext);
+	public static final native int gdk_gl_context_get_current ();
+	public static final native int gdk_gl_context_get_gl_drawable (int glContext);
+	public static final native boolean gdk_gl_drawable_gl_begin (int glDrawable, int glContext);
+	public static final native void gdk_gl_drawable_gl_end (int glDrawable);
+	public static final native void gdk_gl_drawable_make_current (int glDrawable, int glContext);
+	public static final native void gdk_gl_drawable_swap_buffers (int glDrawable);
+	public static final native void gdk_gl_font_use_pango_font (int font_desc, int first, int count, int list_base);
+	public static final native void gtk_gl_init (int argc, int argv);
+	public static final native int gtk_widget_create_gl_context (int widget, int share_list, boolean direct, int render_type);
+	public static final native int gtk_widget_get_gl_context (int widget);
+	public static final native int gtk_widget_get_gl_drawable (int widget);
+	public static final native int gtk_widget_get_gl_window (int widget);
+	public static final native boolean gtk_widget_set_gl_capability (int widget, int glconfig, int share_list, boolean direct, int render_type);
+	public static final int GDK_GL_MODE_DEPTH = 1 << 4;
+	public static final int GDK_GL_MODE_DOUBLE = 1 << 1;
+	public static final int GDK_GL_MODE_INDEX = 1 << 0;
+	public static final int GDK_GL_MODE_RGB = 0;
+	public static final int GDK_GL_MODE_RGBA = 0;
+	public static final int GDK_GL_RGBA_TYPE = 0x8014;
+}
diff --git a/bundles/org.eclipse.swt.opengl/motif/gl_library/build.csh b/bundles/org.eclipse.swt.opengl/motif/gl_library/build.csh
new file mode 100644
index 0000000000..dd0b6d9691
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/gl_library/build.csh
@@ -0,0 +1,69 @@
+#*******************************************************************************
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials 
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+#*******************************************************************************
+
+#!/bin/csh
+
+# Some UNIX/Linux compilers don't like <CR>'s in files (DOS format).
+set fixup_files = `grep -l "\
+" *.[ch]`
+if ( "$fixup_files" != "" ) then
+    echo "Converting files from DOS to UNIX format:"
+    foreach file ($fixup_files)
+	echo "    $file"
+	ex $file << EOF >& /dev/null
+g/
+\$/s///
+w
+EOF
+    end
+endif
+
+# Determine the operating system being built
+set OS=`uname -s`
+switch ($OS )
+	case AIX:
+        if ( "$1" == "clean" ) then
+            make -f make_aix.mak clean
+        else
+            echo "Building AIX version of SWT OpenGL library."
+            make -f make_aix.mak make_swt
+        endif
+        breaksw
+
+    case Linux:
+		if ( "$1" == "clean" ) then
+		    make -f make_linux.mak clean
+		else
+		    echo "Building Linux version of SWT OpenGL library."
+		    make -f make_linux.mak make_swt
+		endif
+		breaksw
+	
+    case SunOS:
+        if ( "$1" == "clean" ) then
+            make -f make_solaris.mak clean
+        else
+            echo "Building Solaris version of SWT OpenGL library."
+            make -f make_solaris.mak make_swt
+        endif
+        breaksw
+
+    case HP-UX:
+        if ( "$1" == "clean" ) then
+            make -f make_hpux.mak clean
+        else
+            echo "Building HP-UX version of SWT OpenGL library."
+            make -f make_hpux.mak make_swt
+        endif
+        breaksw
+
+    default:
+       echo "Unknown OS -- build aborted"
+       breaksw
+endsw
diff --git a/bundles/org.eclipse.swt.opengl/motif/gl_library/glx.c b/bundles/org.eclipse.swt.opengl/motif/gl_library/glx.c
new file mode 100644
index 0000000000..4fca4eb8eb
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/gl_library/glx.c
@@ -0,0 +1,232 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+#include <GL/glx.h>
+#include "swt.h"
+#include "structs.h"
+
+#define XGL_NATIVE(func) Java_org_eclipse_swt_opengl_internal_motif_XGL_##func
+
+JNIEXPORT jint JNICALL XGL_NATIVE(glXChooseVisual)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jintArray arg2)
+{
+	jint *lparg2=NULL;
+	jint rc;
+
+	DEBUG_CALL("glXChooseVisual\n")
+
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	rc = (jint)glXChooseVisual((Display *)arg0, arg1, (int *)lparg2);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	return rc;
+}
+
+JNIEXPORT void JNICALL XGL_NATIVE(glXCopyContext)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("glXCopyContext\n")
+
+	glXCopyContext((Display *)arg0, (GLXContext)arg1, (GLXContext)arg2, arg3);
+}
+
+JNIEXPORT jint JNICALL XGL_NATIVE(glXCreateContext)
+	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2, jboolean arg3)
+{
+	XVisualInfo _arg1, *lparg1=NULL;
+	jint rc;
+
+	DEBUG_CALL("glXCreateContext\n")
+
+	if (arg1) lparg1 = getXVisualInfoFields(env, arg1, &_arg1);
+	rc = (jint)glXCreateContext((Display *)arg0, lparg1, (GLXContext)arg2, arg3);
+	if (arg1) setXVisualInfoFields(env, arg1, lparg1);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL XGL_NATIVE(glXCreateGLXPixmap)
+	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2)
+{
+	XVisualInfo _arg1, *lparg1=NULL;
+	jint rc;
+
+	DEBUG_CALL("glXCreateGLXPixmap\n")
+
+	if (arg1) lparg1 = getXVisualInfoFields(env, arg1, &_arg1);
+	rc = (jint)glXCreateGLXPixmap((Display *)arg0, lparg1, arg2);
+	if (arg1) setXVisualInfoFields(env, arg1, lparg1);
+	return rc;
+}
+
+JNIEXPORT void JNICALL XGL_NATIVE(glXDestroyContext)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glXDestroyContext\n")
+
+	glXDestroyContext((Display *)arg0, (GLXContext)arg1);
+}
+
+JNIEXPORT void JNICALL XGL_NATIVE(glXDestroyGLXPixmap)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glXDestroyGLXPixmap\n")
+
+	glXDestroyGLXPixmap((Display *)arg0, arg1);
+}
+
+JNIEXPORT jint JNICALL XGL_NATIVE(glXGetClientString)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glXGetClientString\n")
+
+	return (jint)glXGetClientString((Display *)arg0, arg1);
+}
+
+JNIEXPORT jint JNICALL XGL_NATIVE(glXGetConfig)
+	(JNIEnv *env, jclass that, jint arg0, jobject arg1, jint arg2, jintArray arg3)
+{
+	XVisualInfo _arg1, *lparg1=NULL;
+	jint *lparg3=NULL;
+	jint rc;
+
+	DEBUG_CALL("glXGetConfig\n")
+
+	if (arg1) lparg1 = getXVisualInfoFields(env, arg1, &_arg1);
+	if (arg3) lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL);
+	rc = (jint)glXGetConfig((Display *)arg0, lparg1, arg2, (int *)lparg3);
+	if (arg1) setXVisualInfoFields(env, arg1, lparg1);
+	if (arg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL XGL_NATIVE(glXGetCurrentContext)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glXGetCurrentContext\n")
+
+	return (jint)glXGetCurrentContext();
+}
+
+JNIEXPORT jint JNICALL XGL_NATIVE(glXGetCurrentDrawable)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glXGetCurrentDrawable\n")
+
+	return (jint)glXGetCurrentDrawable();
+}
+
+JNIEXPORT jboolean JNICALL XGL_NATIVE(glXIsDirect)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glXIsDirect\n")
+
+	return (jboolean)glXIsDirect((Display *)arg0, (GLXContext)arg1);
+}
+
+JNIEXPORT jboolean JNICALL XGL_NATIVE(glXMakeCurrent)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glXMakeCurrent\n")
+
+	return (jboolean)glXMakeCurrent((Display *)arg0, (GLXDrawable)arg1, (GLXContext)arg2);
+}
+
+JNIEXPORT jboolean JNICALL XGL_NATIVE(glXQueryExtension)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jintArray arg2)
+{
+	jint *lparg1=NULL;
+	jint *lparg2=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("glXQueryExtension\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	rc = (jboolean)glXQueryExtension((Display *)arg0, (int *)lparg1, (int *)lparg2);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL XGL_NATIVE(glXQueryExtensionsString)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glXQueryExtensionsString\n")
+
+	return (jint)glXQueryExtensionsString((Display *)arg0, arg1);
+}
+
+JNIEXPORT jint JNICALL XGL_NATIVE(glXQueryServerString)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("glXQueryServerString\n")
+
+	return (jint)glXQueryServerString((Display *)arg0, arg1, arg2);
+}
+
+JNIEXPORT jboolean JNICALL XGL_NATIVE(glXQueryVersion)
+	(JNIEnv *env, jclass that, jint arg0, jintArray arg1, jintArray arg2)
+{
+	jint *lparg1=NULL;
+	jint *lparg2=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("glXQueryVersion\n")
+
+	if (arg1) lparg1 = (*env)->GetIntArrayElements(env, arg1, NULL);
+	if (arg2) lparg2 = (*env)->GetIntArrayElements(env, arg2, NULL);
+	rc = (jboolean)glXQueryVersion((Display *)arg0, (int *)lparg1, (int *)lparg2);
+	if (arg1) (*env)->ReleaseIntArrayElements(env, arg1, lparg1, 0);
+	if (arg2) (*env)->ReleaseIntArrayElements(env, arg2, lparg2, 0);
+	return rc;
+}
+
+JNIEXPORT void JNICALL XGL_NATIVE(glXSwapBuffers)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("glXSwapBuffers\n")
+
+	glXSwapBuffers((Display *)arg0, (GLXDrawable)arg1);
+}
+
+JNIEXPORT void JNICALL XGL_NATIVE(glXUseXFont)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("glXUseXFont\n")
+
+	glXUseXFont(arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT void JNICALL XGL_NATIVE(glXWaitGL)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glXWaitGL\n")
+
+	glXWaitGL();
+}
+
+JNIEXPORT void JNICALL XGL_NATIVE(glXWaitX)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("glXWaitX\n")
+
+	glXWaitX();
+}
+
+JNIEXPORT void JNICALL XGL_NATIVE(memmove__Lorg_eclipse_swt_opengl_internal_motif_XVisualInfo_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	XVisualInfo _arg0, *lparg0=NULL;
+
+	DEBUG_CALL("memmove__Lorg_eclipse_swt_opengl_internal_motif_XVisualInfo_2II\n")
+
+	if (arg0) lparg0 = &_arg0;
+	memmove((void *)lparg0, (const void *)arg1, (size_t)arg2);
+	if (arg0) setXVisualInfoFields(env, arg0, lparg0);
+}
diff --git a/bundles/org.eclipse.swt.opengl/motif/gl_library/make_aix.mak b/bundles/org.eclipse.swt.opengl/motif/gl_library/make_aix.mak
new file mode 100644
index 0000000000..6928cabd4e
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/gl_library/make_aix.mak
@@ -0,0 +1,40 @@
+#*******************************************************************************
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials 
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+#*******************************************************************************
+
+# Define the installation directories for various products.
+#    JAVA_HOME  - The JDK > 1.3
+JAVA_HOME   = /usr/java131
+
+# Define the various shared libraries to be made.
+SWT_PREFIX   = swt
+WS_PREFIX    = motif
+SWT_DLL      = lib$(SWT_PREFIX)-$(WS_PREFIX).so
+SWT_OBJ      = gl.o glu.o structs.o glx.o
+SWT_LIB      = -G -bnoentry -lc_r -lC_r -lm -bexpall -lMrm -lX11 -lXext -liconv -lGL -lGLU
+
+#
+# The following CFLAGS are for compiling the SWT OpenGL library.
+#
+CFLAGS = -O -s \
+	-DAIX \
+	-DNO_XINERAMA_EXTENSIONS \
+	-q mbcs -qlanglvl=extended -qmaxmem=8192 \
+	-I$(JAVA_HOME)/include
+
+all: make_swt
+
+make_swt: $(SWT_DLL)
+
+$(SWT_DLL): $(SWT_OBJ)
+	ld $(SWT_LIB) -o $(SWT_DLL) $(SWT_OBJ)
+
+clean:
+	rm -f *.o *.so *.a
diff --git a/bundles/org.eclipse.swt.opengl/motif/gl_library/make_hpux.mak b/bundles/org.eclipse.swt.opengl/motif/gl_library/make_hpux.mak
new file mode 100644
index 0000000000..16648de5f0
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/gl_library/make_hpux.mak
@@ -0,0 +1,44 @@
+#*******************************************************************************
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials 
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+#*******************************************************************************
+
+# Define the installation directories for various products.
+JAVA_HOME  = /opt/java1.3
+
+# Define the various shared libraries to be made.
+SWT_PREFIX   = gl
+WS_PREFIX    = motif
+SWT_DLL      = lib$(SWT_PREFIX)-$(WS_PREFIX).sl
+SWT_OBJ      = gl.o glu.o structs.o glx.o
+SWT_LIB      = -L/usr/lib -L/opt/graphics/OpenGL/lib -G -lGL -lGLU -lc -ldld -lm
+
+#
+# The following CFLAGS are for compiling the SWT OpenGL library.
+#
+# Note:
+#   The flag -xarch=generic ensure the compiled modules will be targeted
+#   for 32-bit architectures. If this flag is not
+#
+CFLAGS = -Ae +z \
+	-DNO_XINERAMA_EXTENSIONS \
+	-D_HPUX -D_POSIX_C_SOURCE=199506L \
+	-I./ \
+	-I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/hp-ux \
+	-I/opt/graphics/OpenGL/include
+
+all: make_swt
+
+make_swt: $(SWT_DLL)
+
+$(SWT_DLL): $(SWT_OBJ)
+	ld -b -z -o $@ $(SWT_OBJ) $(SWT_LIB)
+
+clean:
+	rm -f *.sl *.o
diff --git a/bundles/org.eclipse.swt.opengl/motif/gl_library/make_linux.mak b/bundles/org.eclipse.swt.opengl/motif/gl_library/make_linux.mak
new file mode 100644
index 0000000000..755895fe3d
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/gl_library/make_linux.mak
@@ -0,0 +1,38 @@
+#*******************************************************************************
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials 
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+#*******************************************************************************
+
+# Define the installation directories for various products.
+JAVA_HOME   = /bluebird/teamswt/swt-builddir/ive/bin
+
+
+# Define the various shared libraries to be made.
+SWT_PREFIX   = gl
+WS_PREFIX    = motif
+SWT_DLL      = lib$(SWT_PREFIX)-$(WS_PREFIX).so
+SWT_OBJ      = gl.o glu.o structs.o glx.o
+SWT_LIB      = -shared -L/usr/X11R6/lib -lGL -lGLU -lm
+
+#
+# The following CFLAGS are for compiling the SWT OpenGL library.
+#
+CFLAGS = -O -s \
+	-I./ \
+	-I$(JAVA_HOME)/include
+
+all: make_swt
+
+make_swt: $(SWT_DLL)
+
+$(SWT_DLL): $(SWT_OBJ)
+	ld -o $@ $(SWT_OBJ) $(SWT_LIB)
+
+clean:
+	rm -f *.so *.o
diff --git a/bundles/org.eclipse.swt.opengl/motif/gl_library/make_solaris.mak b/bundles/org.eclipse.swt.opengl/motif/gl_library/make_solaris.mak
new file mode 100644
index 0000000000..1b08b07f47
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/gl_library/make_solaris.mak
@@ -0,0 +1,45 @@
+#*******************************************************************************
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials 
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+#*******************************************************************************
+
+# Define the installation directories for various products.
+JAVA_HOME   = /bluebird/teamswt/swt-builddir/ive/bin
+
+# Define the various shared libraries to be made.
+SWT_PREFIX   = gl
+WS_PREFIX    = motif
+SWT_DLL      = lib$(SWT_PREFIX)-$(WS_PREFIX).so
+SWT_OBJ      = gl.o glu.o structs.o glx.o
+SWT_LIB      = -G -L/usr/lib -lm -lGL -lGLU
+
+#
+# The following CFLAGS are for compiling the SWT OpenGL library.
+#
+# Note:
+#   The flag -xarch=generic ensure the compiled modules will be targeted
+#   for 32-bit architectures.
+#
+CFLAGS = -O -s \
+	-xarch=generic \
+	-KPIC \
+	-I./ \
+	-I$(JAVA_HOME)/include
+
+all: make_swt
+
+make_swt: $(SWT_DLL)
+
+$(SWT_DLL): $(SWT_OBJ)
+	ld -o $@ $(SWT_OBJ) $(SWT_LIB)
+
+clean:
+	rm -f *.so *.o
+
+
diff --git a/bundles/org.eclipse.swt.opengl/motif/gl_library/structs.c b/bundles/org.eclipse.swt.opengl/motif/gl_library/structs.c
new file mode 100644
index 0000000000..368852dc33
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/gl_library/structs.c
@@ -0,0 +1,73 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include "swt.h"
+#include "structs.h"
+
+typedef struct XVisualInfo_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID visual, visualid, screen, depth, cclass, red_mask, green_mask, blue_mask, colormap_size, bits_per_rgb;
+} XVisualInfo_FID_CACHE;
+typedef XVisualInfo_FID_CACHE *PXVisualInfo_FID_CACHE;
+
+XVisualInfo_FID_CACHE XVisualInfoFc;
+
+void cacheXVisualInfoFids(JNIEnv *env, jobject lpObject, PXVisualInfo_FID_CACHE lpCache)
+{
+	if (lpCache->cached) return;
+	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+	lpCache->visual = (*env)->GetFieldID(env, lpCache->clazz, "visual", "I");
+	lpCache->visualid = (*env)->GetFieldID(env, lpCache->clazz, "visualid", "I");
+	lpCache->screen = (*env)->GetFieldID(env, lpCache->clazz, "screen", "I");
+	lpCache->depth = (*env)->GetFieldID(env, lpCache->clazz, "depth", "I");
+	lpCache->cclass = (*env)->GetFieldID(env, lpCache->clazz, "cclass", "I");
+	lpCache->red_mask = (*env)->GetFieldID(env, lpCache->clazz, "red_mask", "I");
+	lpCache->green_mask = (*env)->GetFieldID(env, lpCache->clazz, "green_mask", "I");
+	lpCache->blue_mask = (*env)->GetFieldID(env, lpCache->clazz, "blue_mask", "I");
+	lpCache->colormap_size = (*env)->GetFieldID(env, lpCache->clazz, "colormap_size", "I");
+	lpCache->bits_per_rgb = (*env)->GetFieldID(env, lpCache->clazz, "bits_per_rgb", "I");
+	lpCache->cached = 1;
+}
+
+XVisualInfo *getXVisualInfoFields(JNIEnv *env, jobject lpObject, XVisualInfo *lpStruct)
+{
+	PXVisualInfo_FID_CACHE lpCache = &XVisualInfoFc;
+	if (!lpCache->cached) cacheXVisualInfoFids(env, lpObject, lpCache);
+	lpStruct->visual = (Visual *)(*env)->GetIntField(env, lpObject, lpCache->visual);
+	lpStruct->visualid = (*env)->GetIntField(env, lpObject, lpCache->visualid);
+	lpStruct->screen = (*env)->GetIntField(env, lpObject, lpCache->screen);
+	lpStruct->depth = (*env)->GetIntField(env, lpObject, lpCache->depth);
+	lpStruct->class = (*env)->GetIntField(env, lpObject, lpCache->cclass);
+	lpStruct->red_mask = (*env)->GetIntField(env, lpObject, lpCache->red_mask);
+	lpStruct->green_mask = (*env)->GetIntField(env, lpObject, lpCache->green_mask);
+	lpStruct->blue_mask = (*env)->GetIntField(env, lpObject, lpCache->blue_mask);
+	lpStruct->colormap_size = (*env)->GetIntField(env, lpObject, lpCache->colormap_size);
+	lpStruct->bits_per_rgb = (*env)->GetIntField(env, lpObject, lpCache->bits_per_rgb);
+	return lpStruct;
+}
+
+void setXVisualInfoFields(JNIEnv *env, jobject lpObject, XVisualInfo *lpStruct)
+{
+	PXVisualInfo_FID_CACHE lpCache = &XVisualInfoFc;
+	if (!lpCache->cached) cacheXVisualInfoFids(env, lpObject, lpCache);
+	(*env)->SetIntField(env, lpObject, lpCache->visual, (jint)lpStruct->visual);
+	(*env)->SetIntField(env, lpObject, lpCache->visualid, (jint)lpStruct->visualid);
+	(*env)->SetIntField(env, lpObject, lpCache->screen, (jint)lpStruct->screen);
+	(*env)->SetIntField(env, lpObject, lpCache->depth, (jint)lpStruct->depth);
+	(*env)->SetIntField(env, lpObject, lpCache->cclass, (jint)lpStruct->class);
+	(*env)->SetIntField(env, lpObject, lpCache->red_mask, (jint)lpStruct->red_mask);
+	(*env)->SetIntField(env, lpObject, lpCache->green_mask, (jint)lpStruct->green_mask);
+	(*env)->SetIntField(env, lpObject, lpCache->blue_mask, (jint)lpStruct->blue_mask);
+	(*env)->SetIntField(env, lpObject, lpCache->colormap_size, (jint)lpStruct->colormap_size);
+	(*env)->SetIntField(env, lpObject, lpCache->bits_per_rgb, (jint)lpStruct->bits_per_rgb);
+}
diff --git a/bundles/org.eclipse.swt.opengl/motif/gl_library/structs.h b/bundles/org.eclipse.swt.opengl/motif/gl_library/structs.h
new file mode 100644
index 0000000000..80791498e6
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/gl_library/structs.h
@@ -0,0 +1,16 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+#include <X11/X.h>
+#include <X11/Xutil.h>
+
+XVisualInfo *getXVisualInfoFields(JNIEnv *env, jobject lpObject, XVisualInfo *lpStruct);
+void setXVisualInfoFields(JNIEnv *env, jobject lpObject, XVisualInfo *lpStruct);
+
diff --git a/bundles/org.eclipse.swt.opengl/motif/org/eclipse/swt/opengl/GLContext.java b/bundles/org.eclipse.swt.opengl/motif/org/eclipse/swt/opengl/GLContext.java
new file mode 100644
index 0000000000..8bab074aac
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/org/eclipse/swt/opengl/GLContext.java
@@ -0,0 +1,303 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl;
+
+
+import org.eclipse.swt.*;
+import org.eclipse.swt.graphics.*;
+import org.eclipse.swt.internal.motif.*;
+import org.eclipse.swt.opengl.internal.motif.*;
+
+/**
+ * Instances of <code>GLContext</code> are used to draw on swt <code>Drawable</code>s 
+ * through invocations of provided OpenGL functions.
+ * <p>
+ * Application code must explicitly invoke the <code>GLContext.dispose ()</code> 
+ * method to release the operating system resources managed by each instance
+ * when those instances are no longer required. This is <em>particularly</em>
+ * important on Windows95 and Windows98 where the operating system has a limited
+ * number of device contexts available.
+ * </p>
+ */
+public class GLContext {
+	int handle;
+	int gc;
+	GCData data;
+	Drawable drawable;
+	int selectBufferPtr = 0;
+
+	static final int MSB_FIRST = 1;
+	static final int LSB_FIRST = 2;
+
+	/**
+	 * Constructs a new instance of this class which has been
+	 * configured to draw on the specified drawable.
+	 * <p>
+	 * You must dispose the <code>GLContext</code> when it is no longer required. 
+	 * </p>
+	 * 
+	 * @param drawable the drawable to draw on
+	 * @exception IllegalArgumentException <ul>
+	 *    <li>ERROR_NULL_ARGUMENT - if the drawable is null</li>
+	 * </ul>
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for gc creation</li>
+	 *    <li>ERROR_UNSUPPORTED_DEPTH - if the current display depth is not supported</li>
+	 * </ul>
+	 */
+	public GLContext (Drawable drawable) {
+		if (drawable == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);
+		this.drawable = drawable;
+		this.data = new GCData ();
+		gc = drawable.internal_new_GC (data);
+		if (gc == 0) SWT.error (SWT.ERROR_NO_HANDLES);
+		int xDisplay = data.display;
+		int screen = OS.XDefaultScreen (xDisplay);
+		int depth = OS.XDefaultDepthOfScreen (OS.XDefaultScreenOfDisplay (xDisplay));
+		int attrib [] = {
+			XGL.GLX_LEVEL,
+			0,
+			XGL.GLX_RGBA,
+			XGL.GLX_DOUBLEBUFFER,
+			XGL.GLX_DEPTH_SIZE,
+			depth,
+			0
+		};
+		int infoPtr = XGL.glXChooseVisual (xDisplay, screen, attrib);
+		if (infoPtr == 0) SWT.error (SWT.ERROR_UNSUPPORTED_DEPTH);
+		XVisualInfo info = new XVisualInfo ();
+		XGL.memmove (info, infoPtr, XVisualInfo.sizeof);
+		OS.XFree (infoPtr);
+		handle = XGL.glXCreateContext (xDisplay, info, 0, false);
+		if (handle == 0) SWT.error (SWT.ERROR_NO_HANDLES);
+	}
+	
+	public ImageData convertImageData (ImageData source) {
+		PaletteData palette = new PaletteData (0xff0000, 0xff00, 0xff);
+		ImageData newSource = new ImageData (source.width, source.height, 24, palette);
+		ImageDataUtil.blit (
+			1,
+			source.data,
+			source.depth,
+			source.bytesPerLine,
+			(source.depth != 16) ? MSB_FIRST : LSB_FIRST,
+			0,
+			0,
+			source.width,
+			source.height,
+			source.palette.redMask,
+			source.palette.greenMask,
+			source.palette.blueMask,
+			255,
+			null,
+			0,
+			0,
+			0,
+			newSource.data,
+			newSource.depth,
+			newSource.bytesPerLine,
+			(newSource.depth != 16) ? MSB_FIRST : LSB_FIRST,
+			0,
+			0,
+			newSource.width,
+			newSource.height,
+			newSource.palette.redMask,
+			newSource.palette.greenMask,
+			newSource.palette.blueMask,
+			false,
+			true);
+
+		return newSource;
+	}
+
+	/**
+	 * Disposes of the operating system resources associated with
+	 * the receiver. Applications must dispose of all <code>GLContext</code>s
+	 * that they allocate.
+	 */
+	public void dispose () {
+		if (handle == 0) return;
+		int xDisplay = data.display;
+		if (XGL.glXGetCurrentContext () == handle) {
+			XGL.glXMakeCurrent (xDisplay, 0, 0);
+		}
+		if (selectBufferPtr != 0) OS.XtFree (selectBufferPtr);
+		XGL.glXDestroyContext (xDisplay, handle);
+		handle = 0;
+		// drawable may be disposed
+		try {
+			drawable.internal_dispose_GC (gc, data);
+		} catch (SWTException e) {
+		}
+		gc = 0;
+		data.display = data.drawable = data.colormap = 0;
+		data.fontList = data.clipRgn = data.renderTable = 0;
+		drawable = null;
+		data.device = null;
+		data.image = null;
+		data.codePage = null;
+		data = null;
+	}
+
+	public int[] getSelectBuffer (int selectBufferPtr, int[] selectBuffer) {
+		OS.memmove (selectBuffer, selectBufferPtr, selectBuffer.length * 4);
+		return selectBuffer;
+	}
+
+	public int getSelectBufferPtr (int[] selectBuffer) {
+		if (selectBufferPtr == 0) {
+			selectBufferPtr = OS.XtMalloc (selectBuffer.length * 4);
+		}
+		OS.memmove (selectBufferPtr, selectBuffer, selectBuffer.length * 4);
+		return selectBufferPtr;
+	}
+
+	/**
+	 * Returns a boolean indicating whether the receiver is the current
+	 * <code>GLContext</code>.
+	 *  
+	 * @return true if the receiver is the current <code>GLContext</code>,
+	 * false otherwise
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_GRAPHIC_DISPOSED if the receiver is disposed</li>
+	 * </ul>
+	 */
+	public boolean isCurrent () {
+		if (isDisposed ()) 	SWT.error (SWT.ERROR_GRAPHIC_DISPOSED);
+		return XGL.glXGetCurrentContext () == handle;
+	}
+
+	/**
+	 * Returns a boolean indicating whether the <code>GLContext</code> has been
+	 * disposed.
+	 * <p>
+	 * This method gets the dispose state for the <code>GLContext</code>.
+	 * When a <code>GLContext</code> has been disposed, it is an error to
+	 * invoke any other method using the <code>GLContext</code>.
+	 *
+	 * @return true if the <code>GLContext</code> is disposed, false otherwise
+	 */
+	public boolean isDisposed () {
+		return handle == 0;
+	}
+
+	/**
+	 * Loads the specified bitmap font.
+	 * 
+	 * @param fdata
+	 * @param device
+	 * @param base
+	 * @param first
+	 * @param count
+	 */
+	public void loadBitmapFont (FontData fdata, Device device, int base, int startIndex, int length) {
+		/* Temporaly code, due some problems when running on UTF-8 loadBitmapFont ()
+		 * is restrict to works only for ascii. 
+		 * Note: en_US.ISO8859-1 also code be used.
+		 */
+		fdata.setLocale ("C");
+		Font font = new Font (device, fdata);
+		int fontList = font.handle;
+		int[] buffer = new int [1];
+		if (!OS.XmFontListInitFontContext (buffer, fontList)) return;
+		int context = buffer [0];
+		XFontStruct fontStruct = new XFontStruct ();
+		int fontListEntry;
+		int[] fontStructPtr = new int [1];
+		int[] fontNamePtr = new int [1];
+		int xfont = 0;
+		// go through each entry in the font list
+		while ((fontListEntry = OS.XmFontListNextEntry (context)) != 0) {
+			int fontPtr = OS.XmFontListEntryGetFont (fontListEntry, buffer);
+			if (buffer [0] == OS.XmFONT_IS_FONT) {
+				// FontList contains a single font
+				OS.memmove (fontStruct, fontPtr, 20 * 4);
+				xfont = fontStruct.fid;
+			} else {
+				// FontList contains a fontSet
+				int nFonts = OS.XFontsOfFontSet (fontPtr, fontStructPtr, fontNamePtr);
+				int[] fontStructs = new int [nFonts];
+				OS.memmove (fontStructs, fontStructPtr [0], nFonts * 4);
+				// Go through each fontStruct in the font set.
+				for (int i = 0; i < nFonts; i++) {
+					OS.memmove (fontStruct, fontStructs [i], XFontStruct.sizeof);
+					xfont = fontStruct.fid;
+				}
+			}
+		}
+		if (xfont != 0) {
+			XGL.glXUseXFont (xfont, startIndex, length, base);
+		}
+		font.dispose ();
+		OS.XmFontListFreeFontContext (context);
+	}
+
+	/**
+	 * Loads the specified outline font.
+	 * 
+	 * @param fdata
+	 * @param device
+	 * @param base
+	 * @param first
+	 * @param count
+	 * @param deviation
+	 * @param extrusion
+	 * @param format
+	 * @param lpgmf
+	 */
+	public void loadOutlineFont (FontData fdata, Device device, int base, int first,
+	int count, float deviation, float extrusion, int format, GLYPHMETRICSFLOAT[] lpgmf) {
+		// stub
+	}
+
+	/**
+	 * Resizes the receiver.
+	 * 
+	 * @param x
+	 * @param y
+	 * @param width
+	 * @param height
+	 */
+	public void resize (int x, int y, int width, int height) {
+		if (height == 0) height = 1;
+		GL.glViewport (x, y, width, height);
+		GL.glMatrixMode (GL.GL_PROJECTION);
+		GL.glLoadIdentity ();
+		GLU.gluPerspective (45.0f, (float) width / (float) height, 0.1f, 100.0f);
+		GL.glMatrixMode (GL.GL_MODELVIEW);
+		GL.glLoadIdentity ();
+	}
+
+	/**
+	 * Sets the receiver to be the current <code>GLContext</code>.
+	 * 
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_GRAPHIC_DISPOSED if the receiver is disposed</li>
+	 * </ul>
+	 */
+	public void setCurrent () {
+		if (isDisposed ()) SWT.error (SWT.ERROR_GRAPHIC_DISPOSED);
+		if (XGL.glXGetCurrentContext () == handle) return;
+		XGL.glXMakeCurrent (data.display, data.drawable, handle);
+	}
+
+	/**
+	 * Swaps the receiver's buffers.
+	 * 
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_GRAPHIC_DISPOSED if the receiver is disposed</li>
+	 * </ul>
+	 */
+	public void swapBuffers () {
+		if (isDisposed ()) SWT.error (SWT.ERROR_GRAPHIC_DISPOSED);
+		XGL.glXSwapBuffers (data.display, data.drawable);
+	}
+}
diff --git a/bundles/org.eclipse.swt.opengl/motif/org/eclipse/swt/opengl/internal/motif/XGL.java b/bundles/org.eclipse.swt.opengl/motif/org/eclipse/swt/opengl/internal/motif/XGL.java
new file mode 100644
index 0000000000..ce3705a06f
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/org/eclipse/swt/opengl/internal/motif/XGL.java
@@ -0,0 +1,227 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl.internal.motif;
+
+import org.eclipse.swt.opengl.Library;
+
+public class XGL {
+	
+static {
+	Library.loadLibrary("gl");
+}
+
+public static final int GLX_VERSION_1_1 = 1;
+public static final int GLX_VERSION_1_2 = 1;
+public static final int GLX_VERSION_1_3 = 1;
+
+/*
+** Visual Config Attributes (glXGetConfig, glXGetFBConfigAttrib)
+*/
+public static final int GLX_USE_GL		= 1;	/* support GLX rendering */
+public static final int GLX_BUFFER_SIZE		= 2;	/* depth of the color buffer */
+public static final int GLX_LEVEL		= 3;	/* level in plane stacking */
+public static final int GLX_RGBA		= 4;	/* true if RGBA mode */
+public static final int GLX_DOUBLEBUFFER	= 5;	/* double buffering supported */
+public static final int GLX_STEREO		= 6;	/* stereo buffering supported */
+public static final int GLX_AUX_BUFFERS		= 7;	/* number of aux buffers */
+public static final int GLX_RED_SIZE		= 8;	/* number of red component bits */
+public static final int GLX_GREEN_SIZE		= 9;	/* number of green component bits */
+public static final int GLX_BLUE_SIZE		= 10;	/* number of blue component bits */
+public static final int GLX_ALPHA_SIZE		= 11;	/* number of alpha component bits */
+public static final int GLX_DEPTH_SIZE		= 12;	/* number of depth bits */
+public static final int GLX_STENCIL_SIZE	= 13;	/* number of stencil bits */
+public static final int GLX_ACCUM_RED_SIZE	= 14;	/* number of red accum bits */
+public static final int GLX_ACCUM_GREEN_SIZE	= 15;	/* number of green accum bits */
+public static final int GLX_ACCUM_BLUE_SIZE	= 16;	/* number of blue accum bits */
+public static final int GLX_ACCUM_ALPHA_SIZE	= 17;	/* number of alpha accum bits */
+/*
+** FBConfig-specific attributes
+*/
+public static final int GLX_X_VISUAL_TYPE		= 0x22;
+public static final int GLX_CONFIG_CAVEAT		= 0x20;	/* Like visual_info VISUAL_CAVEAT_EXT */
+public static final int GLX_TRANSPARENT_TYPE		= 0x23;
+public static final int GLX_TRANSPARENT_INDEX_VALUE	= 0x24;
+public static final int GLX_TRANSPARENT_RED_VALUE	= 0x25;
+public static final int GLX_TRANSPARENT_GREEN_VALUE	= 0x26;
+public static final int GLX_TRANSPARENT_BLUE_VALUE	= 0x27;
+public static final int GLX_TRANSPARENT_ALPHA_VALUE	= 0x28;
+public static final int GLX_DRAWABLE_TYPE		= 0x8010;
+public static final int GLX_RENDER_TYPE			= 0x8011;
+public static final int GLX_X_RENDERABLE		= 0x8012;
+public static final int GLX_FBCONFIG_ID			= 0x8013;
+public static final int GLX_MAX_PBUFFER_WIDTH		= 0x8016;
+public static final int GLX_MAX_PBUFFER_HEIGHT		= 0x8017;
+public static final int GLX_MAX_PBUFFER_PIXELS		= 0x8018;
+public static final int GLX_VISUAL_ID			= 0x800B;
+
+/*
+** Error return values from glXGetConfig.  Success is indicated by
+** a value of 0.
+*/
+public static final int GLX_BAD_SCREEN		= 1;	/* screen # is bad */
+public static final int GLX_BAD_ATTRIBUTE	= 2;	/* attribute to get is bad */
+public static final int GLX_NO_EXTENSION	= 3;	/* no glx extension on server */
+public static final int GLX_BAD_VISUAL		= 4;	/* visual # not known by GLX */
+public static final int GLX_BAD_CONTEXT		= 5;	/* returned only by import_context EXT? */
+public static final int GLX_BAD_VALUE		= 6;	/* returned only by glXSwapIntervalSGI? */
+public static final int GLX_BAD_ENUM		= 7;	/* unused? */
+
+/* FBConfig attribute values */
+
+/*
+** Generic "don't care" value for glX ChooseFBConfig attributes (except
+** GLX_LEVEL)
+*/
+public static final int GLX_DONT_CARE			= 0xFFFFFFFF;
+
+/* GLX_RENDER_TYPE bits */
+public static final int GLX_RGBA_BIT			= 0x00000001;
+public static final int GLX_COLOR_INDEX_BIT		= 0x00000002;
+
+/* GLX_DRAWABLE_TYPE bits */
+public static final int GLX_WINDOW_BIT			= 0x00000001;
+public static final int GLX_PIXMAP_BIT			= 0x00000002;
+public static final int GLX_PBUFFER_BIT			= 0x00000004;
+
+/* GLX_CONFIG_CAVEAT attribute values */
+public static final int GLX_NONE			= 0x8000;
+public static final int GLX_SLOW_CONFIG			= 0x8001;
+public static final int GLX_NON_CONFORMANT_CONFIG	= 0x800D;
+
+/* GLX_X_VISUAL_TYPE attribute values */
+public static final int GLX_TRUE_COLOR			= 0x8002;
+public static final int GLX_DIRECT_COLOR		= 0x8003;
+public static final int GLX_PSEUDO_COLOR		= 0x8004;
+public static final int GLX_STATIC_COLOR		= 0x8005;
+public static final int GLX_GRAY_SCALE			= 0x8006;
+public static final int GLX_STATIC_GRAY			= 0x8007;
+
+/* GLX_TRANSPARENT_TYPE attribute values */
+/* public static final int GLX_NONE			   0x8000 */
+public static final int GLX_TRANSPARENT_RGB		= 0x8008;
+public static final int GLX_TRANSPARENT_INDEX		= 0x8009;
+
+/* glXCreateGLXPbuffer attributes */
+public static final int GLX_PRESERVED_CONTENTS		= 0x801B;
+public static final int GLX_LARGEST_PBUFFER		= 0x801C;
+public static final int GLX_PBUFFER_HEIGHT		= 0x8040;	/* New for GLX 1.3 */
+public static final int GLX_PBUFFER_WIDTH		= 0x8041;	/* New for GLX 1.3 */
+
+/* glXQueryGLXPBuffer attributes */
+public static final int GLX_WIDTH			= 0x801D;
+public static final int GLX_HEIGHT			= 0x801E;
+public static final int GLX_EVENT_MASK			= 0x801F;
+
+/* glXCreateNewContext render_type attribute values */
+public static final int GLX_RGBA_TYPE			= 0x8014;
+public static final int GLX_COLOR_INDEX_TYPE		= 0x8015;
+
+/* glXQueryContext attributes */
+/* public static final int GLX_FBCONFIG_ID		  0x8013 */
+/* public static final int GLX_RENDER_TYPE		  0x8011 */
+public static final int GLX_SCREEN			= 0x800C;
+
+/* glXSelectEvent event mask bits */
+public static final int GLX_PBUFFER_CLOBBER_MASK	= 0x08000000;
+
+/* GLXPbufferClobberEvent event_type values */
+public static final int GLX_DAMAGED			= 0x8020;
+public static final int GLX_SAVED			= 0x8021;
+
+/* GLXPbufferClobberEvent draw_type values */
+public static final int GLX_WINDOW			= 0x8022;
+public static final int GLX_PBUFFER			= 0x8023;
+
+/* GLXPbufferClobberEvent buffer_mask bits */
+public static final int GLX_FRONT_LEFT_BUFFER_BIT	= 0x00000001;
+public static final int GLX_FRONT_RIGHT_BUFFER_BIT	= 0x00000002;
+public static final int GLX_BACK_LEFT_BUFFER_BIT	= 0x00000004;
+public static final int GLX_BACK_RIGHT_BUFFER_BIT	= 0x00000008;
+public static final int GLX_AUX_BUFFERS_BIT		= 0x00000010;
+public static final int GLX_DEPTH_BUFFER_BIT		= 0x00000020;
+public static final int GLX_STENCIL_BUFFER_BIT		= 0x00000040;
+public static final int GLX_ACCUM_BUFFER_BIT		= 0x00000080;
+
+/*
+** Extension return values from glXGetConfig.  These are also
+** accepted as parameter values for glXChooseVisual.
+*/
+
+public static final int GLX_X_VISUAL_TYPE_EXT	= 0x22;	/* visual_info extension type */
+public static final int GLX_TRANSPARENT_TYPE_EXT = 0x23;	/* visual_info extension */
+public static final int GLX_TRANSPARENT_INDEX_VALUE_EXT = 0x24;	/* visual_info extension */
+public static final int GLX_TRANSPARENT_RED_VALUE_EXT	= 0x25;	/* visual_info extension */
+public static final int GLX_TRANSPARENT_GREEN_VALUE_EXT = 0x26;	/* visual_info extension */
+public static final int GLX_TRANSPARENT_BLUE_VALUE_EXT	= 0x27;	/* visual_info extension */
+public static final int GLX_TRANSPARENT_ALPHA_VALUE_EXT = 0x28;	/* visual_info extension */
+
+/* Property values for visual_type */
+public static final int GLX_TRUE_COLOR_EXT	= 0x8002;
+public static final int GLX_DIRECT_COLOR_EXT	= 0x8003;
+public static final int GLX_PSEUDO_COLOR_EXT	= 0x8004;
+public static final int GLX_STATIC_COLOR_EXT	= 0x8005;
+public static final int GLX_GRAY_SCALE_EXT	= 0x8006;
+public static final int GLX_STATIC_GRAY_EXT	= 0x8007;
+
+/* Property values for transparent pixel */
+public static final int GLX_NONE_EXT		= 0x8000;
+public static final int GLX_TRANSPARENT_RGB_EXT		= 0x8008;
+public static final int GLX_TRANSPARENT_INDEX_EXT	= 0x8009;
+
+/* Property values for visual_rating */
+public static final int GLX_VISUAL_CAVEAT_EXT		= 0x20;  /* visual_rating extension type */
+public static final int GLX_SLOW_VISUAL_EXT		= 0x8001;
+public static final int GLX_NON_CONFORMANT_VISUAL_EXT	= 0x800D;
+
+/*
+** Names for attributes to glXGetClientString.
+*/
+public static final int GLX_VENDOR		= 0x1;
+public static final int GLX_VERSION		= 0x2;
+public static final int GLX_EXTENSIONS		= 0x3;
+
+/*
+** Names for attributes to glXQueryContextInfoEXT.
+*/
+public static final int GLX_SHARE_CONTEXT_EXT	= 0x800A;	/* id of share context */
+public static final int GLX_VISUAL_ID_EXT	= 0x800B;	/* id of context's visual */
+public static final int GLX_SCREEN_EXT		= 0x800C;	/* screen number */
+
+/* GLX Extension Strings */
+public static final int GLX_EXT_import_context	= 1;
+public static final int GLX_EXT_visual_info	= 1;
+public static final int GLX_EXT_visual_rating	= 1;
+public static final int GLX_ARB_get_proc_address = 1;
+
+public static final native int glXChooseVisual(int dpy, int screen, int[] attribList);
+public static final native void glXCopyContext(int dpy, int src, int dst, int mask);
+//public static final native int glXCreateContext(int dpy, int vis, int shareList, boolean direct);
+public static final native int glXCreateContext(int dpy, XVisualInfo vis, int shareList, boolean direct);
+public static final native int glXCreateGLXPixmap(int dpy, XVisualInfo vis, int pixmap);
+public static final native void glXDestroyContext(int dpy, int ctx);
+public static final native void glXDestroyGLXPixmap(int dpy, int pix);
+public static final native int glXGetConfig(int dpy, XVisualInfo vis, int attrib, int[] value);
+public static final native int glXGetCurrentContext();
+public static final native int glXGetCurrentDrawable();
+public static final native boolean glXIsDirect(int dpy, int ctx);
+public static final native boolean glXMakeCurrent(int dpy, int drawable, int ctx);
+public static final native boolean glXQueryExtension(int dpy, int[] errorBase, int[] eventBase);
+public static final native boolean glXQueryVersion(int dpy, int[] major, int[] minor);
+public static final native void glXSwapBuffers(int dpy, int drawable);
+public static final native void glXUseXFont(int font, int first, int count, int listBase);
+public static final native void glXWaitGL();
+public static final native void glXWaitX();
+public static final native int glXGetClientString(int dpy, int name);
+public static final native int glXQueryServerString(int dpy, int screen, int name);
+public static final native int glXQueryExtensionsString(int dpy, int screen);
+public static final native void memmove(XVisualInfo dest, int src, int size);
+
+}
diff --git a/bundles/org.eclipse.swt.opengl/motif/org/eclipse/swt/opengl/internal/motif/XVisualInfo.java b/bundles/org.eclipse.swt.opengl/motif/org/eclipse/swt/opengl/internal/motif/XVisualInfo.java
new file mode 100644
index 0000000000..d6cba4ad60
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/motif/org/eclipse/swt/opengl/internal/motif/XVisualInfo.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl.internal.motif;
+
+ 
+public class XVisualInfo {
+	public int visual;
+	public int visualid;
+	public int screen;
+	public int depth;
+	public int cclass;
+	public int red_mask, green_mask, blue_mask;
+	public int colormap_size;
+	public int bits_per_rgb;
+	public static final int sizeof = 40;
+}
diff --git a/bundles/org.eclipse.swt.opengl/plugin.properties b/bundles/org.eclipse.swt.opengl/plugin.properties
new file mode 100644
index 0000000000..72fe2d9ff6
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/plugin.properties
@@ -0,0 +1,12 @@
+###############################################################################
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials 
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+pluginName = Standard Widget Toolkit OpenGL Bindings
+providerName = Eclipse.org
+\ No newline at end of file
diff --git a/bundles/org.eclipse.swt.opengl/plugin.xml b/bundles/org.eclipse.swt.opengl/plugin.xml
new file mode 100644
index 0000000000..0e8596357a
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/plugin.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin
+   id="org.eclipse.swt.opengl"
+   name="%pluginName"
+   version="2.1.0"
+   provider-name="%providerName">
+
+   <runtime>
+      <library name="$ws$/swt.jar">
+         <export name="*"/>
+         <packages prefixes="org.eclipse.swt.opengl"/>
+      </library>
+   </runtime>
+   <requires>
+      <import plugin="org.eclipse.swt"/>
+   </requires>
+
+
+</plugin>
diff --git a/bundles/org.eclipse.swt.opengl/win32/gl_library/build.bat b/bundles/org.eclipse.swt.opengl/win32/gl_library/build.bat
new file mode 100644
index 0000000000..7f343981b4
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/gl_library/build.bat
@@ -0,0 +1,34 @@
+rem *******************************************************************************
+rem  Copyright (c) 2000, 2003 IBM Corporation and others.
+rem  All rights reserved. This program and the accompanying materials 
+rem  are made available under the terms of the Common Public License v1.0
+rem  which accompanies this distribution, and is available at
+rem  http://www.eclipse.org/legal/cpl-v10.html
+rem  
+rem  Contributors:
+rem      IBM Corporation - initial API and implementation
+rem *******************************************************************************
+
+@echo off
+
+IF NOT "%JAVA_HOME%"=="" GOTO MAKE
+
+rem *****
+rem Javah
+rem *****
+set JAVA_HOME=j:\teamswt\swt-builddir\ive\bin
+set path=%JAVA_HOME%;%path%
+
+rem ********
+rem MSVC 6.0
+rem ********
+call k:\dev\products\msvc60\vc98\bin\vcvars32.bat
+
+rem ****** 
+rem MS-SDK
+rem ******
+set Mssdk=j:\teamswt\swt-builddir\mssdk
+call %mssdk%\setenv.bat
+
+:MAKE
+nmake -f make_win32.mak %1 %2 %3 %4
diff --git a/bundles/org.eclipse.swt.opengl/win32/gl_library/glw.c b/bundles/org.eclipse.swt.opengl/win32/gl_library/glw.c
new file mode 100644
index 0000000000..ebe0238cfc
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/gl_library/glw.c
@@ -0,0 +1,283 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+#include <windows.h>
+#include <wingdi.h>
+#include "jni.h"
+#include "swt.h"
+#include "structs.h"
+
+#define WGL_NATIVE(func) Java_org_eclipse_swt_opengl_internal_win32_WGL_##func
+
+JNIEXPORT jint JNICALL WGL_NATIVE(ChoosePixelFormat)
+	(JNIEnv *env, jclass that, jint arg0, jobject arg1)
+{
+	PIXELFORMATDESCRIPTOR _arg1, *lparg1=NULL;
+	jint rc;
+
+	DEBUG_CALL("ChoosePixelFormat\n")
+
+	if (arg1) lparg1 = getPIXELFORMATDESCRIPTORFields(env, arg1, &_arg1);
+	rc = (jint)ChoosePixelFormat((HDC)arg0, (CONST PIXELFORMATDESCRIPTOR *)lparg1);
+	if (arg1) setPIXELFORMATDESCRIPTORFields(env, arg1, lparg1);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(DescribePixelFormat)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jobject arg3)
+{
+	PIXELFORMATDESCRIPTOR _arg3, *lparg3=NULL;
+	jint rc;
+
+	DEBUG_CALL("DescribePixelFormat\n")
+
+	if (arg3) lparg3 = getPIXELFORMATDESCRIPTORFields(env, arg3, &_arg3);
+	rc = (jint)DescribePixelFormat((HDC)arg0, arg1, arg2, (LPPIXELFORMATDESCRIPTOR)lparg3);
+	if (arg3) setPIXELFORMATDESCRIPTORFields(env, arg3, lparg3);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(GetPixelFormat)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("GetPixelFormat\n")
+
+	return (jint)GetPixelFormat((HDC)arg0);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(SetPixelFormat)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jobject arg2)
+{
+	PIXELFORMATDESCRIPTOR _arg2, *lparg2=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("SetPixelFormat\n")
+
+	if (arg2) lparg2 = getPIXELFORMATDESCRIPTORFields(env, arg2, &_arg2);
+	rc = (jboolean)SetPixelFormat((HDC)arg0, arg1, (CONST PIXELFORMATDESCRIPTOR *)lparg2);
+	if (arg2) setPIXELFORMATDESCRIPTORFields(env, arg2, lparg2);
+	return rc;
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(SwapBuffers)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("SwapBuffers\n")
+
+	return (jboolean)SwapBuffers((HDC)arg0);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglCopyContext)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2)
+{
+	DEBUG_CALL("wglCopyContext\n")
+
+	return (jboolean)wglCopyContext((HGLRC)arg0, (HGLRC)arg1, (UINT)arg2);
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglCreateContext)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("wglCreateContext\n")
+
+	return (jint)wglCreateContext((HDC)arg0);
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglCreateLayerContext)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("wglCreateLayerContext\n")
+
+	return (jint)wglCreateLayerContext((HDC)arg0, arg1);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglDeleteContext)
+	(JNIEnv *env, jclass that, jint arg0)
+{
+	DEBUG_CALL("wglDeleteContext\n")
+
+	return (jboolean)wglDeleteContext((HGLRC)arg0);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglDescribeLayerPlane)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jobject arg4)
+{
+	LAYERPLANEDESCRIPTOR _arg4, *lparg4=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("wglDescribeLayerPlane\n")
+
+	if (arg4) lparg4 = getLAYERPLANEDESCRIPTORFields(env, arg4, &_arg4);
+	rc = (jboolean)wglDescribeLayerPlane((HDC)arg0, arg1, arg2, arg3, (LPLAYERPLANEDESCRIPTOR)lparg4);
+	if (arg4) setLAYERPLANEDESCRIPTORFields(env, arg4, lparg4);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglGetCurrentContext)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("wglGetCurrentContext\n")
+
+	return (jint)wglGetCurrentContext();
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglGetCurrentDC)
+	(JNIEnv *env, jclass that)
+{
+	DEBUG_CALL("wglGetCurrentDC\n")
+
+	return (jint)wglGetCurrentDC();
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglGetLayerPaletteEntries)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)
+{
+	jint *lparg4=NULL;
+	jint rc;
+
+	DEBUG_CALL("wglGetLayerPaletteEntries\n")
+
+	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
+	rc = (jint)wglGetLayerPaletteEntries((HDC)arg0, arg1, arg2, arg3, (COLORREF *)lparg4);
+	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
+	return rc;
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglGetProcAddress)
+	(JNIEnv *env, jclass that, jbyteArray arg0)
+{
+	jbyte *lparg0=NULL;
+	jint rc;
+
+	DEBUG_CALL("wglGetProcAddress\n")
+
+	if (arg0) lparg0 = (*env)->GetByteArrayElements(env, arg0, NULL);
+	rc = (jint)wglGetProcAddress((LPCSTR)lparg0);
+	if (arg0) (*env)->ReleaseByteArrayElements(env, arg0, lparg0, 0);
+	return rc;
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglMakeCurrent)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("wglMakeCurrent\n")
+
+	return (jboolean)wglMakeCurrent((HDC)arg0, (HGLRC)arg1);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglRealizeLayerPalette)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2)
+{
+	DEBUG_CALL("wglRealizeLayerPalette\n")
+
+	return (jboolean)wglRealizeLayerPalette((HDC)arg0, arg1, (BOOL)arg2);
+}
+
+JNIEXPORT jint JNICALL WGL_NATIVE(wglSetLayerPaletteEntries)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jintArray arg4)
+{
+	jint *lparg4=NULL;
+	jint rc;
+
+	DEBUG_CALL("wglSetLayerPaletteEntries\n")
+
+	if (arg4) lparg4 = (*env)->GetIntArrayElements(env, arg4, NULL);
+	rc = (jint)wglSetLayerPaletteEntries((HDC)arg0, arg1, arg2, arg3, (CONST COLORREF *)lparg4);
+	if (arg4) (*env)->ReleaseIntArrayElements(env, arg4, lparg4, 0);
+	return rc;
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglShareLists)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("wglShareLists\n")
+
+	return (jboolean)wglShareLists((HGLRC)arg0, (HGLRC)arg1);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglSwapLayerBuffers)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1)
+{
+	DEBUG_CALL("wglSwapLayerBuffers\n")
+
+	return (jboolean)wglSwapLayerBuffers((HDC)arg0, arg1);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontBitmapsA)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("wglUseFontBitmapsA\n")
+
+	return (jboolean)wglUseFontBitmapsA((HDC)arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontBitmapsW)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3)
+{
+	DEBUG_CALL("wglUseFontBitmapsW\n")
+
+	return (jboolean)wglUseFontBitmapsW((HDC)arg0, arg1, arg2, arg3);
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontOutlinesA)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jfloat arg4, jfloat arg5, jint arg6, jobject arg7)
+{
+//	GLYPHMETRICSFLOAT _arg7, *lparg7=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("wglUseFontOutlinesA\n")
+
+//	if (arg7) lparg7 = getGLYPHMETRICSFLOATFields(env, arg7, &_arg7);
+	rc = (jboolean)wglUseFontOutlinesA((HDC)arg0, arg1, arg2, arg3, (FLOAT)arg4, (FLOAT)arg5, arg6, (LPGLYPHMETRICSFLOAT)arg7);
+//	if (arg7) setGLYPHMETRICSFLOATFields(env, arg7, lparg7);
+	return rc;
+}
+
+JNIEXPORT jboolean JNICALL WGL_NATIVE(wglUseFontOutlinesW)
+	(JNIEnv *env, jclass that, jint arg0, jint arg1, jint arg2, jint arg3, jfloat arg4, jfloat arg5, jint arg6, jobject arg7)
+{
+//	GLYPHMETRICSFLOAT _arg7, *lparg7=NULL;
+	jboolean rc;
+
+	DEBUG_CALL("wglUseFontOutlinesW\n")
+
+//	if (arg7) lparg7 = getGLYPHMETRICSFLOATFields(env, arg7, &_arg7);
+	rc = (jboolean)wglUseFontOutlinesW((HDC)arg0, arg1, arg2, arg3, (FLOAT)arg4, (FLOAT)arg5, arg6, (LPGLYPHMETRICSFLOAT)arg7);
+//	if (arg7) setGLYPHMETRICSFLOATFields(env, arg7, lparg7);
+	return rc;
+}
+
+JNIEXPORT void JNICALL WGL_NATIVE(MoveMemoryW__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	GLYPHMETRICSFLOAT _arg0, *lparg0=NULL;
+
+	DEBUG_CALL("MoveMemoryW__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II\n")
+	DEBUG_CHECK_NULL(env, arg1)
+	
+	if (arg0) lparg0 = &_arg0;
+	MoveMemory((PVOID)lparg0, (CONST VOID *)arg1, arg2);
+	if (arg0) setGLYPHMETRICSFLOATFields(env, arg0, lparg0);
+}
+
+JNIEXPORT void JNICALL WGL_NATIVE(MoveMemoryA__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II)
+	(JNIEnv *env, jclass that, jobject arg0, jint arg1, jint arg2)
+{
+	GLYPHMETRICSFLOAT _arg0, *lparg0=NULL;
+
+	DEBUG_CALL("MoveMemoryA__Lorg_eclipse_swt_opengl_internal_win32_GLYPHMETRICSFLOAT_2II\n")
+	DEBUG_CHECK_NULL(env, arg1)
+	
+	if (arg0) lparg0 = &_arg0;
+	MoveMemory((PVOID)lparg0, (CONST VOID *)arg1, arg2);
+	if (arg0) setGLYPHMETRICSFLOATFields(env, arg0, lparg0);
+}
+
+
diff --git a/bundles/org.eclipse.swt.opengl/win32/gl_library/make_win32.mak b/bundles/org.eclipse.swt.opengl/win32/gl_library/make_win32.mak
new file mode 100644
index 0000000000..30df1a6cbe
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/gl_library/make_win32.mak
@@ -0,0 +1,56 @@
+#*******************************************************************************
+# Copyright (c) 2000, 2003 IBM Corporation and others.
+# All rights reserved. This program and the accompanying materials 
+# are made available under the terms of the Common Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/cpl-v10.html
+# 
+# Contributors:
+#     IBM Corporation - initial API and implementation
+#*******************************************************************************
+
+# assumes JAVA_HOME is set in the environment from which nmake is run
+
+APPVER=5.0
+!include <win32.mak>
+
+pgm_ver_str="SWT $(maj_ver).$(min_ver) for Windows"
+timestamp_str=__DATE__\" \"__TIME__\" (EST)\"
+copyright = "Copyright (C) 1999, 2003 IBM Corp.  All rights reserved."
+
+SWT_PREFIX=gl
+WS_PREFIX=win32
+SWT_LIB     = $(SWT_PREFIX)-$(WS_PREFIX).dll
+
+LINK_LIBS = opengl32.lib glu32.lib gdi32.lib
+
+# note: thoroughly test all examples after changing any optimization flags
+SWT_CDEBUG = #-Zi -Odi
+SWT_LDEBUG = #/DEBUG /DEBUGTYPE:both
+CFLAGS = -c -W3 -G6 -GD -O1 $(SWT_CDEBUG) -nologo -D_X86_=1 -D_WIN32 -D_WIN95 -D_WIN32_WINDOWS=0x0400 -D_MT -MT -DWIN32 -D_WIN32_DCOM /I$(JAVA_HOME)\include /I.
+RCFLAGS = -DSWT_COMMA_VERSION=$(comma_ver)
+LFLAGS = /INCREMENTAL:NO /PDB:NONE /RELEASE /NOLOGO $(SWT_LDEBUG) -entry:_DllMainCRTStartup@12 -dll /BASE:0x10000000 /comment:$(pgm_ver_str) /comment:$(copyright) /DLL
+
+SWT_OBJS = gl.obj glu.obj glw.obj structs.obj
+
+all: $(SWT_LIB)
+
+.c.obj:
+	cl $(CFLAGS) $*.c
+
+$(SWT_LIB): $(SWT_OBJS) swt.res
+	echo $(LFLAGS) >templrf
+	echo $(LINK_LIBS) >>templrf
+	echo -machine:IX86 >>templrf
+	echo -subsystem:windows >>templrf
+	echo -out:$(SWT_LIB) >>templrf
+	echo $(SWT_OBJS) >>templrf
+	echo swt.res >>templrf
+	link @templrf
+	del templrf
+	
+swt.res:
+	rc $(RCFLAGS) -DSWT_ORG_FILENAME=\"$(SWT_LIB)\" -r -fo swt.res swt.rc
+	
+clean:
+    del *.obj *.res *.dll *.lib *.exp
diff --git a/bundles/org.eclipse.swt.opengl/win32/gl_library/structs.c b/bundles/org.eclipse.swt.opengl/win32/gl_library/structs.c
new file mode 100644
index 0000000000..7c1c26e1a7
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/gl_library/structs.c
@@ -0,0 +1,304 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+
+#include "swt.h"
+#include "structs.h"
+
+typedef struct GLYPHMETRICSFLOAT_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID gmfCellIncY, gmfCellIncX, gmfptGlyphOrigin_y, gmfptGlyphOrigin_x, gmfBlackBoxY, gmfBlackBoxX;
+} GLYPHMETRICSFLOAT_FID_CACHE;
+typedef GLYPHMETRICSFLOAT_FID_CACHE *PGLYPHMETRICSFLOAT_FID_CACHE;
+
+GLYPHMETRICSFLOAT_FID_CACHE GLYPHMETRICSFLOATFc;
+
+void cacheGLYPHMETRICSFLOATFids(JNIEnv *env, jobject lpObject, PGLYPHMETRICSFLOAT_FID_CACHE lpCache)
+{
+	if (lpCache->cached) return;
+	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+	lpCache->gmfCellIncY = (*env)->GetFieldID(env, lpCache->clazz, "gmfCellIncY", "F");
+	lpCache->gmfCellIncX = (*env)->GetFieldID(env, lpCache->clazz, "gmfCellIncX", "F");
+	lpCache->gmfptGlyphOrigin_y = (*env)->GetFieldID(env, lpCache->clazz, "gmfptGlyphOrigin_y", "F");
+	lpCache->gmfptGlyphOrigin_x = (*env)->GetFieldID(env, lpCache->clazz, "gmfptGlyphOrigin_x", "F");
+	lpCache->gmfBlackBoxY = (*env)->GetFieldID(env, lpCache->clazz, "gmfBlackBoxY", "F");
+	lpCache->gmfBlackBoxX = (*env)->GetFieldID(env, lpCache->clazz, "gmfBlackBoxX", "F");
+	lpCache->cached = 1;
+}
+
+GLYPHMETRICSFLOAT *getGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct)
+{
+	PGLYPHMETRICSFLOAT_FID_CACHE lpCache = &GLYPHMETRICSFLOATFc;
+	if (!lpCache->cached) cacheGLYPHMETRICSFLOATFids(env, lpObject, lpCache);
+	lpStruct->gmfCellIncY = (*env)->GetFloatField(env, lpObject, lpCache->gmfCellIncY);
+	lpStruct->gmfCellIncX = (*env)->GetFloatField(env, lpObject, lpCache->gmfCellIncX);
+	lpStruct->gmfptGlyphOrigin.y = (*env)->GetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_y);
+	lpStruct->gmfptGlyphOrigin.x = (*env)->GetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_x);
+	lpStruct->gmfBlackBoxY = (*env)->GetFloatField(env, lpObject, lpCache->gmfBlackBoxY);
+	lpStruct->gmfBlackBoxX = (*env)->GetFloatField(env, lpObject, lpCache->gmfBlackBoxX);
+	return lpStruct;
+}
+
+void setGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct)
+{
+	PGLYPHMETRICSFLOAT_FID_CACHE lpCache = &GLYPHMETRICSFLOATFc;
+	if (!lpCache->cached) cacheGLYPHMETRICSFLOATFids(env, lpObject, lpCache);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfCellIncY, (jfloat)lpStruct->gmfCellIncY);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfCellIncX, (jfloat)lpStruct->gmfCellIncX);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_y, (jfloat)lpStruct->gmfptGlyphOrigin.y);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfptGlyphOrigin_x, (jfloat)lpStruct->gmfptGlyphOrigin.x);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfBlackBoxY, (jfloat)lpStruct->gmfBlackBoxY);
+	(*env)->SetFloatField(env, lpObject, lpCache->gmfBlackBoxX, (jfloat)lpStruct->gmfBlackBoxX);
+}
+
+typedef struct LAYERPLANEDESCRIPTOR_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID crTransparent, bReserved, iLayerPlane, cAuxBuffers, cStencilBits, cDepthBits, cAccumAlphaBits, cAccumBlueBits, cAccumGreenBits, cAccumRedBits, cAccumBits, cAlphaShift, cAlphaBits, cBlueShift, cBlueBits, cGreenShift, cGreenBits, cRedShift, cRedBits, cColorBits, iPixelType, dwFlags, nVersion, nSize;
+} LAYERPLANEDESCRIPTOR_FID_CACHE;
+typedef LAYERPLANEDESCRIPTOR_FID_CACHE *PLAYERPLANEDESCRIPTOR_FID_CACHE;
+
+LAYERPLANEDESCRIPTOR_FID_CACHE LAYERPLANEDESCRIPTORFc;
+
+void cacheLAYERPLANEDESCRIPTORFids(JNIEnv *env, jobject lpObject, PLAYERPLANEDESCRIPTOR_FID_CACHE lpCache)
+{
+	if (lpCache->cached) return;
+	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+	lpCache->crTransparent = (*env)->GetFieldID(env, lpCache->clazz, "crTransparent", "I");
+	lpCache->bReserved = (*env)->GetFieldID(env, lpCache->clazz, "bReserved", "B");
+	lpCache->iLayerPlane = (*env)->GetFieldID(env, lpCache->clazz, "iLayerPlane", "B");
+	lpCache->cAuxBuffers = (*env)->GetFieldID(env, lpCache->clazz, "cAuxBuffers", "B");
+	lpCache->cStencilBits = (*env)->GetFieldID(env, lpCache->clazz, "cStencilBits", "B");
+	lpCache->cDepthBits = (*env)->GetFieldID(env, lpCache->clazz, "cDepthBits", "B");
+	lpCache->cAccumAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumAlphaBits", "B");
+	lpCache->cAccumBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBlueBits", "B");
+	lpCache->cAccumGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumGreenBits", "B");
+	lpCache->cAccumRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumRedBits", "B");
+	lpCache->cAccumBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBits", "B");
+	lpCache->cAlphaShift = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaShift", "B");
+	lpCache->cAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaBits", "B");
+	lpCache->cBlueShift = (*env)->GetFieldID(env, lpCache->clazz, "cBlueShift", "B");
+	lpCache->cBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cBlueBits", "B");
+	lpCache->cGreenShift = (*env)->GetFieldID(env, lpCache->clazz, "cGreenShift", "B");
+	lpCache->cGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cGreenBits", "B");
+	lpCache->cRedShift = (*env)->GetFieldID(env, lpCache->clazz, "cRedShift", "B");
+	lpCache->cRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cRedBits", "B");
+	lpCache->cColorBits = (*env)->GetFieldID(env, lpCache->clazz, "cColorBits", "B");
+	lpCache->iPixelType = (*env)->GetFieldID(env, lpCache->clazz, "iPixelType", "B");
+	lpCache->dwFlags = (*env)->GetFieldID(env, lpCache->clazz, "dwFlags", "I");
+	lpCache->nVersion = (*env)->GetFieldID(env, lpCache->clazz, "nVersion", "S");
+	lpCache->nSize = (*env)->GetFieldID(env, lpCache->clazz, "nSize", "S");
+	lpCache->cached = 1;
+}
+
+LAYERPLANEDESCRIPTOR *getLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct)
+{
+	PLAYERPLANEDESCRIPTOR_FID_CACHE lpCache = &LAYERPLANEDESCRIPTORFc;
+	if (!lpCache->cached) cacheLAYERPLANEDESCRIPTORFids(env, lpObject, lpCache);
+	lpStruct->crTransparent = (*env)->GetIntField(env, lpObject, lpCache->crTransparent);
+	lpStruct->bReserved = (*env)->GetByteField(env, lpObject, lpCache->bReserved);
+	lpStruct->iLayerPlane = (*env)->GetByteField(env, lpObject, lpCache->iLayerPlane);
+	lpStruct->cAuxBuffers = (*env)->GetByteField(env, lpObject, lpCache->cAuxBuffers);
+	lpStruct->cStencilBits = (*env)->GetByteField(env, lpObject, lpCache->cStencilBits);
+	lpStruct->cDepthBits = (*env)->GetByteField(env, lpObject, lpCache->cDepthBits);
+	lpStruct->cAccumAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumAlphaBits);
+	lpStruct->cAccumBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBlueBits);
+	lpStruct->cAccumGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumGreenBits);
+	lpStruct->cAccumRedBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumRedBits);
+	lpStruct->cAccumBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBits);
+	lpStruct->cAlphaShift = (*env)->GetByteField(env, lpObject, lpCache->cAlphaShift);
+	lpStruct->cAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAlphaBits);
+	lpStruct->cBlueShift = (*env)->GetByteField(env, lpObject, lpCache->cBlueShift);
+	lpStruct->cBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cBlueBits);
+	lpStruct->cGreenShift = (*env)->GetByteField(env, lpObject, lpCache->cGreenShift);
+	lpStruct->cGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cGreenBits);
+	lpStruct->cRedShift = (*env)->GetByteField(env, lpObject, lpCache->cRedShift);
+	lpStruct->cRedBits = (*env)->GetByteField(env, lpObject, lpCache->cRedBits);
+	lpStruct->cColorBits = (*env)->GetByteField(env, lpObject, lpCache->cColorBits);
+	lpStruct->iPixelType = (*env)->GetByteField(env, lpObject, lpCache->iPixelType);
+	lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, lpCache->dwFlags);
+	lpStruct->nVersion = (*env)->GetShortField(env, lpObject, lpCache->nVersion);
+	lpStruct->nSize = (*env)->GetShortField(env, lpObject, lpCache->nSize);
+	return lpStruct;
+}
+
+void setLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct)
+{
+	PLAYERPLANEDESCRIPTOR_FID_CACHE lpCache = &LAYERPLANEDESCRIPTORFc;
+	if (!lpCache->cached) cacheLAYERPLANEDESCRIPTORFids(env, lpObject, lpCache);
+	(*env)->SetIntField(env, lpObject, lpCache->crTransparent, (jint)lpStruct->crTransparent);
+	(*env)->SetByteField(env, lpObject, lpCache->bReserved, (jbyte)lpStruct->bReserved);
+	(*env)->SetByteField(env, lpObject, lpCache->iLayerPlane, (jbyte)lpStruct->iLayerPlane);
+	(*env)->SetByteField(env, lpObject, lpCache->cAuxBuffers, (jbyte)lpStruct->cAuxBuffers);
+	(*env)->SetByteField(env, lpObject, lpCache->cStencilBits, (jbyte)lpStruct->cStencilBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cDepthBits, (jbyte)lpStruct->cDepthBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumAlphaBits, (jbyte)lpStruct->cAccumAlphaBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumBlueBits, (jbyte)lpStruct->cAccumBlueBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumGreenBits, (jbyte)lpStruct->cAccumGreenBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumRedBits, (jbyte)lpStruct->cAccumRedBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumBits, (jbyte)lpStruct->cAccumBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAlphaShift, (jbyte)lpStruct->cAlphaShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cAlphaBits, (jbyte)lpStruct->cAlphaBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cBlueShift, (jbyte)lpStruct->cBlueShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cBlueBits, (jbyte)lpStruct->cBlueBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cGreenShift, (jbyte)lpStruct->cGreenShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cGreenBits, (jbyte)lpStruct->cGreenBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cRedShift, (jbyte)lpStruct->cRedShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cRedBits, (jbyte)lpStruct->cRedBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cColorBits, (jbyte)lpStruct->cColorBits);
+	(*env)->SetByteField(env, lpObject, lpCache->iPixelType, (jbyte)lpStruct->iPixelType);
+	(*env)->SetIntField(env, lpObject, lpCache->dwFlags, (jint)lpStruct->dwFlags);
+	(*env)->SetShortField(env, lpObject, lpCache->nVersion, (jshort)lpStruct->nVersion);
+	(*env)->SetShortField(env, lpObject, lpCache->nSize, (jshort)lpStruct->nSize);
+}
+
+typedef struct POINTFLOAT_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID y, x;
+} POINTFLOAT_FID_CACHE;
+typedef POINTFLOAT_FID_CACHE *PPOINTFLOAT_FID_CACHE;
+
+POINTFLOAT_FID_CACHE POINTFLOATFc;
+
+void cachePOINTFLOATFids(JNIEnv *env, jobject lpObject, PPOINTFLOAT_FID_CACHE lpCache)
+{
+	if (lpCache->cached) return;
+	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+	lpCache->y = (*env)->GetFieldID(env, lpCache->clazz, "y", "F");
+	lpCache->x = (*env)->GetFieldID(env, lpCache->clazz, "x", "F");
+	lpCache->cached = 1;
+}
+
+POINTFLOAT *getPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct)
+{
+	PPOINTFLOAT_FID_CACHE lpCache = &POINTFLOATFc;
+	if (!lpCache->cached) cachePOINTFLOATFids(env, lpObject, lpCache);
+	lpStruct->y = (*env)->GetFloatField(env, lpObject, lpCache->y);
+	lpStruct->x = (*env)->GetFloatField(env, lpObject, lpCache->x);
+	return lpStruct;
+}
+
+void setPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct)
+{
+	PPOINTFLOAT_FID_CACHE lpCache = &POINTFLOATFc;
+	if (!lpCache->cached) cachePOINTFLOATFids(env, lpObject, lpCache);
+	(*env)->SetFloatField(env, lpObject, lpCache->y, (jfloat)lpStruct->y);
+	(*env)->SetFloatField(env, lpObject, lpCache->x, (jfloat)lpStruct->x);
+}
+
+typedef struct PIXELFORMATDESCRIPTOR_FID_CACHE {
+	int cached;
+	jclass clazz;
+	jfieldID dwDamageMask, dwVisibleMask, dwLayerMask, bReserved, iLayerType, cAuxBuffers, cStencilBits, cDepthBits, cAccumAlphaBits, cAccumBlueBits, cAccumGreenBits, cAccumRedBits, cAccumBits, cAlphaShift, cAlphaBits, cBlueShift, cBlueBits, cGreenShift, cGreenBits, cRedShift, cRedBits, cColorBits, iPixelType, dwFlags, nVersion, nSize;
+} PIXELFORMATDESCRIPTOR_FID_CACHE;
+typedef PIXELFORMATDESCRIPTOR_FID_CACHE *PPIXELFORMATDESCRIPTOR_FID_CACHE;
+
+PIXELFORMATDESCRIPTOR_FID_CACHE PIXELFORMATDESCRIPTORFc;
+
+void cachePIXELFORMATDESCRIPTORFids(JNIEnv *env, jobject lpObject, PPIXELFORMATDESCRIPTOR_FID_CACHE lpCache)
+{
+	if (lpCache->cached) return;
+	lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+	lpCache->dwDamageMask = (*env)->GetFieldID(env, lpCache->clazz, "dwDamageMask", "I");
+	lpCache->dwVisibleMask = (*env)->GetFieldID(env, lpCache->clazz, "dwVisibleMask", "I");
+	lpCache->dwLayerMask = (*env)->GetFieldID(env, lpCache->clazz, "dwLayerMask", "I");
+	lpCache->bReserved = (*env)->GetFieldID(env, lpCache->clazz, "bReserved", "B");
+	lpCache->iLayerType = (*env)->GetFieldID(env, lpCache->clazz, "iLayerType", "B");
+	lpCache->cAuxBuffers = (*env)->GetFieldID(env, lpCache->clazz, "cAuxBuffers", "B");
+	lpCache->cStencilBits = (*env)->GetFieldID(env, lpCache->clazz, "cStencilBits", "B");
+	lpCache->cDepthBits = (*env)->GetFieldID(env, lpCache->clazz, "cDepthBits", "B");
+	lpCache->cAccumAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumAlphaBits", "B");
+	lpCache->cAccumBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBlueBits", "B");
+	lpCache->cAccumGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumGreenBits", "B");
+	lpCache->cAccumRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumRedBits", "B");
+	lpCache->cAccumBits = (*env)->GetFieldID(env, lpCache->clazz, "cAccumBits", "B");
+	lpCache->cAlphaShift = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaShift", "B");
+	lpCache->cAlphaBits = (*env)->GetFieldID(env, lpCache->clazz, "cAlphaBits", "B");
+	lpCache->cBlueShift = (*env)->GetFieldID(env, lpCache->clazz, "cBlueShift", "B");
+	lpCache->cBlueBits = (*env)->GetFieldID(env, lpCache->clazz, "cBlueBits", "B");
+	lpCache->cGreenShift = (*env)->GetFieldID(env, lpCache->clazz, "cGreenShift", "B");
+	lpCache->cGreenBits = (*env)->GetFieldID(env, lpCache->clazz, "cGreenBits", "B");
+	lpCache->cRedShift = (*env)->GetFieldID(env, lpCache->clazz, "cRedShift", "B");
+	lpCache->cRedBits = (*env)->GetFieldID(env, lpCache->clazz, "cRedBits", "B");
+	lpCache->cColorBits = (*env)->GetFieldID(env, lpCache->clazz, "cColorBits", "B");
+	lpCache->iPixelType = (*env)->GetFieldID(env, lpCache->clazz, "iPixelType", "B");
+	lpCache->dwFlags = (*env)->GetFieldID(env, lpCache->clazz, "dwFlags", "I");
+	lpCache->nVersion = (*env)->GetFieldID(env, lpCache->clazz, "nVersion", "S");
+	lpCache->nSize = (*env)->GetFieldID(env, lpCache->clazz, "nSize", "S");
+	lpCache->cached = 1;
+}
+
+PIXELFORMATDESCRIPTOR *getPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct)
+{
+	PPIXELFORMATDESCRIPTOR_FID_CACHE lpCache = &PIXELFORMATDESCRIPTORFc;
+	if (!lpCache->cached) cachePIXELFORMATDESCRIPTORFids(env, lpObject, lpCache);
+	lpStruct->dwDamageMask = (*env)->GetIntField(env, lpObject, lpCache->dwDamageMask);
+	lpStruct->dwVisibleMask = (*env)->GetIntField(env, lpObject, lpCache->dwVisibleMask);
+	lpStruct->dwLayerMask = (*env)->GetIntField(env, lpObject, lpCache->dwLayerMask);
+	lpStruct->bReserved = (*env)->GetByteField(env, lpObject, lpCache->bReserved);
+	lpStruct->iLayerType = (*env)->GetByteField(env, lpObject, lpCache->iLayerType);
+	lpStruct->cAuxBuffers = (*env)->GetByteField(env, lpObject, lpCache->cAuxBuffers);
+	lpStruct->cStencilBits = (*env)->GetByteField(env, lpObject, lpCache->cStencilBits);
+	lpStruct->cDepthBits = (*env)->GetByteField(env, lpObject, lpCache->cDepthBits);
+	lpStruct->cAccumAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumAlphaBits);
+	lpStruct->cAccumBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBlueBits);
+	lpStruct->cAccumGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumGreenBits);
+	lpStruct->cAccumRedBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumRedBits);
+	lpStruct->cAccumBits = (*env)->GetByteField(env, lpObject, lpCache->cAccumBits);
+	lpStruct->cAlphaShift = (*env)->GetByteField(env, lpObject, lpCache->cAlphaShift);
+	lpStruct->cAlphaBits = (*env)->GetByteField(env, lpObject, lpCache->cAlphaBits);
+	lpStruct->cBlueShift = (*env)->GetByteField(env, lpObject, lpCache->cBlueShift);
+	lpStruct->cBlueBits = (*env)->GetByteField(env, lpObject, lpCache->cBlueBits);
+	lpStruct->cGreenShift = (*env)->GetByteField(env, lpObject, lpCache->cGreenShift);
+	lpStruct->cGreenBits = (*env)->GetByteField(env, lpObject, lpCache->cGreenBits);
+	lpStruct->cRedShift = (*env)->GetByteField(env, lpObject, lpCache->cRedShift);
+	lpStruct->cRedBits = (*env)->GetByteField(env, lpObject, lpCache->cRedBits);
+	lpStruct->cColorBits = (*env)->GetByteField(env, lpObject, lpCache->cColorBits);
+	lpStruct->iPixelType = (*env)->GetByteField(env, lpObject, lpCache->iPixelType);
+	lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, lpCache->dwFlags);
+	lpStruct->nVersion = (*env)->GetShortField(env, lpObject, lpCache->nVersion);
+	lpStruct->nSize = (*env)->GetShortField(env, lpObject, lpCache->nSize);
+	return lpStruct;
+}
+
+void setPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct)
+{
+	PPIXELFORMATDESCRIPTOR_FID_CACHE lpCache = &PIXELFORMATDESCRIPTORFc;
+	if (!lpCache->cached) cachePIXELFORMATDESCRIPTORFids(env, lpObject, lpCache);
+	(*env)->SetIntField(env, lpObject, lpCache->dwDamageMask, (jint)lpStruct->dwDamageMask);
+	(*env)->SetIntField(env, lpObject, lpCache->dwVisibleMask, (jint)lpStruct->dwVisibleMask);
+	(*env)->SetIntField(env, lpObject, lpCache->dwLayerMask, (jint)lpStruct->dwLayerMask);
+	(*env)->SetByteField(env, lpObject, lpCache->bReserved, (jbyte)lpStruct->bReserved);
+	(*env)->SetByteField(env, lpObject, lpCache->iLayerType, (jbyte)lpStruct->iLayerType);
+	(*env)->SetByteField(env, lpObject, lpCache->cAuxBuffers, (jbyte)lpStruct->cAuxBuffers);
+	(*env)->SetByteField(env, lpObject, lpCache->cStencilBits, (jbyte)lpStruct->cStencilBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cDepthBits, (jbyte)lpStruct->cDepthBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumAlphaBits, (jbyte)lpStruct->cAccumAlphaBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumBlueBits, (jbyte)lpStruct->cAccumBlueBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumGreenBits, (jbyte)lpStruct->cAccumGreenBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumRedBits, (jbyte)lpStruct->cAccumRedBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAccumBits, (jbyte)lpStruct->cAccumBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cAlphaShift, (jbyte)lpStruct->cAlphaShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cAlphaBits, (jbyte)lpStruct->cAlphaBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cBlueShift, (jbyte)lpStruct->cBlueShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cBlueBits, (jbyte)lpStruct->cBlueBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cGreenShift, (jbyte)lpStruct->cGreenShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cGreenBits, (jbyte)lpStruct->cGreenBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cRedShift, (jbyte)lpStruct->cRedShift);
+	(*env)->SetByteField(env, lpObject, lpCache->cRedBits, (jbyte)lpStruct->cRedBits);
+	(*env)->SetByteField(env, lpObject, lpCache->cColorBits, (jbyte)lpStruct->cColorBits);
+	(*env)->SetByteField(env, lpObject, lpCache->iPixelType, (jbyte)lpStruct->iPixelType);
+	(*env)->SetIntField(env, lpObject, lpCache->dwFlags, (jint)lpStruct->dwFlags);
+	(*env)->SetShortField(env, lpObject, lpCache->nVersion, (jshort)lpStruct->nVersion);
+	(*env)->SetShortField(env, lpObject, lpCache->nSize, (jshort)lpStruct->nSize);
+}
+
diff --git a/bundles/org.eclipse.swt.opengl/win32/gl_library/structs.h b/bundles/org.eclipse.swt.opengl/win32/gl_library/structs.h
new file mode 100644
index 0000000000..031dadfc3b
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/gl_library/structs.h
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+#include <windows.h>
+
+GLYPHMETRICSFLOAT *getGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct);
+void setGLYPHMETRICSFLOATFields(JNIEnv *env, jobject lpObject, GLYPHMETRICSFLOAT *lpStruct);
+
+LAYERPLANEDESCRIPTOR *getLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct);
+void setLAYERPLANEDESCRIPTORFields(JNIEnv *env, jobject lpObject, LAYERPLANEDESCRIPTOR *lpStruct);
+
+POINTFLOAT *getPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct);
+void setPOINTFLOATFields(JNIEnv *env, jobject lpObject, POINTFLOAT *lpStruct);
+
+PIXELFORMATDESCRIPTOR *getPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct);
+void setPIXELFORMATDESCRIPTORFields(JNIEnv *env, jobject lpObject, PIXELFORMATDESCRIPTOR *lpStruct);
+
diff --git a/bundles/org.eclipse.swt.opengl/win32/gl_library/swt.rc b/bundles/org.eclipse.swt.opengl/win32/gl_library/swt.rc
new file mode 100644
index 0000000000..68b7074163
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/gl_library/swt.rc
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+ 
+#include "windows.h"
+
+VS_VERSION_INFO VERSIONINFO
+ PRODUCTVERSION 0,0,0,0
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40000L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "IBM Corporation\0"
+            VALUE "FileDescription", "Standard Widget Toolkit\0"
+            VALUE "InternalName", "SWT\0"
+            VALUE "LegalCopyright", "� Copyright 2000, 2003 IBM Corp.  All Rights Reserved.\0"
+            VALUE "OriginalFilename", SWT_ORG_FILENAME
+            VALUE "ProductName", "\0"
+            VALUE "ProductVersion", "0,0,0,0\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+/* SHMENUBAR Pocket PC 
+ * ID_MENU SHMENUBAR DISCARDABLE
+ * BEGIN
+ * 	ID_MENU, 1,
+ *  IMAGE_NONE, ID_MENU_ITEM1, 0, 0,
+ *  0, 0, 0,
+ * END
+ * ID_MENU MENU DISCARDABLE
+ * BEGIN
+ *  MENUITEM "", ID_MENU_ITEM1
+ * END
+ */
+100 RCDATA DISCARDABLE 
+BEGIN
+    100, 1,
+    -2, 101, 0, 0, 
+    0, 0, 0,
+END
+
+100 MENU DISCARDABLE
+BEGIN
+	MENUITEM "", 101
+END
+\ No newline at end of file
diff --git a/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/GLContext.java b/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/GLContext.java
new file mode 100644
index 0000000000..b2863df75c
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/GLContext.java
@@ -0,0 +1,313 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl;
+
+
+import org.eclipse.swt.*;
+import org.eclipse.swt.graphics.*;
+import org.eclipse.swt.opengl.internal.win32.*;
+import org.eclipse.swt.internal.win32.*;
+
+/**
+ * Instances of <code>GLContext</code> are used to draw on swt <code>Drawable</code>s 
+ * through invocations of provided OpenGL functions.
+ * <p>
+ * Application code must explicitly invoke the <code>GLContext.dispose ()</code> 
+ * method to release the operating system resources managed by each instance
+ * when those instances are no longer required. This is <em>particularly</em>
+ * important on Windows95 and Windows98 where the operating system has a limited
+ * number of device contexts available.
+ * </p>
+ */
+public class GLContext {
+	int handle;
+	int hDC;
+	GCData data;
+	Drawable drawable;
+	int selectBufferPtr = 0;
+
+	static final int MSB_FIRST = 1;
+	static final int LSB_FIRST = 2;
+
+	/**
+	 * Constructs a new instance of this class which has been
+	 * configured to draw on the specified drawable.
+	 * <p>
+	 * You must dispose the <code>GLContext</code> when it is no longer required. 
+	 * </p>
+	 * 
+	 * @param drawable the drawable to draw on
+	 * @exception IllegalArgumentException <ul>
+	 *    <li>ERROR_NULL_ARGUMENT - if the drawable is null</li>
+	 * </ul>
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_NO_HANDLES if a handle could not be obtained for gc creation</li>
+	 *    <li>ERROR_UNSUPPORTED_DEPTH - if the current display depth is not supported</li>
+	 * </ul>
+	 */
+	public GLContext (Drawable drawable) {
+		if (drawable == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);
+		this.drawable = drawable;
+		this.data = new GCData ();
+		hDC = drawable.internal_new_GC (data);
+		if (hDC == 0) SWT.error (SWT.ERROR_NO_HANDLES);
+		int bits = OS.GetDeviceCaps (hDC, OS.BITSPIXEL);
+		int planes = OS.GetDeviceCaps (hDC, OS.PLANES);
+		int depth = bits * planes;
+		PIXELFORMATDESCRIPTOR pfd = new PIXELFORMATDESCRIPTOR ();
+		pfd.nSize = (short) PIXELFORMATDESCRIPTOR.sizeof;
+		pfd.nVersion = 1;
+		pfd.dwFlags =
+			WGL.PFD_DRAW_TO_WINDOW
+				| WGL.PFD_SUPPORT_OPENGL
+				| WGL.PFD_DOUBLEBUFFER;
+		pfd.dwLayerMask = WGL.PFD_MAIN_PLANE;
+		pfd.iPixelType = (byte) WGL.PFD_TYPE_RGBA;
+		pfd.cColorBits = (byte) depth;
+		pfd.cDepthBits = (byte) depth;
+		pfd.cAccumBits = 0;
+		pfd.cStencilBits = 0;
+		int pixelFormat = WGL.ChoosePixelFormat (hDC, pfd);
+		if (pixelFormat == 0) {
+			drawable.internal_dispose_GC (hDC, data);
+			SWT.error (SWT.ERROR_UNSUPPORTED_DEPTH);
+		}
+		if (!WGL.SetPixelFormat (hDC, pixelFormat, pfd)) {
+			drawable.internal_dispose_GC (hDC, data);
+			SWT.error (SWT.ERROR_UNSUPPORTED_DEPTH);
+		}
+		handle = WGL.wglCreateContext (hDC);
+		if (handle == 0) SWT.error (SWT.ERROR_NO_HANDLES);
+	}
+
+	public ImageData convertImageData (ImageData source) {
+		PaletteData palette = new PaletteData (0xff0000, 0xff00, 0xff);
+		ImageData newSource = new ImageData (source.width, source.height, 24, palette);
+
+		ImageDataUtil.blit (
+			1,
+			source.data,
+			source.depth,
+			source.bytesPerLine,
+			(source.depth != 16) ? MSB_FIRST : LSB_FIRST,
+			0,
+			0,
+			source.width,
+			source.height,
+			source.palette.redMask,
+			source.palette.greenMask,
+			source.palette.blueMask,
+			255,
+			null,
+			0,
+			0,
+			0,
+			newSource.data,
+			newSource.depth,
+			newSource.bytesPerLine,
+			(newSource.depth != 16) ? MSB_FIRST : LSB_FIRST,
+			0,
+			0,
+			newSource.width,
+			newSource.height,
+			newSource.palette.redMask,
+			newSource.palette.greenMask,
+			newSource.palette.blueMask,
+			false,
+			true);
+
+		return newSource;
+	}
+
+	/**
+	 * Disposes of the operating system resources associated with
+	 * the receiver. Applications must dispose of all <code>GLContext</code>s
+	 * that they allocate.
+	 */
+	public void dispose () {
+		if (handle == 0) return;
+		if (WGL.wglGetCurrentContext () == handle) {
+			WGL.wglMakeCurrent (0, 0);
+		}
+		WGL.wglDeleteContext (handle);
+		handle = 0;
+
+		// drawable may be disposed
+		try {
+			drawable.internal_dispose_GC (hDC, data);
+		} catch (SWTException e) {
+		}
+		int hHeap = OS.GetProcessHeap ();
+		if (selectBufferPtr != 0) {
+			OS.HeapFree (hHeap, 0, selectBufferPtr);
+		}
+		hDC = 0;
+		drawable = null;
+		data.device = null;
+		data = null;
+	}
+
+	public int[] getSelectBuffer (int selectBufferPtr, int[] selectBuffer) {
+		OS.MoveMemory (selectBuffer, selectBufferPtr, selectBuffer.length * 4);
+		return selectBuffer;
+	}
+
+	public int getSelectBufferPtr (int[] selectBuffer) {
+		if (selectBufferPtr == 0) {
+			int hHeap = OS.GetProcessHeap ();
+			selectBufferPtr =
+				OS.HeapAlloc (
+					hHeap,
+					OS.HEAP_ZERO_MEMORY,
+					selectBuffer.length * 4);
+		}
+		OS.MoveMemory (selectBufferPtr, selectBuffer, selectBuffer.length * 4);
+		return selectBufferPtr;
+	}
+
+	/**
+	 * Returns a boolean indicating whether the receiver is the current
+	 * <code>GLContext</code>.
+	 *  
+	 * @return true if the receiver is the current <code>GLContext</code>,
+	 * false otherwise
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_GRAPHIC_DISPOSED if the receiver is disposed</li>
+	 * </ul>
+	 */
+	public boolean isCurrent () {
+		if (isDisposed ()) SWT.error (SWT.ERROR_GRAPHIC_DISPOSED);
+		return WGL.wglGetCurrentContext () == handle;
+	}
+
+	/**
+	 * Returns a boolean indicating whether the <code>GLContext</code> has been
+	 * disposed.
+	 * <p>
+	 * This method gets the dispose state for the <code>GLContext</code>.
+	 * When a <code>GLContext</code> has been disposed, it is an error to
+	 * invoke any other method using the <code>GLContext</code>.
+	 *
+	 * @return true if the <code>GLContext</code> is disposed, false otherwise
+	 */
+	public boolean isDisposed () {
+		return handle == 0;
+	}
+
+	/**
+	 * Loads the specified bitmap font.
+	 * 
+	 * @param fdata
+	 * @param device
+	 * @param base
+	 * @param first
+	 * @param count
+	 */
+	public void loadBitmapFont (FontData fdata,	Device device, int base, int first,	int count) {
+		Font font = new Font (device, fdata);
+		int oldFont = OS.SelectObject (hDC, font.handle);
+		WGL.wglUseFontBitmaps (hDC, first, count, base);
+		OS.SelectObject (hDC, oldFont);
+		font.dispose ();
+	}
+
+	/**
+	 * Loads the specified outline font.
+	 * 
+	 * @param fdata
+	 * @param device
+	 * @param base
+	 * @param first
+	 * @param count
+	 * @param deviation
+	 * @param extrusion
+	 * @param format
+	 * @param lpgmf
+	 */
+	public void loadOutlineFont (FontData fdata, Device device, int base, int first,
+	int count, float deviation, float extrusion, int format, GLYPHMETRICSFLOAT[] lpgmf) {
+		int ptr = 0;
+		int hHeap = 0;
+		if (lpgmf != null && lpgmf.length == count + 1) {
+			hHeap = OS.GetProcessHeap ();
+			ptr =
+				OS.HeapAlloc (
+					hHeap,
+					OS.HEAP_ZERO_MEMORY,
+					count * GLYPHMETRICSFLOAT.sizeof);
+		}
+
+		if (format == GL.GL_POLYGON) {
+			format = WGL.WGL_FONT_POLYGONS;
+		} 
+		if (format == GL.GL_LINE) {
+			format = WGL.WGL_FONT_LINES;
+		} 
+
+		Font font = new Font (device, fdata);
+		int oldFont = OS.SelectObject (hDC, font.handle);
+		WGL.wglUseFontOutlines (hDC, first, count, base, deviation, extrusion, format, ptr);
+		OS.SelectObject (hDC, oldFont);
+		font.dispose ();
+		if (ptr != 0) {
+			int sizeof = GLYPHMETRICSFLOAT.sizeof;
+			for (int i = 0; i < lpgmf.length; i++) {
+				WGL.MoveMemory (lpgmf [i], ptr + (sizeof * i), sizeof);
+			};
+			OS.HeapFree (hHeap, 0, ptr);
+		}
+	}
+
+	/**
+	 * Resizes the receiver.
+	 * 
+	 * @param x
+	 * @param y
+	 * @param width
+	 * @param height
+	 */
+	public void resize (int x, int y, int width, int height) {
+		if (height == 0) height = 1;
+		GL.glViewport (0, 0, width, height);
+		float nRange = 200.0f;
+		GL.glMatrixMode (GL.GL_PROJECTION);
+		GL.glLoadIdentity ();
+		// load projection
+		GLU.gluPerspective (45.0f, (float) width / (float) height, 0.1f, 100.0f);
+		GL.glMatrixMode (GL.GL_MODELVIEW);
+		GL.glLoadIdentity ();
+	}
+
+	/**
+	 * Sets the receiver to be the current <code>GLContext</code>.
+	 * 
+ 	 * @exception SWTError <ul>
+	 *    <li>ERROR_GRAPHIC_DISPOSED if the receiver is disposed</li>
+	 * </ul>
+	 */
+	public void setCurrent () {
+		if (isDisposed ()) SWT.error (SWT.ERROR_GRAPHIC_DISPOSED);
+		if (WGL.wglGetCurrentContext () == handle) return;
+		WGL.wglMakeCurrent (hDC, handle);
+	}
+
+	/**
+	 * Swaps the receiver's buffers.
+	 * 
+	 * @exception SWTError <ul>
+	 *    <li>ERROR_GRAPHIC_DISPOSED if the receiver is disposed</li>
+	 * </ul>
+	 */
+	public void swapBuffers () {
+		if (isDisposed ()) SWT.error (SWT.ERROR_GRAPHIC_DISPOSED);
+		WGL.SwapBuffers (hDC);
+	}
+}
diff --git a/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/LAYERPLANEDESCRIPTOR.java b/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/LAYERPLANEDESCRIPTOR.java
new file mode 100644
index 0000000000..ec410a1f54
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/LAYERPLANEDESCRIPTOR.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl.internal.win32;
+
+
+public class LAYERPLANEDESCRIPTOR {
+    public short nSize;
+    public short nVersion;
+    public int dwFlags;
+    public byte iPixelType;
+    public byte cColorBits;
+    public byte cRedBits;
+    public byte cRedShift;
+    public byte cGreenBits;
+    public byte cGreenShift;
+    public byte cBlueBits;
+    public byte cBlueShift;
+    public byte cAlphaBits;
+    public byte cAlphaShift;
+    public byte cAccumBits;
+    public byte cAccumRedBits;
+    public byte cAccumGreenBits;
+    public byte cAccumBlueBits;
+    public byte cAccumAlphaBits;
+    public byte cDepthBits;
+    public byte cStencilBits;
+    public byte cAuxBuffers;
+    public byte iLayerPlane;
+    public byte bReserved;
+    public int crTransparent;
+	public static final int sizeof = 36;
+}
diff --git a/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/PIXELFORMATDESCRIPTOR.java b/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/PIXELFORMATDESCRIPTOR.java
new file mode 100644
index 0000000000..254f868f85
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/PIXELFORMATDESCRIPTOR.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl.internal.win32;
+
+
+public class PIXELFORMATDESCRIPTOR {
+   	public short nSize;
+    public short nVersion;
+    public int dwFlags;
+    public byte iPixelType;
+    public byte cColorBits;
+    public byte cRedBits;
+    public byte cRedShift;
+    public byte cGreenBits;
+    public byte cGreenShift;
+    public byte cBlueBits;
+    public byte cBlueShift;
+    public byte cAlphaBits;
+    public byte cAlphaShift;
+    public byte cAccumBits;
+    public byte cAccumRedBits;
+    public byte cAccumGreenBits;
+    public byte cAccumBlueBits;
+    public byte cAccumAlphaBits;
+    public byte cDepthBits;
+    public byte cStencilBits;
+    public byte cAuxBuffers;
+    public byte iLayerType;
+    public byte bReserved;
+    public int dwLayerMask;
+    public int dwVisibleMask;
+    public int dwDamageMask;
+	public static final int sizeof = 40;
+}
diff --git a/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/POINTFLOAT.java b/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/POINTFLOAT.java
new file mode 100644
index 0000000000..b0601f1953
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/POINTFLOAT.java
@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl.internal.win32;
+
+
+public class POINTFLOAT {
+	public float x;
+	public float y;
+	public static final int sizeof = 8;
+}
diff --git a/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/WGL.java b/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/WGL.java
new file mode 100644
index 0000000000..000f528d2d
--- /dev/null
+++ b/bundles/org.eclipse.swt.opengl/win32/org/eclipse/swt/opengl/internal/win32/WGL.java
@@ -0,0 +1,142 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.swt.opengl.internal.win32;
+
+
+import org.eclipse.swt.opengl.*;
+import org.eclipse.swt.opengl.Library;
+import org.eclipse.swt.internal.win32.OS;
+
+public class WGL {
+	
+static {
+	Library.loadLibrary("gl");
+}
+	
+public static final int WGL_FONT_LINES      = 0;
+public static final int WGL_FONT_POLYGONS   = 1;
+
+/* LAYERPLANEDESCRIPTOR flags */
+public static final int LPD_DOUBLEBUFFER        = 0x00000001;
+public static final int LPD_STEREO              = 0x00000002;
+public static final int LPD_SUPPORT_GDI         = 0x00000010;
+public static final int LPD_SUPPORT_OPENGL      = 0x00000020;
+public static final int LPD_SHARE_DEPTH         = 0x00000040;
+public static final int LPD_SHARE_STENCIL       = 0x00000080;
+public static final int LPD_SHARE_ACCUM         = 0x00000100;
+public static final int LPD_SWAP_EXCHANGE       = 0x00000200;
+public static final int LPD_SWAP_COPY           = 0x00000400;
+public static final int LPD_TRANSPARENT         = 0x00001000;
+
+public static final int LPD_TYPE_RGBA        = 0;
+public static final int LPD_TYPE_COLORINDEX  = 1;
+
+/* wglSwapLayerBuffers flags */
+public static final int WGL_SWAP_MAIN_PLANE     = 0x00000001;
+public static final int WGL_SWAP_OVERLAY1       = 0x00000002;
+public static final int WGL_SWAP_OVERLAY2       = 0x00000004;
+public static final int WGL_SWAP_OVERLAY3       = 0x00000008;
+public static final int WGL_SWAP_OVERLAY4       = 0x00000010;
+public static final int WGL_SWAP_OVERLAY5       = 0x00000020;
+public static final int WGL_SWAP_OVERLAY6       = 0x00000040;
+public static final int WGL_SWAP_OVERLAY7       = 0x00000080;
+public static final int WGL_SWAP_OVERLAY8       = 0x00000100;
+public static final int WGL_SWAP_OVERLAY9       = 0x00000200;
+public static final int WGL_SWAP_OVERLAY10      = 0x00000400;
+public static final int WGL_SWAP_OVERLAY11      = 0x00000800;
+public static final int WGL_SWAP_OVERLAY12      = 0x00001000;
+public static final int WGL_SWAP_OVERLAY13      = 0x00002000;
+public static final int WGL_SWAP_OVERLAY14      = 0x00004000;
+public static final int WGL_SWAP_OVERLAY15      = 0x00008000;
+public static final int WGL_SWAP_UNDERLAY1      = 0x00010000;
+public static final int WGL_SWAP_UNDERLAY2      = 0x00020000;
+public static final int WGL_SWAP_UNDERLAY3      = 0x00040000;
+public static final int WGL_SWAP_UNDERLAY4      = 0x00080000;
+public static final int WGL_SWAP_UNDERLAY5      = 0x00100000;
+public static final int WGL_SWAP_UNDERLAY6      = 0x00200000;
+public static final int WGL_SWAP_UNDERLAY7      = 0x00400000;
+public static final int WGL_SWAP_UNDERLAY8      = 0x00800000;
+public static final int WGL_SWAP_UNDERLAY9      = 0x01000000;
+public static final int WGL_SWAP_UNDERLAY10     = 0x02000000;
+public static final int WGL_SWAP_UNDERLAY11     = 0x04000000;
+public static final int WGL_SWAP_UNDERLAY12     = 0x08000000;
+public static final int WGL_SWAP_UNDERLAY13     = 0x10000000;
+public static final int WGL_SWAP_UNDERLAY14     = 0x20000000;
+public static final int WGL_SWAP_UNDERLAY15     = 0x40000000;
+
+/* pixel types */
+public static final int PFD_TYPE_RGBA        = 0;
+public static final int PFD_TYPE_COLORINDEX  = 1;
+
+/* layer types */
+public static final int PFD_MAIN_PLANE       = 0;
+public static final int PFD_OVERLAY_PLANE    = 1;
+public static final int PFD_UNDERLAY_PLANE   = (-1);
+
+/* PIXELFORMATDESCRIPTOR flags */
+public static final int PFD_DOUBLEBUFFER            = 0x00000001;
+public static final int PFD_STEREO                  = 0x00000002;
+public static final int PFD_DRAW_TO_WINDOW          = 0x00000004;
+public static final int PFD_DRAW_TO_BITMAP          = 0x00000008;
+public static final int PFD_SUPPORT_GDI             = 0x00000010;
+public static final int PFD_SUPPORT_OPENGL          = 0x00000020;
+public static final int PFD_GENERIC_FORMAT          = 0x00000040;
+public static final int PFD_NEED_PALETTE            = 0x00000080;
+public static final int PFD_NEED_SYSTEM_PALETTE     = 0x00000100;
+public static final int PFD_SWAP_EXCHANGE           = 0x00000200;
+public static final int PFD_SWAP_COPY               = 0x00000400;
+public static final int PFD_SWAP_LAYER_BUFFERS      = 0x00000800;
+public static final int PFD_GENERIC_ACCELERATED     = 0x00001000;
+public static final int PFD_SUPPORT_DIRECTDRAW      = 0x00002000;
+
+/* PIXELFORMATDESCRIPTOR flags for use in ChoosePixelFormat only */
+public static final int PFD_DEPTH_DONTCARE          = 0x20000000;
+public static final int PFD_DOUBLEBUFFER_DONTCARE   = 0x40000000;
+public static final int PFD_STEREO_DONTCARE         = 0x80000000;
+
+public static final native int ChoosePixelFormat(int hdc, PIXELFORMATDESCRIPTOR ppfd);
+public static final native int DescribePixelFormat(int hdc, int iPixelFormat, int nBytes, PIXELFORMATDESCRIPTOR ppfd);
+public static final native int GetPixelFormat(int hdc);
+public static final native boolean SetPixelFormat(int hdc, int iPixelFormat, PIXELFORMATDESCRIPTOR ppfd);
+public static final native boolean SwapBuffers(int hdc);
+public static final native boolean wglCopyContext(int hglrcSrc, int hglrcDst, int mask);
+public static final native int wglCreateContext(int hdc);
+public static final native int wglCreateLayerContext(int hdc, int iLayerPlane);
+public static final native boolean wglDeleteContext(int hglrc);
+public static final native int wglGetCurrentContext();
+public static final native int wglGetCurrentDC();
+public static final native int wglGetProcAddress(byte[] lpszProc);
+public static final native boolean wglMakeCurrent(int hdc, int hglrc);
+public static final native boolean wglShareLists(int hglrc1, int hglrc2);
+public static final native boolean wglUseFontBitmapsA(int hdc, int first, int count, int listBase);
+public static final native boolean wglUseFontBitmapsW(int hdc, int first, int count, int listBase);
+public static final boolean wglUseFontBitmaps(int hdc, int first, int count, int listBase) {
+	if (OS.IsUnicode) return wglUseFontBitmapsW(hdc, first, count, listBase);
+	return wglUseFontBitmapsA(hdc, first, count, listBase);
+}
+public static final native boolean wglUseFontOutlinesA(int hdc, int first, int count, int listBase, float deviation, float extrusion, int format, int lpgmf);
+public static final native boolean wglUseFontOutlinesW(int hdc, int first, int count, int listBase, float deviation, float extrusion, int format, int lpgmf);
+public static final boolean wglUseFontOutlines(int hdc, int first, int count, int listBase, float deviation, float extrusion, int format, int lpgmf) {
+	if (OS.IsUnicode) return wglUseFontOutlinesW(hdc, first, count, listBase, deviation, extrusion, format, lpgmf);
+	return wglUseFontOutlinesA(hdc, first, count, listBase, deviation, extrusion, format, lpgmf);
+}
+public static final native boolean wglDescribeLayerPlane(int hdc, int iPixelFormat, int iLayerPlane, int nBytes, LAYERPLANEDESCRIPTOR plpd);
+public static final native int wglSetLayerPaletteEntries(int hdc, int iLayerPlane, int iStart, int cEntries, int[] pcr);
+public static final native int wglGetLayerPaletteEntries(int hdc, int iLayerPlane, int iStart, int cEntries, int[] pcr);
+public static final native boolean wglRealizeLayerPalette(int hdc, int iLayerPlane, boolean bRealize);
+public static final native boolean wglSwapLayerBuffers(int hdc, int fuPlanes);
+public static final void MoveMemory (GLYPHMETRICSFLOAT Destination, int Source, int Length) {
+	if (OS.IsUnicode) MoveMemoryW (Destination, Source, Length);
+	else MoveMemoryA(Destination, Source, Length);
+}
+public static final native void MoveMemoryA (GLYPHMETRICSFLOAT Destination, int Source, int Length);
+public static final native void MoveMemoryW (GLYPHMETRICSFLOAT Destination, int Source, int Length);
+}
author	Grant Gayed <ggayed>	2003-07-10 20:41:12 +0000
committer	Grant Gayed <ggayed>	2003-07-10 20:41:12 +0000
commit	2bffa3862a37be63a266d84772815ad0cccee5d1 (patch)
tree	9a9d9850e027e6ba1bddb5cde89079cef035ed0a /bundles/org.eclipse.swt.opengl
parent	949a243710db76895ae62e7e3836ee5ccd5921de (diff)
download	eclipse.platform.swt-2bffa3862a37be63a266d84772815ad0cccee5d1.tar.gz eclipse.platform.swt-2bffa3862a37be63a266d84772815ad0cccee5d1.tar.xz eclipse.platform.swt-2bffa3862a37be63a266d84772815ad0cccee5d1.zip