Partial fix for Issue 42: Problems invoking GLU functions

Incorporated the LWJGL team's port of the GLU quadric and projection
routines to be able to eliminate calls to the native GLU library for
these cases, which was problematic on certain Linux distributions.
Still need to port at least some of the mipmap routines and the NURBS
tesselator.


git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@172 232f8b59-042b-4e1e-8c03-345bb8c30851

6 files changed, 187 insertions, 17 deletions

diff --git a/doc/userguide/index.html b/doc/userguide/index.html
index b3253d5f8..63e622f1a 100644
--- a/doc/userguide/index.html
+++ b/doc/userguide/index.html
@@ -415,6 +415,8 @@ on lower-end graphics cards.
 <LI> Hardware acceleration for GLJPanel could be implemented using
 pbuffers.
 
+<LI> Stability issues, in particular on older graphics cards.
+
 </UL>
 
 <H3> Windows </H3>
@@ -427,13 +429,11 @@ No outstanding issues at this time.
 
 <H3> Solaris, Linux (X11 platforms) </H3>
 
-<UL>
+<P>
 
-<LI> Multi-head support is not yet working properly in Jogl.
-Contributions have been made by the community in this area and we
-expect to fold these changes in to the main source tree shortly.
+No outstanding issues at this time.
 
-</UL>
+</P>
 
 <H3> Mac OS X </H3>
 
diff --git a/make/glu-common.cfg b/make/glu-common.cfg
index b7057a978..65919e410 100644
--- a/make/glu-common.cfg
+++ b/make/glu-common.cfg
@@ -151,5 +151,28 @@ Ignore GLUtesselator
 #
 Ignore gluQuadricCallback.*
 
-
-
+# Manually implement the GLU quadric functionality to mostly conform
+# to the C APIs
+Ignore GLUquadric
+ManuallyImplement gluCylinder
+ManuallyImplement gluDeleteQuadric
+ManuallyImplement gluDisk
+ManuallyImplement gluNewQuadric
+ManuallyImplement gluPartialDisk
+ManuallyImplement gluQuadricDrawStyle
+ManuallyImplement gluQuadricNormals
+ManuallyImplement gluQuadricOrientation
+ManuallyImplement gluQuadricTexture
+ManuallyImplement gluSphere
+
+# Ignore a few of the projection/unprojection APIs altogether because
+# their signatures aren't specified correctly in the header file
+Ignore gluProject
+Ignore gluUnProject
+Ignore gluUnProject4
+
+# Manually implement the rest of the projection / unprojection APIs
+ManuallyImplement gluOrtho2D
+ManuallyImplement gluPerspective
+ManuallyImplement gluLookAt
+ManuallyImplement gluPickMatrix
diff --git a/make/glu-impl-common-CustomJavaCode.java b/make/glu-impl-common-CustomJavaCode.java
index 3332bd375..854030351 100644
--- a/make/glu-impl-common-CustomJavaCode.java
+++ b/make/glu-impl-common-CustomJavaCode.java
@@ -5,12 +5,23 @@ public boolean isFunctionAvailable(String gluFunctionName)
 }
 
 private GLUProcAddressTable gluProcAddressTable;
+private GL gl;
 
 public GLUImpl(GLUProcAddressTable gluProcAddressTable)
 {
   this.gluProcAddressTable = gluProcAddressTable;
+  this.project = new Project();
 }
 
+// Used for pure-Java port of GLU
+public void setGL(GL gl) {
+  this.gl = gl;
+}
+
+//----------------------------------------------------------------------
+// Tesselator functionality
+//
+
 public GLUtesselator gluNewTess() {
     return GLUtesselatorImpl.gluNewTess();
 }
@@ -79,3 +90,118 @@ public void gluEndPolygon(GLUtesselator tesselator) {
     GLUtesselatorImpl tess = (GLUtesselatorImpl) tesselator;
     tess.gluEndPolygon();
 }
+
+//----------------------------------------------------------------------
+// Quadric functionality
+//
+
+/** Interface to C language function: <br> <code> void gluCylinder(GLUquadric *  quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks); </code>    */
+public void gluCylinder(GLUquadric quad, double base, double top, double height, int slices, int stacks) {
+  ((GLUquadricImpl) quad).drawCylinder(gl, (float) base, (float) top, (float) height, slices, stacks);
+}
+
+/** Interface to C language function: <br> <code> void gluDeleteQuadric(GLUquadric *  quad); </code>    */
+public void gluDeleteQuadric(GLUquadric quad) {
+}
+
+/** Interface to C language function: <br> <code> void gluDisk(GLUquadric *  quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops); </code>    */
+public void gluDisk(GLUquadric quad, double inner, double outer, int slices, int loops) {
+  ((GLUquadricImpl) quad).drawDisk(gl, (float) inner, (float) outer, slices, loops);
+}
+
+/** Interface to C language function: <br> <code> GLUquadric *  gluNewQuadric(void); </code>    */
+public GLUquadric gluNewQuadric() {
+  return new GLUquadricImpl();
+}
+
+/** Interface to C language function: <br> <code> void gluPartialDisk(GLUquadric *  quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep); </code>    */
+public void gluPartialDisk(GLUquadric quad, double inner, double outer, int slices, int loops, double start, double sweep) {
+  ((GLUquadricImpl) quad).drawPartialDisk(gl, (float) inner, (float) outer, slices, loops, (float) start, (float) sweep);
+}
+
+/** Interface to C language function: <br> <code> void gluQuadricDrawStyle(GLUquadric *  quad, GLenum draw); </code>    */
+public void gluQuadricDrawStyle(GLUquadric quad, int draw) {
+  ((GLUquadricImpl) quad).setDrawStyle(draw);
+}
+
+/** Interface to C language function: <br> <code> void gluQuadricNormals(GLUquadric *  quad, GLenum normal); </code>    */
+public void gluQuadricNormals(GLUquadric quad, int normal) {
+  ((GLUquadricImpl) quad).setNormals(normal);
+}
+
+/** Interface to C language function: <br> <code> void gluQuadricOrientation(GLUquadric *  quad, GLenum orientation); </code>    */
+public void gluQuadricOrientation(GLUquadric quad, int orientation) {
+  ((GLUquadricImpl) quad).setOrientation(orientation);
+}
+
+/** Interface to C language function: <br> <code> void gluQuadricTexture(GLUquadric *  quad, GLboolean texture); </code>    */
+public void gluQuadricTexture(GLUquadric quad, boolean texture) {
+  ((GLUquadricImpl) quad).setTextureFlag(texture);
+}
+
+/** Interface to C language function: <br> <code> void gluSphere(GLUquadric *  quad, GLdouble radius, GLint slices, GLint stacks); </code>    */
+public void gluSphere(GLUquadric quad, double radius, int slices, int stacks) {
+  ((GLUquadricImpl) quad).drawSphere(gl, (float) radius, slices, stacks);
+}
+
+//----------------------------------------------------------------------
+// Projection functionality
+//
+
+private Project project;
+
+public void gluOrtho2D(double left, double right, double bottom, double top) {
+  project.gluOrtho2D(gl, left, right, bottom, top);
+}
+
+public void gluPerspective(double fovy, double aspect, double zNear, double zFar) {
+  project.gluPerspective(gl, fovy, aspect, zNear, zFar);
+}
+
+public void gluLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ) {
+  project.gluLookAt(gl, eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);
+}
+
+public boolean gluProject(double objX, double objY, double objZ, double[] model, double[] proj, int[] view, double[] winX, double[] winY, double[] winZ) {
+  double[] tmp = new double[3];
+  boolean res = project.gluProject(objX, objY, objZ, model, proj, view, tmp);
+  winX[0] = tmp[0];
+  winY[0] = tmp[1];
+  winZ[0] = tmp[2];
+  return res;
+}
+
+public boolean gluProject(double objX, double objY, double objZ, double[] model, double[] proj, int[] view, double[] winPos) {
+  return project.gluProject(objX, objY, objZ, model, proj, view, winPos);
+}
+
+public boolean gluUnProject(double winX, double winY, double winZ, double[] model, double[] proj, int[] view, double[] objX, double[] objY, double[] objZ) {
+  double[] tmp = new double[3];
+  boolean res = project.gluUnProject(winX, winY, winZ, model, proj, view, tmp);
+  objX[0] = tmp[0];
+  objY[0] = tmp[1];
+  objZ[0] = tmp[2];
+  return res;
+}
+
+public boolean gluUnProject(double winX, double winY, double winZ, double[] model, double[] proj, int[] view, double[] objPos) {
+  return project.gluUnProject(winX, winY, winZ, model, proj, view, objPos);
+}
+
+public boolean gluUnProject4(double winX, double winY, double winZ, double clipW, double[] model, double[] proj, int[] view, double nearVal, double farVal, double[] objX, double[] objY, double[] objZ, double[] objW) {
+  double[] tmp = new double[4];
+  boolean res = project.gluUnProject4(winX, winY, winZ, clipW, model, proj, view, nearVal, farVal, tmp);
+  objX[0] = tmp[0];
+  objY[0] = tmp[1];
+  objZ[0] = tmp[2];
+  objW[0] = tmp[3];
+  return res;
+}
+
+public boolean gluUnProject4(double winX, double winY, double winZ, double clipW, double[] model, double[] proj, int[] view, double nearVal, double farVal, double[] objPos) {
+  return project.gluUnProject4(winX, winY, winZ, clipW, model, proj, view, nearVal, farVal, objPos);
+}
+
+public void gluPickMatrix(double x, double y, double delX, double delY, int[] viewport) {
+  project.gluPickMatrix(gl, x, y, delX, delY, viewport);
+}
diff --git a/make/glu-impl-win32-GLU13Hacks.cfg b/make/glu-impl-win32-GLU13Hacks.cfg
index 325d2718c..186ee5ca1 100644
--- a/make/glu-impl-win32-GLU13Hacks.cfg
+++ b/make/glu-impl-win32-GLU13Hacks.cfg
@@ -9,7 +9,6 @@
 Ignore gluBuild(1|2|3)DMipmapLevels
 Ignore gluBuild3DMipmaps
 Ignore gluCheckExtension
-Ignore gluUnProject4
 
 CustomJavaCode GLUImpl  /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, void *CustomJavaCode GLUImpl  data); </code>CustomJavaCode GLUImpl  CustomJavaCode GLUImpl  */
 CustomJavaCode GLUImpl  public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, boolean[] data) { throw new GLException("This GLU 1.3 function is not available on Win32 platforms because Microsoft Windows ships with a GLU 1.2 implementation"); }
@@ -121,6 +120,3 @@ CustomJavaCode GLUImpl  public int gluBuild3DMipmaps(int target, int internalFor
 
 CustomJavaCode GLUImpl  /** Entry point to C language function: <br> <code> GLboolean gluCheckExtension(const GLubyte *CustomJavaCode GLUImpl  extName, const GLubyte *CustomJavaCode GLUImpl  extString); </code>CustomJavaCode GLUImpl  CustomJavaCode GLUImpl  */
 CustomJavaCode GLUImpl  public boolean gluCheckExtension(java.lang.String extName, java.lang.String extString) { throw new GLException("This GLU 1.3 function is not available on Win32 platforms because Microsoft Windows ships with a GLU 1.2 implementation"); }
-
-CustomJavaCode GLUImpl  /** Entry point to C language function: <br> <code> GLint gluUnProject4(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble *CustomJavaCode GLUImpl  model, const GLdouble *CustomJavaCode GLUImpl  proj, const GLint *CustomJavaCode GLUImpl  view, GLdouble nearVal, GLdouble farVal, GLdouble *CustomJavaCode GLUImpl  objX, GLdouble *CustomJavaCode GLUImpl  objY, GLdouble *CustomJavaCode GLUImpl  objZ, GLdouble *CustomJavaCode GLUImpl  objW); </code>CustomJavaCode GLUImpl  CustomJavaCode GLUImpl  */
-CustomJavaCode GLUImpl  public int gluUnProject4(double winX, double winY, double winZ, double clipW, double[] model, double[] proj, int[] view, double nearVal, double farVal, double[] objX, double[] objY, double[] objZ, double[] objW) { throw new GLException("This GLU 1.3 function is not available on Win32 platforms because Microsoft Windows ships with a GLU 1.2 implementation"); }
diff --git a/src/net/java/games/jogl/impl/GLContext.java b/src/net/java/games/jogl/impl/GLContext.java
index 443d009dc..2aa8e9640 100644
--- a/src/net/java/games/jogl/impl/GLContext.java
+++ b/src/net/java/games/jogl/impl/GLContext.java
@@ -67,13 +67,9 @@ public abstract class GLContext {
   protected GLCapabilities capabilities;
   protected GLCapabilitiesChooser chooser;
   protected GL gl;
-  // All GLU interfaces eventually route calls down to gluRoot. It can be
-  // static because GLU it doesn't actually need to own context, it just makes
-  // GL calls and assumes some context is active.
   protected static final GLUProcAddressTable gluProcAddressTable = new GLUProcAddressTable();
-  protected static final GLU gluRoot = new GLUImpl(gluProcAddressTable);
   protected static boolean haveResetGLUProcAddressTable;
-  protected GLU glu = gluRoot; // this is the context's GLU interface
+  protected GLU glu = new GLUImpl(gluProcAddressTable);
   protected Thread renderingThread;
   protected Runnable deferredReshapeAction;
   // Support for OpenGL context destruction and recreation in the face
@@ -155,7 +151,7 @@ public abstract class GLContext {
       throw new GLException(e);
     }
     this.chooser = chooser;
-    gl = createGL();
+    setGL(createGL());
     functionAvailability = new FunctionAvailabilityCache(this);
     if (shareWith != null) {
       GLContextShareSet.registerSharing(this, shareWith);
@@ -374,6 +370,8 @@ public abstract class GLContext {
 
   public void setGL(GL gl) {
     this.gl = gl;
+    // Also reset the GL object for the pure-Java GLU implementation
+    ((GLUImpl) glu).setGL(gl);
   }
 
   public GLU getGLU() {    
diff --git a/src/net/java/games/jogl/util/BufferUtils.java b/src/net/java/games/jogl/util/BufferUtils.java
index 88afa1c8f..1572b749b 100644
--- a/src/net/java/games/jogl/util/BufferUtils.java
+++ b/src/net/java/games/jogl/util/BufferUtils.java
@@ -45,9 +45,15 @@ import java.util.*;
 /** Utility routines for dealing with direct buffers. */
 
 public class BufferUtils {
+  public static final int SIZEOF_DOUBLE = 8;
   public static final int SIZEOF_FLOAT = 4;
   public static final int SIZEOF_INT = 4;
 
+  public static DoubleBuffer newDoubleBuffer(int numElements) {
+    ByteBuffer bb = newByteBuffer(numElements * SIZEOF_DOUBLE);
+    return bb.asDoubleBuffer();
+  }
+
   public static FloatBuffer newFloatBuffer(int numElements) {
     ByteBuffer bb = newByteBuffer(numElements * SIZEOF_FLOAT);
     return bb.asFloatBuffer();
@@ -64,6 +70,13 @@ public class BufferUtils {
     return bb;
   }
 
+  public static DoubleBuffer copyDoubleBuffer(DoubleBuffer orig) {
+    DoubleBuffer dest = newDoubleBuffer(orig.capacity());
+    orig.rewind();
+    dest.put(orig);
+    return dest;
+  }
+
   public static FloatBuffer copyFloatBuffer(FloatBuffer orig) {
     FloatBuffer dest = newFloatBuffer(orig.capacity());
     orig.rewind();
@@ -71,6 +84,20 @@ public class BufferUtils {
     return dest;
   }
 
+  public static IntBuffer copyIntBuffer(IntBuffer orig) {
+    IntBuffer dest = newIntBuffer(orig.capacity());
+    orig.rewind();
+    dest.put(orig);
+    return dest;
+  }
+
+  public static ByteBuffer copyByteBuffer(ByteBuffer orig) {
+    ByteBuffer dest = newByteBuffer(orig.capacity());
+    orig.rewind();
+    dest.put(orig);
+    return dest;
+  }
+
   private static Map bufferOffsetCache = Collections.synchronizedMap(new HashMap());
 
   /** Creates an "offset buffer" for use with the