PMVMatrix: Defaults from direct NIO -> array-backed non-direct NIO: Reduced cycles 45% -> 5% (from GearsES2 100%) - users/mraynsford/jogl.git

diff options

author	Sven Gothel <[email protected]>	2011-10-07 02:40:52 +0200
committer	Sven Gothel <[email protected]>	2011-10-07 02:40:52 +0200
commit	f5a2da16645ebc60d4e3da72f702cf682a5c0488 (patch)
tree	94a65aadeae42f623bce76a803cab1d76b04d1ba /make/scripts/lsGL23_commons.sh
parent	fa7627f623141c6fa15856c74d26c8ffe82550d0 (diff)

PMVMatrix: Defaults from direct NIO -> array-backed non-direct NIO: Reduced cycles 45% -> 5% (from GearsES2 100%)

- NIO direct access from Java is expensive - default is now array-backed non-direct NIO, which guarantees array useage for Java computation (especially the inverse calculation) - only update Mvi and Mvit if requested in the first place - moved all local matrices to float[]

Diffstat (limited to 'make/scripts/lsGL23_commons.sh')

0 files changed, 0 insertions, 0 deletions

/** * Returns true if the specified GLU core- or extension-function can be * successfully used through this GLU instance. By "successfully" we mean * that the function is both callable on the machine running the * program and available on the current display. * * A GLU function is callable if it is a GLU core- or extension-function * that is supported by the underlying GLU implementation. The function is * available if the OpenGL implementation on the display meets the * requirements of the GLU function being called (because GLU functions utilize * OpenGL functions). * * Whether or not a GLU function is callable is determined as follows: * <ul> * <li>If the function is a GLU core function (i.e., not an * extension), <code>gluGetString(GLU_VERSION)</code> is used to determine the * version number of the underlying GLU implementation on the host. * then the function name is cross-referenced with that specification to * see if it is part of that version's specification. * * <li> If the function is a GLU extension, the function name is * cross-referenced with the list returned by * <code>gluGetString(GLU_EXTENSIONS)</code> to see if the function is one of * the extensions that is supported by the underlying GLU implementation. * </ul> * * Whether or not a GLU function is available is determined as follows: * <ul> * <li>If the function is a GLU core function then the function is first * cross-referenced with the GLU specifications to find the minimum GLU * version required to call that GLU function. Then the following table * is consulted to determine the minimum GL version required for that version * of GLU: * <ul> * <li> GLU 1.0 requires OpenGL 1.0 * <li> GLU 1.1 requires OpenGL 1.0 * <li> GLU 1.2 requires OpenGL 1.1 * <li> GLU 1.3 requires OpenGL 1.2 * </ul> * Finally, <code>glGetString(GL_VERSION)</code> is used to determine the * highest OpenGL version that both host and display support, and from that it * is possible to determine if the GL facilities required by the GLU function * are available on the display. * * <li> If the function is a GLU extension, the function name is * cross-referenced with the list returned by * <code>gluGetString(GLU_EXTENSIONS)</code> to see if the function is one of * the extensions that is supported by the underlying GLU implementation. * </ul> * * NOTE:The availability of a function may change at runtime in * response to changes in the display environment. For example, when a window * is dragged from one display to another on a multi-display system, or when * the properties of the display device are modified (e.g., changing the color * depth of the display). Any application that is concerned with handling * these situations correctly should confirm availability after a display * change before calling a questionable OpenGL function. To detect a change in * the display device, please see {@link * GLEventListener#displayChanged(GLAutoDrawable,boolean,boolean)}. * * @param gluFunctionName the name of the OpenGL function (e.g., use * "gluNurbsCallbackDataEXT" to check if the <code> * gluNurbsCallbackDataEXT(GLUnurbs, GLvoid)</code> extension is available). */ public boolean isFunctionAvailable(String gluFunctionName) { // if (useJavaMipmapCode) { // All GLU functions are available in Java port return true; // } // return (gluProcAddressTable.getAddressFor(gluFunctionName) != 0); } //---------------------------------------------------------------------- // Utility routines // private static final Class gl2Class; private static final Class gl2es1Class; static { Class _gl2Class=null; Class _gl2es1Class=null; try { _gl2Class = Class.forName("javax.media.opengl.glu.gl2.GLUgl2"); _gl2es1Class = Class.forName("javax.media.opengl.glu.gl2es1.GLUgl2es1"); } catch (Throwable t) {} gl2Class = _gl2Class; gl2es1Class = _gl2es1Class; } /** * Instantiates a GLU implementation object in respect to the given GL profile * of this thread current GL. */ public static final GLU createGLU() throws GLException { return createGLU(getCurrentGL()); } /** * Instantiates a GLU implementation object in respect to the given GL profile * of the given GL. */ public static final GLU createGLU(GL gl) throws GLException { try { Class c = null; if(gl.isGL2() && null!=gl2Class) { c = gl2Class; } else if(gl.isGL2ES1() && null!=gl2es1Class) { c = gl2es1Class; /** There is no specialized ES 2 GLU at this time } else if(gl.isGL2ES2() && null!=gl2es2Class) { c = gl2es2Class; */ } else { c = GLU.class; } return (GLU) c.newInstance(); } catch (Exception e) { throw new GLException(e); } } public GLU() { this.project = new ProjectFloat(); } public void destroy() { if(null!=this.project) { this.project.destroy(); this.project=null; } } public static final GL getCurrentGL() throws GLException { GLContext curContext = GLContext.getCurrent(); if (curContext == null) { throw new GLException("No OpenGL context current on this thread"); } return curContext.getGL(); } public final String gluErrorString(int errorCode) { return Error.gluErrorString(errorCode); } /* extName is an extension name. * extString is a string of extensions separated by blank(s). There may or * may not be leading or trailing blank(s) in extString. * This works in cases of extensions being prefixes of another like * GL_EXT_texture and GL_EXT_texture3D. * Returns true if extName is found otherwise it returns false. */ public final boolean gluCheckExtension(java.lang.String extName, java.lang.String extString) { return Registry.gluCheckExtension(extName, extString); } public final String gluGetString(int name) { return Registry.gluGetString(name); } //---------------------------------------------------------------------- // Tessellation routines // protected static boolean availableGLUtessellatorImpl = false; protected static boolean checkedGLUtessellatorImpl = false; protected static final void validateGLUtessellatorImpl() { if(!checkedGLUtessellatorImpl) { availableGLUtessellatorImpl = ReflectionUtil.isClassAvailable("jogamp.opengl.glu.tessellator.GLUtessellatorImpl", GLU.class.getClassLoader()); checkedGLUtessellatorImpl = true; } if(!availableGLUtessellatorImpl) { throw new GLException("GLUtessellator not available (GLUtessellatorImpl)"); } } /***************************************************************************** * gluNewTess 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 #gluTessBeginPolygon gluTessBeginPolygon * @see #gluDeleteTess gluDeleteTess * @see #gluTessCallback gluTessCallback ****************************************************************************/ public static final GLUtessellator gluNewTess() { validateGLUtessellatorImpl(); return GLUtessellatorImpl.gluNewTess(); } /***************************************************************************** * gluDeleteTess destroys the indicated tessellation object (which was * created with {@link #gluNewTess gluNewTess}). * * Optional, throws GLException if not available in profile * * @param tessellator * Specifies the tessellation object to destroy. * * @see #gluBeginPolygon gluBeginPolygon * @see #gluNewTess gluNewTess * @see #gluTessCallback gluTessCallback ****************************************************************************/ public static final void gluDeleteTess(GLUtessellator tessellator) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; tess.gluDeleteTess(); } /***************************************************************************** * gluTessProperty 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 * * GLU_TESS_WINDING_RULE * <UL> * Determines which parts of the polygon are on the "interior". * value may be set to one of * GLU_TESS_WINDING_ODD, * GLU_TESS_WINDING_NONZERO, * GLU_TESS_WINDING_POSITIVE, or * GLU_TESS_WINDING_NEGATIVE, or * GLU_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 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> * GLU_TESS_BOUNDARY_ONLY * <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 GLU_TESS_BEGIN and GLU_TESS_BEGIN_DATA * callbacks use the type GL_LINE_LOOP for each contour. * </UL> * GLU_TESS_TOLERANCE * <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. * * 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. * </UL> * * @param tessellator * Specifies the tessellation object created with * {@link #gluNewTess gluNewTess} * @param which * Specifies the property to be set. Valid values are * GLU_TESS_WINDING_RULE, GLU_TESS_BOUNDARDY_ONLY, * GLU_TESS_TOLERANCE. * @param value * Specifices the value of the indicated property. * * @see #gluGetTessProperty gluGetTessProperty * @see #gluNewTess gluNewTess ****************************************************************************/ public static final void gluTessProperty(GLUtessellator tessellator, int which, double value) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) 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 #gluTessProperty gluTessProperty} 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 #gluNewTess gluNewTess}). * @param which * Specifies the property whose value is to be fetched. Valid values * are GLU_TESS_WINDING_RULE, GLU_TESS_BOUNDARY_ONLY, * and GLU_TESS_TOLERANCES. * @param value * Specifices an array into which the value of the named property is * written. * * @see #gluNewTess gluNewTess * @see #gluTessProperty gluTessProperty ****************************************************************************/ public static final void gluGetTessProperty(GLUtessellator tessellator, int which, double[] value, int value_offset) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; tess.gluGetTessProperty(which, value, value_offset); } /***************************************************************************** * gluTessNormal 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 * gluTessNormal(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 * gluTessNormal. * * Optional, throws GLException if not available in profile * * @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 static final void gluTessNormal(GLUtessellator tessellator, double x, double y, double z) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; tess.gluTessNormal(x, y, z); } /***************************************************************************** * gluTessCallback 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 #gluTessBeginPolygon gluTessBeginPolygon} * was called. The legal callbacks are as follows: * * GLU_TESS_BEGIN * <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 * GLU_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 * GLU_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: * </UL> * * <PRE> * void begin(int type);</PRE> * * GLU_TESS_BEGIN_DATA * <UL> * The same as the GLU_TESS_BEGIN 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> * * GLU_TESS_EDGE_FLAG * <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 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: * </UL> * * <PRE> * void edgeFlag(boolean boundaryEdge);</PRE> * * GLU_TESS_EDGE_FLAG_DATA * <UL> * The same as the GLU_TESS_EDGE_FLAG 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> * * GLU_TESS_VERTEX * <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> * * GLU_TESS_VERTEX_DATA * <UL> * The same as the GLU_TESS_VERTEX 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> * * GLU_TESS_END * <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> * * GLU_TESS_END_DATA * <UL> * The same as the GLU_TESS_END 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> * * GLU_TESS_COMBINE * <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 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 #gluTessEndPolygon gluTessEndPolygon} is * called. * * For example, if the polygon lies in an arbitrary plane in 3-space, and a * color is associated with each vertex, the GLU_TESS_COMBINE * 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 * GLU_TESS_COMBINE or GLU_TESS_COMBINE_DATA callback (see * below) must be defined, and it must write a non-null reference into * outData. Otherwise the GLU_TESS_NEED_COMBINE_CALLBACK error * occurs, and no output is generated. * </UL> * * GLU_TESS_COMBINE_DATA * <UL> * The same as the GLU_TESS_COMBINE 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> * * GLU_TESS_ERROR * <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 GLU_TESS_MISSING_BEGIN_POLYGON, * GLU_TESS_MISSING_END_POLYGON, * GLU_TESS_MISSING_BEGIN_CONTOUR, * GLU_TESS_MISSING_END_CONTOUR, GLU_TESS_COORD_TOO_LARGE, * GLU_TESS_NEED_COMBINE_CALLBACK or GLU_OUT_OF_MEMORY. * 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). GLU_TESS_COORD_TOO_LARGE indicates that some * vertex coordinate exceeded the predefined constant * GLU_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.) * GLU_TESS_NEED_COMBINE_CALLBACK indicates that the tessellation * detected an intersection between two edges in the input data, and the * GLU_TESS_COMBINE or GLU_TESS_COMBINE_DATA callback was not * provided. No output is generated. GLU_OUT_OF_MEMORY indicates that * there is not enough memory so no output is generated. * </UL> * * GLU_TESS_ERROR_DATA * <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: GLU_TESS_BEGIN, GLU_TESS_BEGIN_DATA, * GLU_TESS_EDGE_FLAG, GLU_TESS_EDGE_FLAG_DATA, * GLU_TESS_VERTEX, GLU_TESS_VERTEX_DATA, * GLU_TESS_END, GLU_TESS_END_DATA, * GLU_TESS_COMBINE, GLU_TESS_COMBINE_DATA, * GLU_TESS_ERROR, and GLU_TESS_ERROR_DATA. * @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 static final void gluTessCallback(GLUtessellator tessellator, int which, GLUtessellatorCallback aCallback) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; tess.gluTessCallback(which, aCallback); } /***************************************************************************** * gluTessVertex describes a vertex on a polygon that the program * defines. Successive gluTessVertex calls describe a closed contour. * For example, to describe a quadrilateral gluTessVertex should be * called four times. gluTessVertex can only be called between * {@link #gluTessBeginContour gluTessBeginContour} and * {@link #gluTessBeginContour gluTessEndContour}. * * 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 * GLU_TESS_VERTEX or GLU_TESS_VERTEX_DATA 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 static final void gluTessVertex(GLUtessellator tessellator, double[] coords, int coords_offset, Object data) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; tess.gluTessVertex(coords, coords_offset, data); } /***************************************************************************** * gluTessBeginPolygon and * {@link #gluTessEndPolygon gluTessEndPolygon} delimit * the definition of a convex, concave or self-intersecting polygon. Within * each gluTessBeginPolygon/ * {@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. * * 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 #gluTessCallback gluTessCallback}), then this * reference is returned to the callback method(s). Thus, it is a convenient * way to store per-polygon information. * * 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 static final void gluTessBeginPolygon(GLUtessellator tessellator, Object data) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; tess.gluTessBeginPolygon(data); } /***************************************************************************** * gluTessBeginContour and * {@link #gluTessEndContour gluTessEndContour} delimit * the definition of a polygon contour. Within each * gluTessBeginContour/ * {@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. gluTessBeginContour * can only be called between * {@link #gluTessBeginPolygon gluTessBeginPolygon} and * {@link #gluTessEndPolygon gluTessEndPolygon}. * * Optional, throws GLException if not available in profile * * @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 static final void gluTessBeginContour(GLUtessellator tessellator) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; tess.gluTessBeginContour(); } /***************************************************************************** * gluTessEndContour and * {@link #gluTessBeginContour gluTessBeginContour} * delimit the definition of a polygon contour. Within each * {@link #gluTessBeginContour gluTessBeginContour}/ * 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. * {@link #gluTessBeginContour gluTessBeginContour} can * only be called between {@link #gluTessBeginPolygon * gluTessBeginPolygon} and * {@link #gluTessEndPolygon gluTessEndPolygon}. * * Optional, throws GLException if not available in profile * * @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 static final void gluTessEndContour(GLUtessellator tessellator) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; tess.gluTessEndContour(); } /***************************************************************************** * gluTessEndPolygon and * {@link #gluTessBeginPolygon gluTessBeginPolygon} * delimit the definition of a convex, concave or self-intersecting polygon. * Within each {@link #gluTessBeginPolygon * gluTessBeginPolygon}/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. * * Optional, throws GLException if not available in profile * * Once gluTessEndPolygon 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 static final void gluTessEndPolygon(GLUtessellator tessellator) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; tess.gluTessEndPolygon(); } /***************************************************************************** * gluBeginPolygon and {@link #gluEndPolygon gluEndPolygon} * delimit the definition of a nonconvex polygon. To define such a * polygon, first call 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 {@link * #gluEndPolygon gluEndPolygon} to signal the end of the * definition. See the {@link #gluTessVertex gluTessVertex} and {@link * #gluNextContour gluNextContour} reference pages for more * details. * * Optional, throws GLException if not available in profile * * 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 static final void gluBeginPolygon(GLUtessellator tessellator) { validateGLUtessellatorImpl(); GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; tess.gluBeginPolygon(); } /***************************************************************************** * gluNextContour is used to describe polygons with multiple * contours. After you describe the first contour through a series of * {@link #gluTessVertex gluTessVertex} calls, a * gluNextContour 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. * * Optional, throws GLException if not available in profile * * The type parameter defines what type of contour follows. The following * values are valid. * * GLU_EXTERIOR * <UL> * An exterior contour defines an exterior boundary of the polygon. * </UL> * GLU_INTERIOR * <UL> * An interior contour defines an interior boundary of the polygon (such as * a hole). * </UL> * GLU_UNKNOWN


context:
space:
mode: