com.sun.prism.util.tess.Tess Maven / Gradle / Ivy
Show all versions of openjfx-78-backport Show documentation
/*
* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.prism.util.tess;
import com.sun.prism.util.tess.impl.tess.TessellatorImpl;
// TODO: RT-17486 - Need a replacement for GLU Tessellator
/**
* Provides access to the OpenGL Utility Library (Tess).
*
*
*
* Notes from the Reference Implementation for this class:
* Thanks to the contributions of many individuals, this class is a
* pure Java port of SGI's original C sources. All of the projection,
* mipmap, scaling, and tessellation routines that are exposed are
* compatible with the GLU 1.3 specification. The GLU NURBS routines
* are not currently exposed.
*/
public class Tess
{
// TODO: Temporary constants needed to isolate jogl
public static final int GL_POINTS = 0; // GL.GL_POINTS;
public static final int GL_LINES = 1; //GL.GL_LINES;
public static final int GL_LINE_LOOP = 2; //GL.GL_LINE_LOOP;
public static final int GL_LINE_STRIP = 3; //GL.GL_LINE_STRIP;
public static final int GL_TRIANGLES = 4; //GL.GL_TRIANGLES;
public static final int GL_TRIANGLE_STRIP = 5; //GL.GL_TRIANGLE_STRIP;
public static final int GL_TRIANGLE_FAN = 6; //GL.GL_TRIANGLE_FAN;
//----------------------------------------------------------------------
// Tessellation routines
//
/*****************************************************************************
* newTess 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.
*
* Optional, throws GLException if not available in profile
*
* @return A new tessellation object.
*
* @see #tessBeginPolygon tessBeginPolygon
* @see #deleteTess deleteTess
* @see #tessCallback tessCallback
****************************************************************************/
public static final Tessellator newTess() {
return TessellatorImpl.gluNewTess();
}
/*****************************************************************************
* deleteTess destroys the indicated tessellation object (which was
* created with {@link #newTess newTess}).
*
* Optional, throws GLException if not available in profile
*
* @param tessellator
* Specifies the tessellation object to destroy.
*
* @see #beginPolygon beginPolygon
* @see #newTess newTess
* @see #tessCallback tessCallback
****************************************************************************/
public static final void deleteTess(Tessellator tessellator) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluDeleteTess();
}
/*****************************************************************************
* tessProperty 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 which are as
* follows:
*
* Optional, throws GLException if not available in profile
*
* TESS_WINDING_RULE
*
* Determines which parts of the polygon are on the "interior".
* value may be set to one of
*
TESS_WINDING_ODD,
*
TESS_WINDING_NONZERO,
*
TESS_WINDING_POSITIVE, or
*
TESS_WINDING_NEGATIVE, or
*
TESS_WINDING_ABS_GEQ_TWO.
*
* 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.
*
* 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.
*
* 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 Tess tessellator (prior to
* Tess 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.
*
*
TESS_BOUNDARY_ONLY
*
* 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 TESS_BEGIN and TESS_BEGIN_DATA
* callbacks use the type GL_LINE_LOOP for each contour.
*
*
TESS_TOLERANCE
*
* 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.
*
* 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.
*
* 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.
*
*
* @param tessellator
* Specifies the tessellation object created with
* {@link #newTess newTess}
* @param which
* Specifies the property to be set. Valid values are
* TESS_WINDING_RULE, GLU_TESS_BOUNDARDY_ONLY,
* TESS_TOLERANCE.
* @param value
* Specifices the value of the indicated property.
*
* @see #gluGetTessProperty gluGetTessProperty
* @see #newTess newTess
****************************************************************************/
public static final void tessProperty(Tessellator tessellator, int which, double value) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluTessProperty(which, value);
}
/*****************************************************************************
* gluGetTessProperty retrieves properties stored in a tessellation
* object. These properties affect the way that tessellation objects are
* interpreted and rendered. See the
* {@link #tessProperty tessProperty} reference
* page for information about the properties and what they do.
*
* Optional, throws GLException if not available in profile
*
* @param tessellator
* Specifies the tessellation object (created with
* {@link #newTess newTess}).
* @param which
* Specifies the property whose value is to be fetched. Valid values
* are TESS_WINDING_RULE, TESS_BOUNDARY_ONLY,
* and GLU_TESS_TOLERANCES.
* @param value
* Specifices an array into which the value of the named property is
* written.
*
* @see #newTess newTess
* @see #tessProperty tessProperty
****************************************************************************/
public static final void gluGetTessProperty(Tessellator tessellator, int which, double[] value, int value_offset) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluGetTessProperty(which, value, value_offset);
}
/*****************************************************************************
* tessNormal 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
* tessNormal(tess, 0.0, 0.0, 0.0) before rendering any polygons.
*
* 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).
*
* The supplied normal persists until it is changed by another call to
* tessNormal.
*
* Optional, throws GLException if not available in profile
*
* @param tessellator
* Specifies the tessellation object (created by
* {@link #newTess newTess}).
* @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 #tessBeginPolygon tessBeginPolygon
* @see #tessEndPolygon tessEndPolygon
****************************************************************************/
public static final void tessNormal(Tessellator tessellator, double x, double y, double z) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluTessNormal(x, y, z);
}
/*****************************************************************************
* tessCallback 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 aCallback is null, then the existing callback
* becomes undefined.
*
* Optional, throws GLException if not available in profile
*
* 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 #tessBeginPolygon tessBeginPolygon}
* was called. The legal callbacks are as follows:
*
* TESS_BEGIN
*
* The begin callback is invoked like {@link com.sun.prism.opengl.GL#glBegin
* glBegin} to indicate the start of a (triangle) primitive. The method
* takes a single argument of type int. If the
* TESS_BOUNDARY_ONLY property is set to GL_FALSE, then
* the argument is set to either GL_TRIANGLE_FAN,
* GL_TRIANGLE_STRIP, or GL_TRIANGLES. If the
* TESS_BOUNDARY_ONLY property is set to GL_TRUE, then the
* argument will be set to GL_LINE_LOOP. The method prototype for
* this callback is:
*
*
*
* void begin(int type);
*
* TESS_BEGIN_DATA
*
* The same as the TESS_BEGIN callback except
* that it takes an additional reference argument. This reference is
* identical to the opaque reference provided when
* {@link #tessBeginPolygon tessBeginPolygon}
* was called. The method prototype for this callback is:
*
*
*
* void beginData(int type, Object polygonData);
*
* TESS_EDGE_FLAG
*
* The edge flag callback is similar to
* {@link com.sun.prism.opengl.GL#glEdgeFlag glEdgeFlag}. The method takes
* a single boolean boundaryEdge that indicates which edges lie on the
* polygon boundary. If the boundaryEdge is GL_TRUE, 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 GL_FALSE, 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.
*
* Since triangle fans and triangle strips do not support edge flags, the
* begin callback is not called with GL_TRIANGLE_FAN or
* GL_TRIANGLE_STRIP 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:
*
*
*
* void edgeFlag(boolean boundaryEdge);
*
* TESS_EDGE_FLAG_DATA
*
* The same as the TESS_EDGE_FLAG callback except that it takes
* an additional reference argument. This reference is identical to the
* opaque reference provided when
* {@link #tessBeginPolygon tessBeginPolygon}
* was called. The method prototype for this callback is:
*
*
*
* void edgeFlagData(boolean boundaryEdge, Object polygonData);
*
* TESS_VERTEX
*
* The vertex callback is invoked between the begin and end callbacks. It is
* similar to {@link com.sun.prism.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 #tessVertex tessVertex}). The method
* prototype for this callback is:
*
*
*
* void vertex(Object vertexData);
*
* TESS_VERTEX_DATA
*
* The same as the TESS_VERTEX callback except that it takes an
* additional reference argument. This reference is identical to the opaque
* reference provided when
* {@link #tessBeginPolygon tessBeginPolygon}
* was called. The method prototype for this callback is:
*
*
*
* void vertexData(Object vertexData, Object polygonData);
*
* TESS_END
*
* The end callback serves the same purpose as
* {@link com.sun.prism.opengl.GL#glEnd glEnd}. It indicates the end of a
* primitive and it takes no arguments. The method prototype for this
* callback is:
*
*
*
* void end();
*
* TESS_END_DATA
*
* The same as the TESS_END callback except that it takes an
* additional reference argument. This reference is identical to the opaque
* reference provided when
* {@link #tessBeginPolygon tessBeginPolygon}
* was called. The method prototype for this callback is:
*
*
*
* void endData(Object polygonData);
*
* TESS_COMBINE
*
* 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:
*
*
*
* void combine(double[] coords, Object[] data,
* float[] weight, Object[] outData);
*
*
* The vertex is defined as a linear combination of up to four existing
* vertices, stored in data. The coefficients of the linear
* combination are given by weight; these weights always add up to 1.
* All vertex pointers are valid even when some of the weights are 0.
* coords gives the location of the new vertex.
*
* The user must allocate another vertex, interpolate parameters using
* data and weight, and return the new vertex pointer
* in outData. This handle is supplied during rendering callbacks.
* The user is responsible for freeing the memory some time after
* {@link #tessEndPolygon tessEndPolygon} is
* called.
*
* For example, if the polygon lies in an arbitrary plane in 3-space, and a
* color is associated with each vertex, the TESS_COMBINE
* callback might look like this:
*
*
* 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;
* }
*
*
* If the tessellation detects an intersection, then the
* TESS_COMBINE or TESS_COMBINE_DATA callback (see
* below) must be defined, and it must write a non-null reference into
* outData. Otherwise the TESS_NEED_COMBINE_CALLBACK error
* occurs, and no output is generated.
*
*
* TESS_COMBINE_DATA
*
* The same as the TESS_COMBINE callback except that it takes an
* additional reference argument. This reference is identical to the opaque
* reference provided when
* {@link #tessBeginPolygon tessBeginPolygon}
* was called. The method prototype for this callback is:
*
*
*
* void combineData(double[] coords, Object[] data,
float[] weight, Object[] outData,
Object polygonData);
*
* TESS_ERROR
*
* 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 TESS_MISSING_BEGIN_POLYGON,
* TESS_MISSING_END_POLYGON,
* TESS_MISSING_BEGIN_CONTOUR,
* TESS_MISSING_END_CONTOUR, TESS_COORD_TOO_LARGE,
* TESS_NEED_COMBINE_CALLBACK or OUT_OF_MEMORY.
* Character strings describing these errors can be retrieved with the
* {@link #gluErrorString gluErrorString} call. The
* method prototype for this callback is:
*
*
*
* void error(int errnum);
*
*
* The Tess library will recover from the first four errors by inserting the
* missing call(s). TESS_COORD_TOO_LARGE indicates that some
* vertex coordinate exceeded the predefined constant
* TESS_MAX_COORD 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.)
* TESS_NEED_COMBINE_CALLBACK indicates that the tessellation
* detected an intersection between two edges in the input data, and the
* TESS_COMBINE or TESS_COMBINE_DATA callback was not
* provided. No output is generated. OUT_OF_MEMORY indicates that
* there is not enough memory so no output is generated.
*
*
* TESS_ERROR_DATA
*
* The same as the TESS_ERROR callback except that it takes an
* additional reference argument. This reference is identical to the opaque
* reference provided when
* {@link #tessBeginPolygon tessBeginPolygon}
* was called. The method prototype for this callback is:
*
*
*
* void errorData(int errnum, Object polygonData);
*
* @param tessellator
* Specifies the tessellation object (created with
* {@link #newTess newTess}).
* @param which
* Specifies the callback being defined. The following values are
* valid: TESS_BEGIN, TESS_BEGIN_DATA,
* TESS_EDGE_FLAG, TESS_EDGE_FLAG_DATA,
* TESS_VERTEX, TESS_VERTEX_DATA,
* TESS_END, TESS_END_DATA,
* TESS_COMBINE, TESS_COMBINE_DATA,
* TESS_ERROR, and TESS_ERROR_DATA.
* @param aCallback
* Specifies the callback object to be called.
*
* @see com.sun.prism.opengl.GL#glBegin glBegin
* @see com.sun.prism.opengl.GL#glEdgeFlag glEdgeFlag
* @see com.sun.prism.opengl.GL#glVertex3f glVertex3f
* @see #newTess newTess
* @see #gluErrorString gluErrorString
* @see #tessVertex tessVertex
* @see #tessBeginPolygon tessBeginPolygon
* @see #tessBeginContour tessBeginContour
* @see #tessProperty tessProperty
* @see #tessNormal tessNormal
****************************************************************************/
public static final void tessCallback(Tessellator tessellator, int which, TessellatorCallback aCallback) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluTessCallback(which, aCallback);
}
/*****************************************************************************
* tessVertex describes a vertex on a polygon that the program
* defines. Successive tessVertex calls describe a closed contour.
* For example, to describe a quadrilateral tessVertex should be
* called four times. tessVertex can only be called between
* {@link #tessBeginContour tessBeginContour} and
* {@link #tessBeginContour tessEndContour}.
*
* Optional, throws GLException if not available in profile
*
* data 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
* TESS_VERTEX or TESS_VERTEX_DATA callback after
* tessellation (see the {@link #tessCallback
* tessCallback} reference page).
*
* @param tessellator
* Specifies the tessellation object (created with
* {@link #newTess newTess}).
* @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 #tessCallback tessCallback}).
*
* @see #tessBeginPolygon tessBeginPolygon
* @see #newTess newTess
* @see #tessBeginContour tessBeginContour
* @see #tessCallback tessCallback
* @see #tessProperty tessProperty
* @see #tessNormal tessNormal
* @see #tessEndPolygon tessEndPolygon
****************************************************************************/
public static final void tessVertex(Tessellator tessellator, double[] coords, int coords_offset, Object data) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluTessVertex(coords, coords_offset, data);
}
/*****************************************************************************
* tessBeginPolygon and
* {@link #tessEndPolygon tessEndPolygon} delimit
* the definition of a convex, concave or self-intersecting polygon. Within
* each tessBeginPolygon/
* {@link #tessEndPolygon tessEndPolygon} pair,
* there must be one or more calls to
* {@link #tessBeginContour tessBeginContour}/
* {@link #tessEndContour tessEndContour}. Within
* each contour, there are zero or more calls to
* {@link #tessVertex tessVertex}. The vertices
* specify a closed contour (the last vertex of each contour is automatically
* linked to the first). See the {@link #tessVertex
* tessVertex}, {@link #tessBeginContour
* tessBeginContour}, and {@link #tessEndContour
* tessEndContour} reference pages for more details.
*
* Optional, throws GLException if not available in profile
*
* data is a reference to a user-defined data structure. If the
* appropriate callback(s) are specified (see
* {@link #tessCallback tessCallback}), then this
* reference is returned to the callback method(s). Thus, it is a convenient
* way to store per-polygon information.
*
* Once {@link #tessEndPolygon tessEndPolygon} is
* called, the polygon is tessellated, and the resulting triangles are
* described through callbacks. See
* {@link #tessCallback tessCallback} for
* descriptions of the callback methods.
*
* @param tessellator
* Specifies the tessellation object (created with
* {@link #newTess newTess}).
* @param data
* Specifies a reference to user polygon data.
*
* @see #newTess newTess
* @see #tessBeginContour tessBeginContour
* @see #tessVertex tessVertex
* @see #tessCallback tessCallback
* @see #tessProperty tessProperty
* @see #tessNormal tessNormal
* @see #tessEndPolygon tessEndPolygon
****************************************************************************/
public static final void tessBeginPolygon(Tessellator tessellator, Object data) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluTessBeginPolygon(data);
}
/*****************************************************************************
* tessBeginContour and
* {@link #tessEndContour tessEndContour} delimit
* the definition of a polygon contour. Within each
* tessBeginContour/
* {@link #tessEndContour tessEndContour} pair,
* there can be zero or more calls to
* {@link #tessVertex tessVertex}. The vertices
* specify a closed contour (the last vertex of each contour is automatically
* linked to the first). See the {@link #tessVertex
* tessVertex} reference page for more details. tessBeginContour
* can only be called between
* {@link #tessBeginPolygon tessBeginPolygon} and
* {@link #tessEndPolygon tessEndPolygon}.
*
* Optional, throws GLException if not available in profile
*
* @param tessellator
* Specifies the tessellation object (created with
* {@link #newTess newTess}).
*
* @see #newTess newTess
* @see #tessBeginPolygon tessBeginPolygon
* @see #tessVertex tessVertex
* @see #tessCallback tessCallback
* @see #tessProperty tessProperty
* @see #tessNormal tessNormal
* @see #tessEndPolygon tessEndPolygon
****************************************************************************/
public static final void tessBeginContour(Tessellator tessellator) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluTessBeginContour();
}
/*****************************************************************************
* tessEndContour and
* {@link #tessBeginContour tessBeginContour}
* delimit the definition of a polygon contour. Within each
* {@link #tessBeginContour tessBeginContour}/
* tessEndContour pair, there can be zero or more calls to
* {@link #tessVertex tessVertex}. The vertices
* specify a closed contour (the last vertex of each contour is automatically
* linked to the first). See the {@link #tessVertex
* tessVertex} reference page for more details.
* {@link #tessBeginContour tessBeginContour} can
* only be called between {@link #tessBeginPolygon
* tessBeginPolygon} and
* {@link #tessEndPolygon tessEndPolygon}.
*
* Optional, throws GLException if not available in profile
*
* @param tessellator
* Specifies the tessellation object (created with
* {@link #newTess newTess}).
*
* @see #newTess newTess
* @see #tessBeginPolygon tessBeginPolygon
* @see #tessVertex tessVertex
* @see #tessCallback tessCallback
* @see #tessProperty tessProperty
* @see #tessNormal tessNormal
* @see #tessEndPolygon tessEndPolygon
****************************************************************************/
public static final void tessEndContour(Tessellator tessellator) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluTessEndContour();
}
/*****************************************************************************
* tessEndPolygon and
* {@link #tessBeginPolygon tessBeginPolygon}
* delimit the definition of a convex, concave or self-intersecting polygon.
* Within each {@link #tessBeginPolygon
* tessBeginPolygon}/tessEndPolygon pair, there must be one or
* more calls to {@link #tessBeginContour
* tessBeginContour}/{@link #tessEndContour
* tessEndContour}. Within each contour, there are zero or more calls to
* {@link #tessVertex tessVertex}. The vertices
* specify a closed contour (the last vertex of each contour is automatically
* linked to the first). See the {@link #tessVertex
* tessVertex}, {@link #tessBeginContour
* tessBeginContour} and {@link #tessEndContour
* tessEndContour} reference pages for more details.
*
* Optional, throws GLException if not available in profile
*
* Once tessEndPolygon is called, the polygon is tessellated, and
* the resulting triangles are described through callbacks. See
* {@link #tessCallback tessCallback} for
* descriptions of the callback functions.
*
* @param tessellator
* Specifies the tessellation object (created with
* {@link #newTess newTess}).
*
* @see #newTess newTess
* @see #tessBeginContour tessBeginContour
* @see #tessVertex tessVertex
* @see #tessCallback tessCallback
* @see #tessProperty tessProperty
* @see #tessNormal tessNormal
* @see #tessBeginPolygon tessBeginPolygon
****************************************************************************/
public static final void tessEndPolygon(Tessellator tessellator) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluTessEndPolygon();
}
/*****************************************************************************
* beginPolygon and {@link #endPolygon endPolygon}
* delimit the definition of a nonconvex polygon. To define such a
* polygon, first call beginPolygon. Then define the
* contours of the polygon by calling {@link #tessVertex
* tessVertex} for each vertex and {@link #nextContour
* nextContour} to start each new contour. Finally, call {@link
* #endPolygon endPolygon} to signal the end of the
* definition. See the {@link #tessVertex tessVertex} and {@link
* #nextContour nextContour} reference pages for more
* details.
*
* Optional, throws GLException if not available in profile
*
* Once {@link #endPolygon endPolygon} is called,
* the polygon is tessellated, and the resulting triangles are described
* through callbacks. See {@link #tessCallback
* tessCallback} for descriptions of the callback methods.
*
* @param tessellator
* Specifies the tessellation object (created with
* {@link #newTess newTess}).
*
* @see #newTess newTess
* @see #nextContour nextContour
* @see #tessCallback tessCallback
* @see #tessVertex tessVertex
* @see #tessBeginPolygon tessBeginPolygon
* @see #tessBeginContour tessBeginContour
****************************************************************************/
public static final void beginPolygon(Tessellator tessellator) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluBeginPolygon();
}
/*****************************************************************************
* nextContour is used to describe polygons with multiple
* contours. After you describe the first contour through a series of
* {@link #tessVertex tessVertex} calls, a
* nextContour call indicates that the previous contour is complete
* and that the next contour is about to begin. Perform another series of
* {@link #tessVertex tessVertex} calls to
* describe the new contour. Repeat this process until all contours have been
* described.
*
* Optional, throws GLException if not available in profile
*
* The type parameter defines what type of contour follows. The following
* values are valid.
*
* GLU_EXTERIOR
*
* An exterior contour defines an exterior boundary of the polygon.
*
* GLU_INTERIOR
*
* An interior contour defines an interior boundary of the polygon (such as
* a hole).
*
* GLU_UNKNOWN
*
* An unknown contour is analyzed by the library to determine whether it is
* interior or exterior.
*
* GLU_CCW, GLU_CW
*
* The first GLU_CCW or GLU_CW 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
* GLU_CCW or GLU_CW, then all contours must be of the same
* type (if they are not, then all GLU_CCW and GLU_CW contours
* will be changed to GLU_UNKNOWN). Note that there is no
* real difference between the GLU_CCW and GLU_CW contour
* types.
*
*
* To define the type of the first contour, you can call nextContour
* before describing the first contour. If you do not call
* nextContour before the first contour, the first contour is marked
* GLU_EXTERIOR.
*
*
* Note: The nextContour function is obsolete and is
* provided for backward compatibility only. The nextContour
* function is mapped to {@link #tessEndContour
* tessEndContour} followed by
* {@link #tessBeginContour tessBeginContour}.
*
*
* @param tessellator
* Specifies the tessellation object (created with
* {@link #newTess newTess}).
* @param type
* The type of the contour being defined.
*
* @see #newTess newTess
* @see #tessBeginContour tessBeginContour
* @see #tessBeginPolygon tessBeginPolygon
* @see #tessCallback tessCallback
* @see #tessEndContour tessEndContour
* @see #tessVertex tessVertex
****************************************************************************/
public static final void nextContour(Tessellator tessellator, int type) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluNextContour(type);
}
/*****************************************************************************
* endPolygon and {@link #beginPolygon
* beginPolygon} delimit the definition of a nonconvex polygon. To define
* such a polygon, first call {@link #beginPolygon
* beginPolygon}. Then define the contours of the polygon by calling
* {@link #tessVertex tessVertex} for each vertex
* and {@link #nextContour nextContour} to start
* each new contour. Finally, call endPolygon to signal the end of
* the definition. See the {@link #tessVertex
* tessVertex} and {@link #nextContour
* nextContour} reference pages for more details.
*
* Optional, throws GLException if not available in profile
*
* Once endPolygon is called, the polygon is tessellated, and the
* resulting triangles are described through callbacks. See
* {@link #tessCallback tessCallback} for
* descriptions of the callback methods.
*
* @param tessellator
* Specifies the tessellation object (created with
* {@link #newTess newTess}).
*
* @see #newTess newTess
* @see #nextContour nextContour
* @see #tessCallback tessCallback
* @see #tessVertex tessVertex
* @see #tessBeginPolygon tessBeginPolygon
* @see #tessBeginContour tessBeginContour
****************************************************************************/
public static final void endPolygon(Tessellator tessellator) {
TessellatorImpl tess = (TessellatorImpl) tessellator;
tess.gluEndPolygon();
}
// ErrorCode
public static final int INVALID_ENUM = 100900;
public static final int INVALID_VALUE = 100901;
public static final int OUT_OF_MEMORY = 100902;
public static final int INVALID_OPERATION = 100904;
// TessCallback
public static final int TESS_BEGIN = 100100;
public static final int BEGIN = 100100;
public static final int TESS_VERTEX = 100101;
public static final int VERTEX = 100101;
public static final int TESS_END = 100102;
public static final int END = 100102;
public static final int TESS_ERROR = 100103;
public static final int TESS_EDGE_FLAG = 100104;
public static final int EDGE_FLAG = 100104;
public static final int TESS_COMBINE = 100105;
public static final int TESS_BEGIN_DATA = 100106;
public static final int TESS_VERTEX_DATA = 100107;
public static final int TESS_END_DATA = 100108;
public static final int TESS_ERROR_DATA = 100109;
public static final int TESS_EDGE_FLAG_DATA = 100110;
public static final int TESS_COMBINE_DATA = 100111;
// TessProperty
public static final int TESS_WINDING_RULE = 100140;
public static final int TESS_BOUNDARY_ONLY = 100141;
public static final int TESS_TOLERANCE = 100142;
// JOGL-specific boolean property, false by default, that may improve the tessellation
public static final int TESS_AVOID_DEGENERATE_TRIANGLES = 100149;
// TessError
public static final int TESS_ERROR1 = 100151;
public static final int TESS_ERROR2 = 100152;
public static final int TESS_ERROR3 = 100153;
public static final int TESS_ERROR4 = 100154;
public static final int TESS_ERROR5 = 100155;
public static final int TESS_ERROR6 = 100156;
public static final int TESS_MISSING_BEGIN_POLYGON = 100151;
public static final int TESS_MISSING_BEGIN_CONTOUR = 100152;
public static final int TESS_MISSING_END_POLYGON = 100153;
public static final int TESS_MISSING_END_CONTOUR = 100154;
public static final int TESS_COORD_TOO_LARGE = 100155;
public static final int TESS_NEED_COMBINE_CALLBACK = 100156;
// TessWinding
public static final int TESS_WINDING_ODD = 100130;
public static final int TESS_WINDING_NONZERO = 100131;
public static final int TESS_WINDING_POSITIVE = 100132;
public static final int TESS_WINDING_NEGATIVE = 100133;
public static final int TESS_WINDING_ABS_GEQ_TWO = 100134;
public static final double TESS_MAX_COORD = 1.0e150;
} // end of class Tess