- Using new config feature: 'IgnoreExtendedInterfaceSymbols <java class source file>'

  and get rid of manual 'Ignore' configs for common stuff in the base interfaces.

- Add: GLUnsupportedException:
    - Using new config feature 'UnsupportedExceptionType GLUnsupportedException'
    - GLUnsupportedException is used for anything 'UnsupportedOperationException'

- GLU:
    - GLU itself is no more abstract
    - GLU contains the tesselator implementation
        - name, return type, modifiers and arguments
    - createGLU(..)
        - operated by profile name now.
        - GLU itself will be used for GLES2

- Cleanup:
    - gluegen/GL configs ..


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

1 files changed, 0 insertions, 793 deletions

diff --git a/make/glu-CustomJavaCode-gl2.java b/make/glu-CustomJavaCode-gl2.java
index d6f18a7db..5aef1a7ac 100644
--- a/make/glu-CustomJavaCode-gl2.java
+++ b/make/glu-CustomJavaCode-gl2.java
@@ -139,799 +139,6 @@ public final boolean isFunctionAvailable(String gluFunctionName)
 }
 
 //----------------------------------------------------------------------
-// Tessellation routines
-//
-
-/*****************************************************************************
- * <b>gluNewTess</b> creates and returns a new tessellation object.  This
- * object must be referred to when calling tesselation methods.  A return
- * value of null means that there was not enough memeory to allocate the
- * object.
- *
- * @return A new tessellation object.
- *
- * @see #gluTessBeginPolygon gluTessBeginPolygon
- * @see #gluDeleteTess       gluDeleteTess
- * @see #gluTessCallback     gluTessCallback
- ****************************************************************************/
-public final GLUtessellator gluNewTess() {
-    return GLUtessellatorImpl.gluNewTess();
-}
-
-/*****************************************************************************
- * <b>gluDeleteTess</b> destroys the indicated tessellation object (which was
- * created with {@link #gluNewTess gluNewTess}).
- *
- * @param tessellator
- *        Specifies the tessellation object to destroy.
- *
- * @see #gluBeginPolygon gluBeginPolygon
- * @see #gluNewTess      gluNewTess
- * @see #gluTessCallback gluTessCallback
- ****************************************************************************/
-public final void gluDeleteTess(GLUtessellator tessellator) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluDeleteTess();
-}
-
-/*****************************************************************************
- * <b>gluTessProperty</b> is used to control properites stored in a
- * tessellation object.  These properties affect the way that the polygons are
- * interpreted and rendered.  The legal value for <i>which</i> are as
- * follows:<P>
- *
- * <b>GLU_TESS_WINDING_RULE</b>
- * <UL>
- *   Determines which parts of the polygon are on the "interior".
- *   <em>value</em> may be set to one of
- *   <BR><b>GLU_TESS_WINDING_ODD</b>,
- *   <BR><b>GLU_TESS_WINDING_NONZERO</b>,
- *   <BR><b>GLU_TESS_WINDING_POSITIVE</b>, or
- *   <BR><b>GLU_TESS_WINDING_NEGATIVE</b>, or
- *   <BR><b>GLU_TESS_WINDING_ABS_GEQ_TWO</b>.<P>
- *
- *   To understand how the winding rule works, consider that the input
- *   contours partition the plane into regions.  The winding rule determines
- *   which of these regions are inside the polygon.<P>
- *
- *   For a single contour C, the winding number of a point x is simply the
- *   signed number of revolutions we make around x as we travel once around C
- *   (where CCW is positive).  When there are several contours, the individual
- *   winding numbers are summed.  This procedure associates a signed integer
- *   value with each point x in the plane.  Note that the winding number is
- *   the same for all points in a single region.<P>
- *
- *   The winding rule classifies a region as "inside" if its winding number
- *   belongs to the chosen category (odd, nonzero, positive, negative, or
- *   absolute value of at least two).  The previous GLU tessellator (prior to
- *   GLU 1.2) used the "odd" rule.  The "nonzero" rule is another common way
- *   to define the interior.  The other three rules are useful for polygon CSG
- *   operations.
- * </UL>
- * <BR><b>GLU_TESS_BOUNDARY_ONLY</b>
- * <UL>
- *   Is a boolean value ("value" should be set to GL_TRUE or GL_FALSE). When
- *   set to GL_TRUE, a set of closed contours separating the polygon interior
- *   and exterior are returned instead of a tessellation.  Exterior contours
- *   are oriented CCW with respect to the normal; interior contours are
- *   oriented CW. The <b>GLU_TESS_BEGIN</b> and <b>GLU_TESS_BEGIN_DATA</b>
- *   callbacks use the type GL_LINE_LOOP for each contour.
- * </UL>
- * <BR><b>GLU_TESS_TOLERANCE</b>
- * <UL>
- *   Specifies a tolerance for merging features to reduce the size of the
- *   output. For example, two vertices that are very close to each other
- *   might be replaced by a single vertex.  The tolerance is multiplied by the
- *   largest coordinate magnitude of any input vertex; this specifies the
- *   maximum distance that any feature can move as the result of a single
- *   merge operation.  If a single feature takes part in several merge
- *   operations, the toal distance moved could be larger.<P>
- *
- *   Feature merging is completely optional; the tolerance is only a hint.
- *   The implementation is free to merge in some cases and not in others, or
- *   to never merge features at all.  The initial tolerance is 0.<P>
- *
- *   The current implementation merges vertices only if they are exactly
- *   coincident, regardless of the current tolerance.  A vertex is spliced
- *   into an edge only if the implementation is unable to distinguish which
- *   side of the edge the vertex lies on.  Two edges are merged only when both
- *   endpoints are identical.
- * </UL>
- *
- * @param tessellator
- *        Specifies the tessellation object created with
- *        {@link #gluNewTess gluNewTess}
- * @param which
- *        Specifies the property to be set.  Valid values are
- *        <b>GLU_TESS_WINDING_RULE</b>, <b>GLU_TESS_BOUNDARDY_ONLY</b>,
- *        <b>GLU_TESS_TOLERANCE</b>.
- * @param value
- *        Specifices the value of the indicated property.
- *
- * @see #gluGetTessProperty gluGetTessProperty
- * @see #gluNewTess         gluNewTess
- ****************************************************************************/
-public final void gluTessProperty(GLUtessellator tessellator, int which, double value) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluTessProperty(which, value);
-}
-
-/*****************************************************************************
- * <b>gluGetTessProperty</b> retrieves properties stored in a tessellation
- * object.  These properties affect the way that tessellation objects are
- * interpreted and rendered.  See the
- * {@link #gluTessProperty gluTessProperty} reference
- * page for information about the properties and what they do.
- *
- * @param tessellator
- *        Specifies the tessellation object (created with
- *        {@link #gluNewTess gluNewTess}).
- * @param which
- *        Specifies the property whose value is to be fetched. Valid values
- *        are <b>GLU_TESS_WINDING_RULE</b>, <b>GLU_TESS_BOUNDARY_ONLY</b>,
- *        and <b>GLU_TESS_TOLERANCES</b>.
- * @param value
- *        Specifices an array into which the value of the named property is
- *        written.
- *
- * @see #gluNewTess      gluNewTess
- * @see #gluTessProperty gluTessProperty
- ****************************************************************************/
-public final void gluGetTessProperty(GLUtessellator tessellator, int which, double[] value, int value_offset) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluGetTessProperty(which, value, value_offset);
-}
-
-/*****************************************************************************
- * <b>gluTessNormal</b> describes a normal for a polygon that the program is
- * defining. All input data will be projected onto a plane perpendicular to
- * the one of the three coordinate axes before tessellation and all output
- * triangles will be oriented CCW with repsect to the normal (CW orientation
- * can be obtained by reversing the sign of the supplied normal).  For
- * example, if you know that all polygons lie in the x-y plane, call
- * <b>gluTessNormal</b>(tess, 0.0, 0.0, 0.0) before rendering any polygons.<P>
- *
- * If the supplied normal is (0.0, 0.0, 0.0)(the initial value), the normal
- * is determined as follows.  The direction of the normal, up to its sign, is
- * found by fitting a plane to the vertices, without regard to how the
- * vertices are connected.  It is expected that the input data lies
- * approximately in the plane; otherwise, projection perpendicular to one of
- * the three coordinate axes may substantially change the geometry.  The sign
- * of the normal is chosen so that the sum of the signed areas of all input
- * contours is nonnegative (where a CCW contour has positive area).<P>
- *
- * The supplied normal persists until it is changed by another call to
- * <b>gluTessNormal</b>.
- *
- * @param tessellator
- *        Specifies the tessellation object (created by
- *        {@link #gluNewTess gluNewTess}).
- * @param x
- *        Specifies the first component of the normal.
- * @param y
- *        Specifies the second component of the normal.
- * @param z
- *        Specifies the third component of the normal.
- *
- * @see #gluTessBeginPolygon gluTessBeginPolygon
- * @see #gluTessEndPolygon   gluTessEndPolygon
- ****************************************************************************/
-public final void gluTessNormal(GLUtessellator tessellator, double x, double y, double z) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluTessNormal(x, y, z);
-}
-
-/*****************************************************************************
- * <b>gluTessCallback</b> is used to indicate a callback to be used by a
- * tessellation object. If the specified callback is already defined, then it
- * is replaced. If <i>aCallback</i> is null, then the existing callback
- * becomes undefined.<P>
- *
- * These callbacks are used by the tessellation object to describe how a
- * polygon specified by the user is broken into triangles. Note that there are
- * two versions of each callback: one with user-specified polygon data and one
- * without. If both versions of a particular callback are specified, then the
- * callback with user-specified polygon data will be used. Note that the
- * polygonData parameter used by some of the methods is a copy of the
- * reference that was specified when
- * {@link #gluTessBeginPolygon gluTessBeginPolygon}
- * was called. The legal callbacks are as follows:<P>
- *
- * <b>GLU_TESS_BEGIN</b>
- * <UL>
- *   The begin callback is invoked like {@link javax.media.opengl.GL#glBegin
- *   glBegin} to indicate the start of a (triangle) primitive. The method
- *   takes a single argument of type int. If the
- *   <b>GLU_TESS_BOUNDARY_ONLY</b> property is set to <b>GL_FALSE</b>, then
- *   the argument is set to either <b>GL_TRIANGLE_FAN</b>,
- *   <b>GL_TRIANGLE_STRIP</b>, or <b>GL_TRIANGLES</b>. If the
- *   <b>GLU_TESS_BOUNDARY_ONLY</b> property is set to <b>GL_TRUE</b>, then the
- *   argument will be set to <b>GL_LINE_LOOP</b>. The method prototype for
- *   this callback is:
- * </UL>
- *
- * <PRE>
- *         void begin(int type);</PRE><P>
- *
- * <b>GLU_TESS_BEGIN_DATA</b>
- * <UL>
- *   The same as the <b>GLU_TESS_BEGIN</b> callback except
- *   that it takes an additional reference argument. This reference is
- *   identical to the opaque reference provided when
- *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
- *   was called. The method prototype for this callback is:
- * </UL>
- *
- * <PRE>
- *         void beginData(int type, Object polygonData);</PRE>
- *
- * <b>GLU_TESS_EDGE_FLAG</b>
- * <UL>
- *   The edge flag callback is similar to
- *   {@link javax.media.opengl.GL#glEdgeFlag glEdgeFlag}. The method takes
- *   a single boolean boundaryEdge that indicates which edges lie on the
- *   polygon boundary. If the boundaryEdge is <b>GL_TRUE</b>, then each vertex
- *   that follows begins an edge that lies on the polygon boundary, that is,
- *   an edge that separates an interior region from an exterior one. If the
- *   boundaryEdge is <b>GL_FALSE</b>, then each vertex that follows begins an
- *   edge that lies in the polygon interior. The edge flag callback (if
- *   defined) is invoked before the first vertex callback.<P>
- *
- *   Since triangle fans and triangle strips do not support edge flags, the
- *   begin callback is not called with <b>GL_TRIANGLE_FAN</b> or
- *   <b>GL_TRIANGLE_STRIP</b> if a non-null edge flag callback is provided.
- *   (If the callback is initialized to null, there is no impact on
- *   performance). Instead, the fans and strips are converted to independent
- *   triangles. The method prototype for this callback is:
- * </UL>
- *
- * <PRE>
- *         void edgeFlag(boolean boundaryEdge);</PRE>
- *
- * <b>GLU_TESS_EDGE_FLAG_DATA</b>
- * <UL>
- *   The same as the <b>GLU_TESS_EDGE_FLAG</b> callback except that it takes
- *   an additional reference argument. This reference is identical to the
- *   opaque reference provided when
- *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
- *   was called. The method prototype for this callback is:
- * </UL>
- *
- * <PRE>
- *         void edgeFlagData(boolean boundaryEdge, Object polygonData);</PRE>
- *
- * <b>GLU_TESS_VERTEX</b>
- * <UL>
- *   The vertex callback is invoked between the begin and end callbacks. It is
- *   similar to {@link javax.media.opengl.GL#glVertex3f glVertex3f}, and it
- *   defines the vertices of the triangles created by the tessellation
- *   process. The method takes a reference as its only argument. This
- *   reference is identical to the opaque reference provided by the user when
- *   the vertex was described (see
- *   {@link #gluTessVertex gluTessVertex}). The method
- *   prototype for this callback is:
- * </UL>
- *
- * <PRE>
- *         void vertex(Object vertexData);</PRE>
- *
- * <b>GLU_TESS_VERTEX_DATA</b>
- * <UL>
- *   The same as the <b>GLU_TESS_VERTEX</b> callback except that it takes an
- *   additional reference argument. This reference is identical to the opaque
- *   reference provided when
- *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
- *   was called. The method prototype for this callback is:
- * </UL>
- *
- * <PRE>
- *         void vertexData(Object vertexData, Object polygonData);</PRE>
- *
- * <b>GLU_TESS_END</b>
- * <UL>
- *   The end callback serves the same purpose as
- *   {@link javax.media.opengl.GL#glEnd glEnd}. It indicates the end of a
- *   primitive and it takes no arguments. The method prototype for this
- *   callback is:
- * </UL>
- *
- * <PRE>
- *         void end();</PRE>
- *
- * <b>GLU_TESS_END_DATA</b>
- * <UL>
- *   The same as the <b>GLU_TESS_END</b> callback except that it takes an
- *   additional reference argument. This reference is identical to the opaque
- *   reference provided when
- *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
- *   was called. The method prototype for this callback is:
- * </UL>
- *
- * <PRE>
- *         void endData(Object polygonData);</PRE>
- *
- * <b>GLU_TESS_COMBINE</b>
- * <UL>
- *   The combine callback is called to create a new vertex when the
- *   tessellation detects an intersection, or wishes to merge features. The
- *   method takes four arguments: an array of three elements each of type
- *   double, an array of four references, an array of four elements each of
- *   type float, and a reference to a reference. The prototype is:
- * </UL>
- *
- * <PRE>
- *         void combine(double[] coords, Object[] data,
- *                      float[] weight, Object[] outData);</PRE>
- *
- * <UL>
- *   The vertex is defined as a linear combination of up to four existing
- *   vertices, stored in <i>data</i>. The coefficients of the linear
- *   combination are given by <i>weight</i>; these weights always add up to 1.
- *   All vertex pointers are valid even when some of the weights are 0.
- *   <i>coords</i> gives the location of the new vertex.<P>
- *
- *   The user must allocate another vertex, interpolate parameters using
- *   <i>data</i> and <i>weight</i>, and return the new vertex pointer
- *   in <i>outData</i>. This handle is supplied during rendering callbacks.
- *   The user is responsible for freeing the memory some time after
- *   {@link #gluTessEndPolygon gluTessEndPolygon} is
- *   called.<P>
- *
- *   For example, if the polygon lies in an arbitrary plane in 3-space, and a
- *   color is associated with each vertex, the <b>GLU_TESS_COMBINE</b>
- *   callback might look like this:
- * </UL>
- * <PRE>
- *         void myCombine(double[] coords, Object[] data,
- *                        float[] weight, Object[] outData)
- *         {
- *            MyVertex newVertex = new MyVertex();
- *
- *            newVertex.x = coords[0];
- *            newVertex.y = coords[1];
- *            newVertex.z = coords[2];
- *            newVertex.r = weight[0]*data[0].r +
- *                          weight[1]*data[1].r +
- *                          weight[2]*data[2].r +
- *                          weight[3]*data[3].r;
- *            newVertex.g = weight[0]*data[0].g +
- *                          weight[1]*data[1].g +
- *                          weight[2]*data[2].g +
- *                          weight[3]*data[3].g;
- *            newVertex.b = weight[0]*data[0].b +
- *                          weight[1]*data[1].b +
- *                          weight[2]*data[2].b +
- *                          weight[3]*data[3].b;
- *            newVertex.a = weight[0]*data[0].a +
- *                          weight[1]*data[1].a +
- *                          weight[2]*data[2].a +
- *                          weight[3]*data[3].a;
- *            outData = newVertex;
- *         }</PRE>
- *
- * <UL>
- *   If the tessellation detects an intersection, then the
- *   <b>GLU_TESS_COMBINE</b> or <b>GLU_TESS_COMBINE_DATA</b> callback (see
- *   below) must be defined, and it must write a non-null reference into
- *   <i>outData</i>. Otherwise the <b>GLU_TESS_NEED_COMBINE_CALLBACK</b> error
- *   occurs, and no output is generated.
- * </UL>
- *
- * <b>GLU_TESS_COMBINE_DATA</b>
- * <UL>
- *   The same as the <b>GLU_TESS_COMBINE</b> callback except that it takes an
- *   additional reference argument. This reference is identical to the opaque
- *   reference provided when
- *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
- *   was called. The method prototype for this callback is:
- * </UL>
- *
- * <PRE>
- *         void combineData(double[] coords, Object[] data,
-                            float[] weight, Object[] outData,
-                            Object polygonData);</PRE>
- *
- * <b>GLU_TESS_ERROR</b>
- * <UL>
- *   The error callback is called when an error is encountered. The one
- *   argument is of type int; it indicates the specific error that occurred
- *   and will be set to one of <b>GLU_TESS_MISSING_BEGIN_POLYGON</b>,
- *   <b>GLU_TESS_MISSING_END_POLYGON</b>,
- *   <b>GLU_TESS_MISSING_BEGIN_CONTOUR</b>,
- *   <b>GLU_TESS_MISSING_END_CONTOUR</b>, <b>GLU_TESS_COORD_TOO_LARGE</b>,
- *   <b>GLU_TESS_NEED_COMBINE_CALLBACK</b> or <b>GLU_OUT_OF_MEMORY</b>.
- *   Character strings describing these errors can be retrieved with the
- *   {@link #gluErrorString gluErrorString} call. The
- *   method prototype for this callback is:
- * </UL>
- *
- * <PRE>
- *         void error(int errnum);</PRE>
- *
- * <UL>
- *   The GLU library will recover from the first four errors by inserting the
- *   missing call(s). <b>GLU_TESS_COORD_TOO_LARGE</b> indicates that some
- *   vertex coordinate exceeded the predefined constant
- *   <b>GLU_TESS_MAX_COORD</b> in absolute value, and that the value has been
- *   clamped. (Coordinate values must be small enough so that two can be
- *   multiplied together without overflow.)
- *   <b>GLU_TESS_NEED_COMBINE_CALLBACK</b> indicates that the tessellation
- *   detected an intersection between two edges in the input data, and the
- *   <b>GLU_TESS_COMBINE</b> or <b>GLU_TESS_COMBINE_DATA</b> callback was not
- *   provided. No output is generated. <b>GLU_OUT_OF_MEMORY</b> indicates that
- *   there is not enough memory so no output is generated.
- * </UL>
- *
- * <b>GLU_TESS_ERROR_DATA</b>
- * <UL>
- *   The same as the GLU_TESS_ERROR callback except that it takes an
- *   additional reference argument. This reference is identical to the opaque
- *   reference provided when
- *   {@link #gluTessBeginPolygon gluTessBeginPolygon}
- *   was called. The method prototype for this callback is:
- * </UL>
- *
- * <PRE>
- *         void errorData(int errnum, Object polygonData);</PRE>
- *
- * @param tessellator
- *        Specifies the tessellation object (created with
- *        {@link #gluNewTess gluNewTess}).
- * @param which
- *        Specifies the callback being defined. The following values are
- *        valid: <b>GLU_TESS_BEGIN</b>, <b>GLU_TESS_BEGIN_DATA</b>,
- *        <b>GLU_TESS_EDGE_FLAG</b>, <b>GLU_TESS_EDGE_FLAG_DATA</b>,
- *        <b>GLU_TESS_VERTEX</b>, <b>GLU_TESS_VERTEX_DATA</b>,
- *        <b>GLU_TESS_END</b>, <b>GLU_TESS_END_DATA</b>,
- *        <b>GLU_TESS_COMBINE</b>,  <b>GLU_TESS_COMBINE_DATA</b>,
- *        <b>GLU_TESS_ERROR</b>, and <b>GLU_TESS_ERROR_DATA</b>.
- * @param aCallback
- *        Specifies the callback object to be called.
- *
- * @see javax.media.opengl.GL#glBegin              glBegin
- * @see javax.media.opengl.GL#glEdgeFlag           glEdgeFlag
- * @see javax.media.opengl.GL#glVertex3f           glVertex3f
- * @see #gluNewTess          gluNewTess
- * @see #gluErrorString      gluErrorString
- * @see #gluTessVertex       gluTessVertex
- * @see #gluTessBeginPolygon gluTessBeginPolygon
- * @see #gluTessBeginContour gluTessBeginContour
- * @see #gluTessProperty     gluTessProperty
- * @see #gluTessNormal       gluTessNormal
- ****************************************************************************/
-public final void gluTessCallback(GLUtessellator tessellator, int which, GLUtessellatorCallback aCallback) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluTessCallback(which, aCallback);
-}
-
-/*****************************************************************************
- * <b>gluTessVertex</b> describes a vertex on a polygon that the program
- * defines. Successive <b>gluTessVertex</b> calls describe a closed contour.
- * For example, to describe a quadrilateral <b>gluTessVertex</b> should be
- * called four times. <b>gluTessVertex</b> can only be called between
- * {@link #gluTessBeginContour gluTessBeginContour} and
- * {@link #gluTessBeginContour gluTessEndContour}.<P>
- *
- * <b>data</b> normally references to a structure containing the vertex
- * location, as well as other per-vertex attributes such as color and normal.
- * This reference is passed back to the user through the
- * <b>GLU_TESS_VERTEX</b> or <b>GLU_TESS_VERTEX_DATA</b> callback after
- * tessellation (see the {@link #gluTessCallback
- * gluTessCallback} reference page).
- *
- * @param tessellator
- *        Specifies the tessellation object (created with
- *        {@link #gluNewTess gluNewTess}).
- * @param coords
- *        Specifies the coordinates of the vertex.
- * @param data
- *        Specifies an opaque reference passed back to the program with the
- *        vertex callback (as specified by
- *        {@link #gluTessCallback gluTessCallback}).
- *
- * @see #gluTessBeginPolygon gluTessBeginPolygon
- * @see #gluNewTess          gluNewTess
- * @see #gluTessBeginContour gluTessBeginContour
- * @see #gluTessCallback     gluTessCallback
- * @see #gluTessProperty     gluTessProperty
- * @see #gluTessNormal       gluTessNormal
- * @see #gluTessEndPolygon   gluTessEndPolygon
- ****************************************************************************/
-public final void gluTessVertex(GLUtessellator tessellator, double[] coords, int coords_offset, Object data) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluTessVertex(coords, coords_offset, data);
-}
-
-/*****************************************************************************
- * <b>gluTessBeginPolygon</b> and
- * {@link #gluTessEndPolygon gluTessEndPolygon} delimit
- * the definition of a convex, concave or self-intersecting polygon. Within
- * each <b>gluTessBeginPolygon</b>/
- * {@link #gluTessEndPolygon gluTessEndPolygon} pair,
- * there must be one or more calls to
- * {@link #gluTessBeginContour gluTessBeginContour}/
- * {@link #gluTessEndContour gluTessEndContour}. Within
- * each contour, there are zero or more calls to
- * {@link #gluTessVertex gluTessVertex}. The vertices
- * specify a closed contour (the last vertex of each contour is automatically
- * linked to the first). See the {@link #gluTessVertex
- * gluTessVertex}, {@link #gluTessBeginContour
- * gluTessBeginContour}, and {@link #gluTessEndContour
- * gluTessEndContour} reference pages for more details.<P>
- *
- * <b>data</b> is a reference to a user-defined data structure. If the
- * appropriate callback(s) are specified (see
- * {@link #gluTessCallback gluTessCallback}), then this
- * reference is returned to the callback method(s). Thus, it is a convenient
- * way to store per-polygon information.<P>
- *
- * Once {@link #gluTessEndPolygon gluTessEndPolygon} is
- * called, the polygon is tessellated, and the resulting triangles are
- * described through callbacks. See
- * {@link #gluTessCallback gluTessCallback} for
- * descriptions of the callback methods.
- *
- * @param tessellator
- *        Specifies the tessellation object (created with
- *        {@link #gluNewTess gluNewTess}).
- * @param data
- *        Specifies a reference to user polygon data.
- *
- * @see #gluNewTess          gluNewTess
- * @see #gluTessBeginContour gluTessBeginContour
- * @see #gluTessVertex       gluTessVertex
- * @see #gluTessCallback     gluTessCallback
- * @see #gluTessProperty     gluTessProperty
- * @see #gluTessNormal       gluTessNormal
- * @see #gluTessEndPolygon   gluTessEndPolygon
- ****************************************************************************/
-public final void gluTessBeginPolygon(GLUtessellator tessellator, Object data) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluTessBeginPolygon(data);
-}
-
-/*****************************************************************************
- * <b>gluTessBeginContour</b> and
- * {@link #gluTessEndContour gluTessEndContour} delimit
- * the definition of a polygon contour. Within each
- * <b>gluTessBeginContour</b>/
- * {@link #gluTessEndContour gluTessEndContour} pair,
- * there can be zero or more calls to
- * {@link #gluTessVertex gluTessVertex}. The vertices
- * specify a closed contour (the last vertex of each contour is automatically
- * linked to the first). See the {@link #gluTessVertex
- * gluTessVertex} reference page for more details. <b>gluTessBeginContour</b>
- * can only be called between
- * {@link #gluTessBeginPolygon gluTessBeginPolygon} and
- * {@link #gluTessEndPolygon gluTessEndPolygon}.
- *
- * @param tessellator
- *        Specifies the tessellation object (created with
- *        {@link #gluNewTess gluNewTess}).
- *
- * @see #gluNewTess          gluNewTess
- * @see #gluTessBeginPolygon gluTessBeginPolygon
- * @see #gluTessVertex       gluTessVertex
- * @see #gluTessCallback     gluTessCallback
- * @see #gluTessProperty     gluTessProperty
- * @see #gluTessNormal       gluTessNormal
- * @see #gluTessEndPolygon   gluTessEndPolygon
- ****************************************************************************/
-public final void gluTessBeginContour(GLUtessellator tessellator) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluTessBeginContour();
-}
-
-/*****************************************************************************
- *  <b>gluTessEndContour</b> and
- * {@link #gluTessBeginContour gluTessBeginContour}
- * delimit the definition of a polygon contour. Within each
- * {@link #gluTessBeginContour gluTessBeginContour}/
- * <b>gluTessEndContour</b> pair, there can be zero or more calls to
- * {@link #gluTessVertex gluTessVertex}. The vertices
- * specify a closed contour (the last vertex of each contour is automatically
- * linked to the first). See the {@link #gluTessVertex
- * gluTessVertex} reference page for more details.
- * {@link #gluTessBeginContour gluTessBeginContour} can
- * only be called between {@link #gluTessBeginPolygon
- * gluTessBeginPolygon} and
- * {@link #gluTessEndPolygon gluTessEndPolygon}.
- *
- * @param tessellator
- *        Specifies the tessellation object (created with
- *        {@link #gluNewTess gluNewTess}).
- *
- * @see #gluNewTess          gluNewTess
- * @see #gluTessBeginPolygon gluTessBeginPolygon
- * @see #gluTessVertex       gluTessVertex
- * @see #gluTessCallback     gluTessCallback
- * @see #gluTessProperty     gluTessProperty
- * @see #gluTessNormal       gluTessNormal
- * @see #gluTessEndPolygon   gluTessEndPolygon
- ****************************************************************************/
-public final void gluTessEndContour(GLUtessellator tessellator) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluTessEndContour();
-}
-
-/*****************************************************************************
- * <b>gluTessEndPolygon</b> and
- * {@link #gluTessBeginPolygon gluTessBeginPolygon}
- * delimit the definition of a convex, concave or self-intersecting polygon.
- * Within each {@link #gluTessBeginPolygon
- * gluTessBeginPolygon}/<b>gluTessEndPolygon</b> pair, there must be one or
- * more calls to {@link #gluTessBeginContour
- * gluTessBeginContour}/{@link #gluTessEndContour
- * gluTessEndContour}. Within each contour, there are zero or more calls to
- * {@link #gluTessVertex gluTessVertex}. The vertices
- * specify a closed contour (the last vertex of each contour is automatically
- * linked to the first). See the {@link #gluTessVertex
- * gluTessVertex}, {@link #gluTessBeginContour
- * gluTessBeginContour} and {@link #gluTessEndContour
- * gluTessEndContour} reference pages for more details.<P>
- *
- * Once <b>gluTessEndPolygon</b> is called, the polygon is tessellated, and
- * the resulting triangles are described through callbacks. See
- * {@link #gluTessCallback gluTessCallback} for
- * descriptions of the callback functions.
- *
- * @param tessellator
- *        Specifies the tessellation object (created with
- *        {@link #gluNewTess gluNewTess}).
- *
- * @see #gluNewTess          gluNewTess
- * @see #gluTessBeginContour gluTessBeginContour
- * @see #gluTessVertex       gluTessVertex
- * @see #gluTessCallback     gluTessCallback
- * @see #gluTessProperty     gluTessProperty
- * @see #gluTessNormal       gluTessNormal
- * @see #gluTessBeginPolygon gluTessBeginPolygon
- ****************************************************************************/
-public final void gluTessEndPolygon(GLUtessellator tessellator) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluTessEndPolygon();
-}
-
-/*****************************************************************************
-
- * <b>gluBeginPolygon</b> and {@link #gluEndPolygon gluEndPolygon}
- * delimit the definition of a nonconvex polygon. To define such a
- * polygon, first call <b>gluBeginPolygon</b>. Then define the
- * contours of the polygon by calling {@link #gluTessVertex
- * gluTessVertex} for each vertex and {@link #gluNextContour
- * gluNextContour} to start each new contour. Finally, call {@link
- * #gluEndPolygon gluEndPolygon} to signal the end of the
- * definition. See the {@link #gluTessVertex gluTessVertex} and {@link
- * #gluNextContour gluNextContour} reference pages for more
- * details.<P>
-
- *
- * Once {@link #gluEndPolygon gluEndPolygon} is called,
- * the polygon is tessellated, and the resulting triangles are described
- * through callbacks. See {@link #gluTessCallback
- * gluTessCallback} for descriptions of the callback methods.
- *
- * @param tessellator
- *        Specifies the tessellation object (created with
- *        {@link #gluNewTess gluNewTess}).
- *
- * @see #gluNewTess          gluNewTess
- * @see #gluNextContour      gluNextContour
- * @see #gluTessCallback     gluTessCallback
- * @see #gluTessVertex       gluTessVertex
- * @see #gluTessBeginPolygon gluTessBeginPolygon
- * @see #gluTessBeginContour gluTessBeginContour
- ****************************************************************************/
-public final void gluBeginPolygon(GLUtessellator tessellator) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluBeginPolygon();
-}
-
-/*****************************************************************************
- * <b>gluNextContour</b> is used to describe polygons with multiple
- * contours. After you describe the first contour through a series of
- * {@link #gluTessVertex gluTessVertex} calls, a
- * <b>gluNextContour</b> call indicates that the previous contour is complete
- * and that the next contour is about to begin. Perform another series of
- * {@link #gluTessVertex gluTessVertex} calls to
- * describe the new contour. Repeat this process until all contours have been
- * described.<P>
- *
- * The type parameter defines what type of contour follows. The following
- * values are valid. <P>
- *
- * <b>GLU_EXTERIOR</b>
- * <UL>
- *   An exterior contour defines an exterior boundary of the polygon.
- * </UL>
- * <b>GLU_INTERIOR</b>
- * <UL>
- *   An interior contour defines an interior boundary of the polygon (such as
- *   a hole).
- * </UL>
- * <b>GLU_UNKNOWN</b>
- * <UL>
- *   An unknown contour is analyzed by the library to determine whether it is
- *   interior or exterior.
- * </UL>
- * <b>GLU_CCW, GLU_CW</b>
- * <UL>
- *   The first <b>GLU_CCW</b> or <b>GLU_CW</b> contour defined is considered
- *   to be exterior. All other contours are considered to be exterior if they
- *   are oriented in the same direction (clockwise or counterclockwise) as the
- *   first contour, and interior if they are not. If one contour is of type
- *   <b>GLU_CCW</b> or <b>GLU_CW</b>, then all contours must be of the same
- *   type (if they are not, then all <b>GLU_CCW</b> and <b>GLU_CW</b> contours
- *   will be changed to <b>GLU_UNKNOWN</b>). Note that there is no
- *   real difference between the <b>GLU_CCW</b> and <b>GLU_CW</b> contour
- *   types.
- * </UL><P>
- *
- * To define the type of the first contour, you can call <b>gluNextContour</b>
- * before describing the first contour. If you do not call
- * <b>gluNextContour</b> before the first contour, the first contour is marked
- * <b>GLU_EXTERIOR</b>.<P>
- *
- * <UL>
- *   <b>Note:</b>  The <b>gluNextContour</b> function is obsolete and is
- *   provided for backward compatibility only. The <b>gluNextContour</b>
- *   function is mapped to {@link #gluTessEndContour
- *   gluTessEndContour} followed by
- *   {@link #gluTessBeginContour gluTessBeginContour}.
- * </UL>
- *
- * @param tessellator
- *        Specifies the tessellation object (created with
- *        {@link #gluNewTess gluNewTess}).
- * @param type
- *        The type of the contour being defined.
- *
- * @see #gluNewTess          gluNewTess
- * @see #gluTessBeginContour gluTessBeginContour
- * @see #gluTessBeginPolygon gluTessBeginPolygon
- * @see #gluTessCallback     gluTessCallback
- * @see #gluTessEndContour   gluTessEndContour
- * @see #gluTessVertex       gluTessVertex
- ****************************************************************************/
-public final void gluNextContour(GLUtessellator tessellator, int type) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluNextContour(type);
-}
-
-/*****************************************************************************
- * <b>gluEndPolygon</b> and {@link #gluBeginPolygon
- * gluBeginPolygon} delimit the definition of a nonconvex polygon. To define
- * such a polygon, first call {@link #gluBeginPolygon
- * gluBeginPolygon}. Then define the contours of the polygon by calling
- * {@link #gluTessVertex gluTessVertex} for each vertex
- * and {@link #gluNextContour gluNextContour} to start
- * each new contour. Finally, call <b>gluEndPolygon</b> to signal the end of
- * the definition. See the {@link #gluTessVertex
- * gluTessVertex} and {@link #gluNextContour
- * gluNextContour} reference pages for more details.<P>
- *
- * Once <b>gluEndPolygon</b> is called, the polygon is tessellated, and the
- * resulting triangles are described through callbacks. See
- * {@link #gluTessCallback gluTessCallback} for
- * descriptions of the callback methods.
- *
- * @param tessellator
- *        Specifies the tessellation object (created with
- *        {@link #gluNewTess gluNewTess}).
- *
- * @see #gluNewTess          gluNewTess
- * @see #gluNextContour      gluNextContour
- * @see #gluTessCallback     gluTessCallback
- * @see #gluTessVertex       gluTessVertex
- * @see #gluTessBeginPolygon gluTessBeginPolygon
- * @see #gluTessBeginContour gluTessBeginContour
- ****************************************************************************/
-public final void gluEndPolygon(GLUtessellator tessellator) {
-    GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
-    tess.gluEndPolygon();
-}
-
-//----------------------------------------------------------------------
 // Quadric functionality
 //