From a959c53b7ac91e489bf0959391e892790b9ff248 Mon Sep 17 00:00:00 2001 From: Kenneth Russel Date: Mon, 15 Jun 2009 22:57:38 +0000 Subject: Copied JOGL_2_SANDBOX r1957 on to trunk; JOGL_2_SANDBOX branch is now closed git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@1959 232f8b59-042b-4e1e-8c03-345bb8c30851 --- make/config/jogl/glu-CustomJavaCode-base.java | 1469 +++++++++++++++++++++++++ 1 file changed, 1469 insertions(+) create mode 100755 make/config/jogl/glu-CustomJavaCode-base.java (limited to 'make/config/jogl/glu-CustomJavaCode-base.java') diff --git a/make/config/jogl/glu-CustomJavaCode-base.java b/make/config/jogl/glu-CustomJavaCode-base.java new file mode 100755 index 000000000..6949cfb68 --- /dev/null +++ b/make/config/jogl/glu-CustomJavaCode-base.java @@ -0,0 +1,1469 @@ +/** + * 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: + *

+ * + * Whether or not a GLU function is available is determined as follows: + * + * + * 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 + * gluNurbsCallbackDataEXT(GLUnurbs, GLvoid) 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 Class gl2Class; +private static Class 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()) { + if (gl2Class == null) { + gl2Class = Class.forName("javax.media.opengl.glu.gl2.GLUgl2"); + } + c = gl2Class; + } else if (gl.isGL2ES1()) { + if (gl2es1Class == null) { + gl2es1Class = Class.forName("javax.media.opengl.glu.gl2es1.GLUgl2es1"); + } + c = gl2es1Class; + } + if (c != null) { + return (GLU) c.newInstance(); + } + } catch (Exception e) { + throw new GLException(e); + } + // There is no specialized ES 2 GLU at this time + /* + try { + if(GLProfile.GL2ES12.equals(profile) || GLProfile.GL2.equals(profile) || GLProfile.GLES2.equals(profile)) { + return (GLU) NWReflection.createInstance("javax.media.opengl.glu.gl2es2.GLUgl2es2"); + } + } catch (GLException e) { e.printStackTrace(); } + */ + return new GLU(); +} + +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 = NWReflection.isClassAvailable("com.sun.opengl.impl.glu.tessellator.GLUtessellatorImpl"); + 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 + *

+ *
GLU_TESS_BOUNDARY_ONLY + * + *
GLU_TESS_TOLERANCE + * + * + * @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 + *

+ * + * 
+ *         void begin(int type);

+ * + * GLU_TESS_BEGIN_DATA + *

+ * + * 
+ *         void beginData(int type, Object polygonData);
+ * + * GLU_TESS_EDGE_FLAG + * + * + * 
+ *         void edgeFlag(boolean boundaryEdge);
+ * + * GLU_TESS_EDGE_FLAG_DATA + * + * + * 
+ *         void edgeFlagData(boolean boundaryEdge, Object polygonData);
+ * + * GLU_TESS_VERTEX + * + * + * 
+ *         void vertex(Object vertexData);
+ * + * GLU_TESS_VERTEX_DATA + * + * + * 
+ *         void vertexData(Object vertexData, Object polygonData);
+ * + * GLU_TESS_END + * + * + * 
+ *         void end();
+ * + * GLU_TESS_END_DATA + * + * + * 
+ *         void endData(Object polygonData);
+ * + * GLU_TESS_COMBINE + * + * + * 
+ *         void combine(double[] coords, Object[] data,
+ *                      float[] weight, Object[] outData);
+ * + * + * 
+ *         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;
+ *         }
+ * + * + * + * GLU_TESS_COMBINE_DATA + * + * + * 
+ *         void combineData(double[] coords, Object[] data,
+                            float[] weight, Object[] outData,
+                            Object polygonData);
+ * + * GLU_TESS_ERROR + * + * + * 
+ *         void error(int errnum);
+ * + * + * + * GLU_TESS_ERROR_DATA + * + * + * 
+ *         void errorData(int errnum, Object polygonData);
+ * + * @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 + *

+ * GLU_INTERIOR + * + * GLU_UNKNOWN + * + * GLU_CCW, GLU_CW + *

+ * + * To define the type of the first contour, you can call gluNextContour + * before describing the first contour. If you do not call + * gluNextContour before the first contour, the first contour is marked + * GLU_EXTERIOR.

+ * + *

+ * + * @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 static final void gluNextContour(GLUtessellator tessellator, int type) { + validateGLUtessellatorImpl(); + GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; + tess.gluNextContour(type); +} + +/***************************************************************************** + * gluEndPolygon 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 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 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 gluEndPolygon(GLUtessellator tessellator) { + validateGLUtessellatorImpl(); + GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator; + tess.gluEndPolygon(); +} + +// Boolean +public static final int GLU_FALSE = 0; +public static final int GLU_TRUE = 1; + +// String Name +public static final int GLU_VERSION = 100800; +public static final int GLU_EXTENSIONS = 100801; + +// Extensions +public static final String versionString = "1.3"; +public static final String extensionString = "GLU_EXT_nurbs_tessellator " + + "GLU_EXT_object_space_tess "; + +// ErrorCode +public static final int GLU_INVALID_ENUM = 100900; +public static final int GLU_INVALID_VALUE = 100901; +public static final int GLU_OUT_OF_MEMORY = 100902; +public static final int GLU_INVALID_OPERATION = 100904; + + +// QuadricDrawStyle +public static final int GLU_POINT = 100010; +public static final int GLU_LINE = 100011; +public static final int GLU_FILL = 100012; +public static final int GLU_SILHOUETTE = 100013; + +// QuadricCallback +// GLU_ERROR + +// QuadricNormal +public static final int GLU_SMOOTH = 100000; +public static final int GLU_FLAT = 100001; +public static final int GLU_NONE = 100002; + +// QuadricOrientation +public static final int GLU_OUTSIDE = 100020; +public static final int GLU_INSIDE = 100021; + +// NurbsDisplay +// GLU_FILL +//public static final int GLU_OUTLINE_POLYGON = 100240; +//public static final int GLU_OUTLINE_PATCH = 100241; + +// NurbsCallback +//public static final int GLU_NURBS_ERROR = 100103; +public static final int GLU_ERROR = 100103; +//public static final int GLU_NURBS_BEGIN = 100164; +//public static final int GLU_NURBS_BEGIN_EXT = 100164; +//public static final int GLU_NURBS_VERTEX = 100165; +//public static final int GLU_NURBS_VERTEX_EXT = 100165; +//public static final int GLU_NURBS_NORMAL = 100166; +//public static final int GLU_NURBS_NORMAL_EXT = 100166; +//public static final int GLU_NURBS_COLOR = 100167; +//public static final int GLU_NURBS_COLOR_EXT = 100167; +//public static final int GLU_NURBS_TEXTURE_COORD = 100168; +//public static final int GLU_NURBS_TEX_COORD_EXT = 100168; +//public static final int GLU_NURBS_END = 100169; +//public static final int GLU_NURBS_END_EXT = 100169; +//public static final int GLU_NURBS_BEGIN_DATA = 100170; +//public static final int GLU_NURBS_BEGIN_DATA_EXT = 100170; +//public static final int GLU_NURBS_VERTEX_DATA = 100171; +//public static final int GLU_NURBS_VERTEX_DATA_EXT = 100171; +//public static final int GLU_NURBS_NORMAL_DATA = 100172; +//public static final int GLU_NURBS_NORMAL_DATA_EXT = 100172; +//public static final int GLU_NURBS_COLOR_DATA = 100173; +//public static final int GLU_NURBS_COLOR_DATA_EXT = 100173; +//public static final int GLU_NURBS_TEXTURE_COORD_DATA = 100174; +//public static final int GLU_NURBS_TEX_COORD_DATA_EXT = 100174; +//public static final int GLU_NURBS_END_DATA = 100175; +//public static final int GLU_NURBS_END_DATA_EXT = 100175; + +// NurbsError +//public static final int GLU_NURBS_ERROR1 = 100251; +//public static final int GLU_NURBS_ERROR2 = 100252; +//public static final int GLU_NURBS_ERROR3 = 100253; +//public static final int GLU_NURBS_ERROR4 = 100254; +//public static final int GLU_NURBS_ERROR5 = 100255; +//public static final int GLU_NURBS_ERROR6 = 100256; +//public static final int GLU_NURBS_ERROR7 = 100257; +//public static final int GLU_NURBS_ERROR8 = 100258; +//public static final int GLU_NURBS_ERROR9 = 100259; +//public static final int GLU_NURBS_ERROR10 = 100260; +//public static final int GLU_NURBS_ERROR11 = 100261; +//public static final int GLU_NURBS_ERROR12 = 100262; +//public static final int GLU_NURBS_ERROR13 = 100263; +//public static final int GLU_NURBS_ERROR14 = 100264; +//public static final int GLU_NURBS_ERROR15 = 100265; +//public static final int GLU_NURBS_ERROR16 = 100266; +//public static final int GLU_NURBS_ERROR17 = 100267; +//public static final int GLU_NURBS_ERROR18 = 100268; +//public static final int GLU_NURBS_ERROR19 = 100269; +//public static final int GLU_NURBS_ERROR20 = 100270; +//public static final int GLU_NURBS_ERROR21 = 100271; +//public static final int GLU_NURBS_ERROR22 = 100272; +//public static final int GLU_NURBS_ERROR23 = 100273; +//public static final int GLU_NURBS_ERROR24 = 100274; +//public static final int GLU_NURBS_ERROR25 = 100275; +//public static final int GLU_NURBS_ERROR26 = 100276; +//public static final int GLU_NURBS_ERROR27 = 100277; +//public static final int GLU_NURBS_ERROR28 = 100278; +//public static final int GLU_NURBS_ERROR29 = 100279; +//public static final int GLU_NURBS_ERROR30 = 100280; +//public static final int GLU_NURBS_ERROR31 = 100281; +//public static final int GLU_NURBS_ERROR32 = 100282; +//public static final int GLU_NURBS_ERROR33 = 100283; +//public static final int GLU_NURBS_ERROR34 = 100284; +//public static final int GLU_NURBS_ERROR35 = 100285; +//public static final int GLU_NURBS_ERROR36 = 100286; +//public static final int GLU_NURBS_ERROR37 = 100287; + +// NurbsProperty +//public static final int GLU_AUTO_LOAD_MATRIX = 100200; +//public static final int GLU_CULLING = 100201; +//public static final int GLU_SAMPLING_TOLERANCE = 100203; +//public static final int GLU_DISPLAY_MODE = 100204; +//public static final int GLU_PARAMETRIC_TOLERANCE = 100202; +//public static final int GLU_SAMPLING_METHOD = 100205; +//public static final int GLU_U_STEP = 100206; +//public static final int GLU_V_STEP = 100207; +//public static final int GLU_NURBS_MODE = 100160; +//public static final int GLU_NURBS_MODE_EXT = 100160; +//public static final int GLU_NURBS_TESSELLATOR = 100161; +//public static final int GLU_NURBS_TESSELLATOR_EXT = 100161; +//public static final int GLU_NURBS_RENDERER = 100162; +//public static final int GLU_NURBS_RENDERER_EXT = 100162; + +// NurbsSampling +//public static final int GLU_OBJECT_PARAMETRIC_ERROR = 100208; +//public static final int GLU_OBJECT_PARAMETRIC_ERROR_EXT = 100208; +//public static final int GLU_OBJECT_PATH_LENGTH = 100209; +//public static final int GLU_OBJECT_PATH_LENGTH_EXT = 100209; +//public static final int GLU_PATH_LENGTH = 100215; +//public static final int GLU_PARAMETRIC_ERROR = 100216; +//public static final int GLU_DOMAIN_DISTANCE = 100217; + +// NurbsTrim +//public static final int GLU_MAP1_TRIM_2 = 100210; +//public static final int GLU_MAP1_TRIM_3 = 100211; + +// QuadricCallback +// GLU_ERROR + +// TessCallback +public static final int GLU_TESS_BEGIN = 100100; +public static final int GLU_BEGIN = 100100; +public static final int GLU_TESS_VERTEX = 100101; +public static final int GLU_VERTEX = 100101; +public static final int GLU_TESS_END = 100102; +public static final int GLU_END = 100102; +public static final int GLU_TESS_ERROR = 100103; +public static final int GLU_TESS_EDGE_FLAG = 100104; +public static final int GLU_EDGE_FLAG = 100104; +public static final int GLU_TESS_COMBINE = 100105; +public static final int GLU_TESS_BEGIN_DATA = 100106; +public static final int GLU_TESS_VERTEX_DATA = 100107; +public static final int GLU_TESS_END_DATA = 100108; +public static final int GLU_TESS_ERROR_DATA = 100109; +public static final int GLU_TESS_EDGE_FLAG_DATA = 100110; +public static final int GLU_TESS_COMBINE_DATA = 100111; + +// TessContour +public static final int GLU_CW = 100120; +public static final int GLU_CCW = 100121; +public static final int GLU_INTERIOR = 100122; +public static final int GLU_EXTERIOR = 100123; +public static final int GLU_UNKNOWN = 100124; + +// TessProperty +public static final int GLU_TESS_WINDING_RULE = 100140; +public static final int GLU_TESS_BOUNDARY_ONLY = 100141; +public static final int GLU_TESS_TOLERANCE = 100142; +// JOGL-specific boolean property, false by default, that may improve the tessellation +public static final int GLU_TESS_AVOID_DEGENERATE_TRIANGLES = 100149; + +// TessError +public static final int GLU_TESS_ERROR1 = 100151; +public static final int GLU_TESS_ERROR2 = 100152; +public static final int GLU_TESS_ERROR3 = 100153; +public static final int GLU_TESS_ERROR4 = 100154; +public static final int GLU_TESS_ERROR5 = 100155; +public static final int GLU_TESS_ERROR6 = 100156; +public static final int GLU_TESS_ERROR7 = 100157; +public static final int GLU_TESS_ERROR8 = 100158; +public static final int GLU_TESS_MISSING_BEGIN_POLYGON = 100151; +public static final int GLU_TESS_MISSING_BEGIN_CONTOUR = 100152; +public static final int GLU_TESS_MISSING_END_POLYGON = 100153; +public static final int GLU_TESS_MISSING_END_CONTOUR = 100154; +public static final int GLU_TESS_COORD_TOO_LARGE = 100155; +public static final int GLU_TESS_NEED_COMBINE_CALLBACK = 100156; + +// TessWinding +public static final int GLU_TESS_WINDING_ODD = 100130; +public static final int GLU_TESS_WINDING_NONZERO = 100131; +public static final int GLU_TESS_WINDING_POSITIVE = 100132; +public static final int GLU_TESS_WINDING_NEGATIVE = 100133; +public static final int GLU_TESS_WINDING_ABS_GEQ_TWO = 100134; +public static final double GLU_TESS_MAX_COORD = 1.0e150; + +//---------------------------------------------------------------------- +// Quadric functionality +// + +protected static boolean availableGLUquadricImpl = false; +protected static boolean checkedGLUquadricImpl = false; +protected static volatile Object syncObject = new Object(); + +/** + * Optional, throws GLException if not available in profile + */ +protected static final void validateGLUquadricImpl() { + if(!checkedGLUquadricImpl) { + synchronized (syncObject) { + if(!checkedGLUquadricImpl) { + availableGLUquadricImpl = NWReflection.isClassAvailable("com.sun.opengl.impl.glu.GLUquadricImpl"); + checkedGLUquadricImpl = true; + } + } + } + if(!availableGLUquadricImpl) { + throw new GLException("GLUquadric not available (GLUquadricImpl)"); + } +} + + +/** Option (throws GLException if not available in profile).
Interface to C language function:
void gluCylinder(GLUquadric * quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks); */ +public final void gluCylinder(GLUquadric quad, double base, double top, double height, int slices, int stacks) { + validateGLUquadricImpl(); + ((GLUquadricImpl) quad).drawCylinder(getCurrentGL(), (float) base, (float) top, (float) height, slices, stacks); +} + +/** Option (throws GLException if not available in profile).
Interface to C language function:
void gluDeleteQuadric(GLUquadric * quad); */ +public final void gluDeleteQuadric(GLUquadric quad) { + validateGLUquadricImpl(); +} + +/** Option (throws GLException if not available in profile).
Interface to C language function:
void gluDisk(GLUquadric * quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops); */ +public final void gluDisk(GLUquadric quad, double inner, double outer, int slices, int loops) { + validateGLUquadricImpl(); + ((GLUquadricImpl) quad).drawDisk(getCurrentGL(), (float) inner, (float) outer, slices, loops); +} + +/** Option (throws GLException if not available in profile).
Interface to C language function:
GLUquadric * gluNewQuadric(void); */ +public final GLUquadric gluNewQuadric() { + return gluNewQuadric(false); +} + +public final GLUquadric gluNewQuadric(boolean useGLSL) { + GL gl = getCurrentGL(); + if(useGLSL && !gl.isGL2ES2()) { + throw new GLException("GLUquadric GLSL implementation not supported for profile: "+gl); + } + validateGLUquadricImpl(); + return new GLUquadricImpl(gl, useGLSL); +} + +/** Option (throws GLException if not available in profile).
Interface to C language function:
void gluPartialDisk(GLUquadric * quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep); */ +public final void gluPartialDisk(GLUquadric quad, double inner, double outer, int slices, int loops, double start, double sweep) { + validateGLUquadricImpl(); + ((GLUquadricImpl) quad).drawPartialDisk(getCurrentGL(), (float) inner, (float) outer, slices, loops, (float) start, (float) sweep); +} + +/** Option (throws GLException if not available in profile).
Interface to C language function:
void gluQuadricDrawStyle(GLUquadric * quad, GLenum draw); */ +public final void gluQuadricDrawStyle(GLUquadric quad, int draw) { + validateGLUquadricImpl(); + ((GLUquadricImpl) quad).setDrawStyle(draw); +} + +/** Option (throws GLException if not available in profile).
Interface to C language function:
void gluQuadricNormals(GLUquadric * quad, GLenum normal); */ +public final void gluQuadricNormals(GLUquadric quad, int normal) { + validateGLUquadricImpl(); + ((GLUquadricImpl) quad).setNormals(normal); +} + +/** Option (throws GLException if not available in profile).
Interface to C language function:
void gluQuadricOrientation(GLUquadric * quad, GLenum orientation); */ +public final void gluQuadricOrientation(GLUquadric quad, int orientation) { + validateGLUquadricImpl(); + ((GLUquadricImpl) quad).setOrientation(orientation); +} + +/** Option (throws GLException if not available in profile).
Interface to C language function:
void gluQuadricTexture(GLUquadric * quad, GLboolean texture); */ +public final void gluQuadricTexture(GLUquadric quad, boolean texture) { + validateGLUquadricImpl(); + ((GLUquadricImpl) quad).setTextureFlag(texture); +} + +/** Option (throws GLException if not available in profile).
Interface to C language function:
void gluSphere(GLUquadric * quad, GLdouble radius, GLint slices, GLint stacks); */ +public final void gluSphere(GLUquadric quad, double radius, int slices, int stacks) { + validateGLUquadricImpl(); + ((GLUquadricImpl) quad).drawSphere(getCurrentGL(), (float) radius, slices, stacks); +} + +//---------------------------------------------------------------------- +// Projection routines +// + +private ProjectFloat project; + +public void gluOrtho2D(float left, float right, float bottom, float top) { + project.gluOrtho2D(getCurrentGL().getGL2ES1(), left, right, bottom, top); +} + +public void gluPerspective(float fovy, float aspect, float zNear, float zFar) { + project.gluPerspective(getCurrentGL().getGL2ES1(), fovy, aspect, zNear, zFar); +} + +public void gluLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ) { + project.gluLookAt(getCurrentGL().getGL2ES1(), eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ); +} + +/** Interface to C language function:
GLint gluProject(GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble * model, const GLdouble * proj, const GLint * view, GLdouble * winX, GLdouble * winY, GLdouble * winZ); + *

Accepts the outgoing window coordinates as a single array. + */ +public boolean gluProject(float objX, float objY, float objZ, float[] model, int model_offset, float[] proj, int proj_offset, int[] view, int view_offset, float[] winPos, int winPos_offset) { + return project.gluProject(objX, objY, objZ, model, model_offset, proj, proj_offset, view, view_offset, winPos, winPos_offset); +} + +/** Interface to C language function:
GLint gluProject(GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble * model, const GLdouble * proj, const GLint * view, GLdouble * winX, GLdouble * winY, GLdouble * winZ); + *

Accepts the outgoing window coordinates as a single buffer. + */ +public boolean gluProject(float objX, float objY, float objZ, java.nio.FloatBuffer model, java.nio.FloatBuffer proj, java.nio.IntBuffer view, java.nio.FloatBuffer winPos) { + return project.gluProject(objX, objY, objZ, model, proj, view, winPos); +} + +/** Interface to C language function:
GLint gluUnProject(GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble * model, const GLdouble * proj, const GLint * view, GLdouble * objX, GLdouble * objY, GLdouble * objZ); + *

Accepts the outgoing object coordinates (a 3-vector) as a single array. + */ +public boolean gluUnProject(float winX, float winY, float winZ, float[] model, int model_offset, float[] proj, int proj_offset, int[] view, int view_offset, float[] objPos, int objPos_offset) { + return project.gluUnProject(winX, winY, winZ, model, model_offset, proj, proj_offset, view, view_offset, objPos, objPos_offset); +} + +/** Interface to C language function:
GLint gluUnProject(GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble * model, const GLdouble * proj, const GLint * view, GLdouble * objX, GLdouble * objY, GLdouble * objZ); + *

Accepts the outgoing object coordinates (a 3-vector) as a single buffer. + */ +public boolean gluUnProject(float winX, float winY, float winZ, java.nio.FloatBuffer model, java.nio.FloatBuffer proj, java.nio.IntBuffer view, java.nio.FloatBuffer objPos) { + return project.gluUnProject(winX, winY, winZ, model, proj, view, objPos); +} + +/** Interface to C language function:
GLint gluUnProject4(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble * model, const GLdouble * proj, const GLint * view, GLdouble nearVal, GLdouble farVal, GLdouble * objX, GLdouble * objY, GLdouble * objZ, GLdouble * objW); + *

Accepts the outgoing object coordinates (a 4-vector) as a single array. + */ +public boolean gluUnProject4(float winX, float winY, float winZ, float clipW, float[] model, int model_offset, float[] proj, int proj_offset, int[] view, int view_offset, float nearVal, float farVal, float[] objPos, int objPos_offset) { + return project.gluUnProject4(winX, winY, winZ, clipW, model, model_offset, proj, proj_offset, view, view_offset, nearVal, farVal, objPos, objPos_offset); +} + +/** Interface to C language function:
GLint gluUnProject4(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble * model, const GLdouble * proj, const GLint * view, GLdouble nearVal, GLdouble farVal, GLdouble * objX, GLdouble * objY, GLdouble * objZ, GLdouble * objW); + *

Accepts the outgoing object coordinates (a 4-vector) as a single buffer. + */ +public boolean gluUnProject4(float winX, float winY, float winZ, float clipW, java.nio.FloatBuffer model, java.nio.FloatBuffer proj, java.nio.IntBuffer view, float nearVal, float farVal, java.nio.FloatBuffer objPos) { + return project.gluUnProject4(winX, winY, winZ, clipW, model, proj, view, nearVal, farVal, objPos); +} + +public void gluPickMatrix(float x, float y, float delX, float delY, int[] viewport, int viewport_offset) { + project.gluPickMatrix(getCurrentGL().getGL2ES1(), x, y, delX, delY, viewport, viewport_offset); +} + +public void gluPickMatrix(float x, float y, float delX, float delY, java.nio.IntBuffer viewport) { + project.gluPickMatrix(getCurrentGL().getGL2ES1(), x, y, delX, delY, viewport); +} + +public void gluOrtho2D(double left, double right, double bottom, double top) { + project.gluOrtho2D(getCurrentGL().getGL2ES1(), (float)left, (float)right, (float)bottom, (float)top); +} + +public void gluPerspective(double fovy, double aspect, double zNear, double zFar) { + project.gluPerspective(getCurrentGL().getGL2ES1(), (float)fovy, (float)aspect, (float)zNear, (float)zFar); +} + +public void gluLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ) { + project.gluLookAt(getCurrentGL().getGL2ES1(), (float)eyeX, (float)eyeY, (float)eyeZ, (float)centerX, (float)centerY, (float)centerZ, (float)upX, (float)upY, (float)upZ); +} + +/** Interface to C language function:
GLint gluProject(GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble * model, const GLdouble * proj, const GLint * view, GLdouble * winX, GLdouble * winY, GLdouble * winZ); + *

Accepts the outgoing window coordinates as a single array. + */ +public boolean gluProject(double objX, double objY, double objZ, double[] model, int model_offset, double[] proj, int proj_offset, int[] view, int view_offset, double[] winPos, int winPos_offset) { + return project.gluProject((float)objX, (float)objY, (float)objZ, InternalBufferUtil.getFloatArray(model), model_offset, InternalBufferUtil.getFloatArray(proj), proj_offset, view, view_offset, InternalBufferUtil.getFloatArray(winPos), winPos_offset); +} + +/** Interface to C language function:
GLint gluUnProject(GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble * model, const GLdouble * proj, const GLint * view, GLdouble * objX, GLdouble * objY, GLdouble * objZ); + *

Accepts the outgoing object coordinates (a 3-vector) as a single array. + */ +public boolean gluUnProject(double winX, double winY, double winZ, double[] model, int model_offset, double[] proj, int proj_offset, int[] view, int view_offset, double[] objPos, int objPos_offset) { + return project.gluUnProject((float)winX, (float)winY, (float)winZ, InternalBufferUtil.getFloatArray(model), model_offset, InternalBufferUtil.getFloatArray(proj), proj_offset, view, view_offset, InternalBufferUtil.getFloatArray(objPos), objPos_offset); +} + +/** Interface to C language function:
GLint gluUnProject4(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble * model, const GLdouble * proj, const GLint * view, GLdouble nearVal, GLdouble farVal, GLdouble * objX, GLdouble * objY, GLdouble * objZ, GLdouble * objW); + *

Accepts the outgoing object coordinates (a 4-vector) as a single array. + */ +public boolean gluUnProject4(double winX, double winY, double winZ, double clipW, double[] model, int model_offset, double[] proj, int proj_offset, int[] view, int view_offset, double nearVal, double farVal, double[] objPos, int objPos_offset) { + return project.gluUnProject4((float)winX, (float)winY, (float)winZ, (float)clipW, InternalBufferUtil.getFloatArray(model), model_offset, InternalBufferUtil.getFloatArray(proj), proj_offset, view, view_offset, (float)nearVal, (float)farVal, InternalBufferUtil.getFloatArray(objPos), objPos_offset); +} + +public void gluPickMatrix(double x, double y, double delX, double delY, int[] viewport, int viewport_offset) { + project.gluPickMatrix(getCurrentGL().getGL2ES1(), (float)x, (float)y, (float)delX, (float)delY, viewport, viewport_offset); +} + +public void gluPickMatrix(double x, double y, double delX, double delY, IntBuffer viewport) { + project.gluPickMatrix(getCurrentGL().getGL2ES1(), (float)x, (float)y, (float)delX, (float)delY, viewport); +} + +/** + * Optional, throws GLException if not available in profile + */ +public int gluScaleImage( int format, int widthin, int heightin, + int typein, java.nio.Buffer datain, int widthout, int heightout, + int typeout, java.nio.Buffer dataout ) { + throw new GLException("not implemented"); +} + +/** + * Optional, throws GLException if not available in profile + */ +public int gluBuild1DMipmapLevels( int target, int internalFormat, int width, + int format, int type, int userLevel, int baseLevel, int maxLevel, + java.nio.Buffer data ) { + throw new GLException("not implemented"); +} +/** + * Optional, throws GLException if not available in profile + */ +public int gluBuild1DMipmaps( int target, int internalFormat, int width, + int format, int type, java.nio.Buffer data ) { + throw new GLException("not implemented"); +} + +/** + * Optional, throws GLException if not available in profile + */ +public int gluBuild2DMipmapLevels( int target, int internalFormat, int width, + int height, int format, int type, int userLevel, int baseLevel, + int maxLevel, java.nio.Buffer data ) { + throw new GLException("not implemented"); +} + +/** + * Optional, throws GLException if not available in profile + */ +public int gluBuild2DMipmaps( int target, int internalFormat, int width, + int height, int format, int type, java.nio.Buffer data ) { + throw new GLException("not implemented"); +} + +/** + * Optional, throws GLException if not available in profile + */ +public int gluBuild3DMipmapLevels( int target, int internalFormat, int width, + int height, int depth, int format, int type, int userLevel, int baseLevel, + int maxLevel, java.nio.Buffer data) { + throw new GLException("not implemented"); +} + +/** + * Optional, throws GLException if not available in profile + */ +public int gluBuild3DMipmaps( int target, int internalFormat, int width, + int height, int depth, int format, int type, java.nio.Buffer data ) { + throw new GLException("not implemented"); +} + -- cgit v1.2.3