private static boolean useJavaMipmapCode = true; static { AccessController.doPrivileged(new PrivilegedAction() { public Object run() { String val = System.getProperty("jogl.glu.nojava"); if (val != null && !val.toLowerCase().equals("false")) { useJavaMipmapCode = false; } return null; } }); } /** * Instantiates a new OpenGL Utility Library object. A GLU object may * be instantiated at any point in the application and is not * inherently tied to any particular OpenGL context; however, the GLU * object may only be used when an OpenGL context is current on the * current thread. Attempts to call most of the methods in the GLU * library when no OpenGL context is current will cause an exception * to be thrown. * *
* * The returned GLU object is not guaranteed to be thread-safe and * should only be used from one thread at a time. Multiple GLU objects * may be instantiated to be used from different threads * simultaneously. */ public GLU() { this.project = new Project(); } //---------------------------------------------------------------------- // Utility routines // /** * Returns the GL object associated with the OpenGL context current on * the current thread. Throws GLException if no OpenGL context is * current. */ public static 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 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 boolean gluCheckExtension(java.lang.String extName, java.lang.String extString) { return Registry.gluCheckExtension(extName, extString); } public String gluGetString(int name) { return Registry.gluGetString(name); } /** * 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: *
gluGetString(GLU_VERSION)
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.
*
* gluGetString(GLU_EXTENSIONS)
to see if the function is one of
* the extensions that is supported by the underlying GLU implementation.
* glGetString(GL_VERSION)
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.
*
* gluGetString(GLU_EXTENSIONS)
to see if the function is one of
* the extensions that is supported by the underlying GLU implementation.
*
* 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);
}
//----------------------------------------------------------------------
// Tessellation routines
//
/*****************************************************************************
* 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.
*
* @return A new tessellation object.
*
* @see #gluTessBeginPolygon gluTessBeginPolygon
* @see #gluDeleteTess gluDeleteTess
* @see #gluTessCallback gluTessCallback
****************************************************************************/
public GLUtessellator gluNewTess() {
return GLUtessellatorImpl.gluNewTess();
}
/*****************************************************************************
* gluDeleteTess destroys the indicated tessellation object (which was
* created with {@link #gluNewTess gluNewTess}).
*
* @param tessellator
* Specifies the tessellation object to destroy.
*
* @see #gluBeginPolygon gluBeginPolygon
* @see #gluNewTess gluNewTess
* @see #gluTessCallback gluTessCallback
****************************************************************************/
public void gluDeleteTess(GLUtessellator tessellator) {
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:* * GLU_TESS_WINDING_RULE *
* * 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. *
* * 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. *
* * 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. * * @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 void gluTessNormal(GLUtessellator tessellator, double x, double y, double z) { 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.
* * 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 *
* * 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);* * 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);* *
* * 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: *
* 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; * }* *
* void combineData(double[] coords, Object[] data, float[] weight, Object[] outData, Object polygonData);* * GLU_TESS_ERROR *
* void error(int errnum);* *
* 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 void gluTessCallback(GLUtessellator tessellator, int which, GLUtessellatorCallback aCallback) { 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}.
* * 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 void gluTessVertex(GLUtessellator tessellator, double[] coords, int coords_offset, Object data) { 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.
* * 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 void gluTessBeginPolygon(GLUtessellator tessellator, Object data) { 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}. * * @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 void gluTessBeginContour(GLUtessellator tessellator) { 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}. * * @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 void gluTessEndContour(GLUtessellator tessellator) { 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.
* * 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 void gluTessEndPolygon(GLUtessellator tessellator) { 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.
* * 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 void gluBeginPolygon(GLUtessellator tessellator) { 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.
* * The type parameter defines what type of contour follows. The following * values are valid.
* * GLU_EXTERIOR *
* * 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.
* *
*
* 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 void gluEndPolygon(GLUtessellator tessellator) {
GLUtessellatorImpl tess = (GLUtessellatorImpl) tessellator;
tess.gluEndPolygon();
}
//----------------------------------------------------------------------
// Quadric functionality
//
/** Interface to C language function:
void gluCylinder(GLUquadric * quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks);
*/
public void gluCylinder(GLUquadric quad, double base, double top, double height, int slices, int stacks) {
((GLUquadricImpl) quad).drawCylinder(getCurrentGL(), (float) base, (float) top, (float) height, slices, stacks);
}
/** Interface to C language function:
void gluDeleteQuadric(GLUquadric * quad);
*/
public void gluDeleteQuadric(GLUquadric quad) {
}
/** Interface to C language function:
void gluDisk(GLUquadric * quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops);
*/
public void gluDisk(GLUquadric quad, double inner, double outer, int slices, int loops) {
((GLUquadricImpl) quad).drawDisk(getCurrentGL(), (float) inner, (float) outer, slices, loops);
}
/** Interface to C language function:
GLUquadric * gluNewQuadric(void);
*/
public GLUquadric gluNewQuadric() {
return new GLUquadricImpl();
}
/** Interface to C language function:
void gluPartialDisk(GLUquadric * quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep);
*/
public void gluPartialDisk(GLUquadric quad, double inner, double outer, int slices, int loops, double start, double sweep) {
((GLUquadricImpl) quad).drawPartialDisk(getCurrentGL(), (float) inner, (float) outer, slices, loops, (float) start, (float) sweep);
}
/** Interface to C language function:
void gluQuadricDrawStyle(GLUquadric * quad, GLenum draw);
*/
public void gluQuadricDrawStyle(GLUquadric quad, int draw) {
((GLUquadricImpl) quad).setDrawStyle(draw);
}
/** Interface to C language function:
void gluQuadricNormals(GLUquadric * quad, GLenum normal);
*/
public void gluQuadricNormals(GLUquadric quad, int normal) {
((GLUquadricImpl) quad).setNormals(normal);
}
/** Interface to C language function:
void gluQuadricOrientation(GLUquadric * quad, GLenum orientation);
*/
public void gluQuadricOrientation(GLUquadric quad, int orientation) {
((GLUquadricImpl) quad).setOrientation(orientation);
}
/** Interface to C language function:
void gluQuadricTexture(GLUquadric * quad, GLboolean texture);
*/
public void gluQuadricTexture(GLUquadric quad, boolean texture) {
((GLUquadricImpl) quad).setTextureFlag(texture);
}
/** Interface to C language function:
void gluSphere(GLUquadric * quad, GLdouble radius, GLint slices, GLint stacks);
*/
public void gluSphere(GLUquadric quad, double radius, int slices, int stacks) {
((GLUquadricImpl) quad).drawSphere(getCurrentGL(), (float) radius, slices, stacks);
}
//----------------------------------------------------------------------
// Projection routines
//
private Project project;
public void gluOrtho2D(double left, double right, double bottom, double top) {
project.gluOrtho2D(getCurrentGL(), left, right, bottom, top);
}
public void gluPerspective(double fovy, double aspect, double zNear, double zFar) {
project.gluPerspective(getCurrentGL(), fovy, aspect, zNear, zFar);
}
public void gluLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ) {
project.gluLookAt(getCurrentGL(), 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);
*/
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[] winX, int winX_offset, double[] winY, int winY_offset, double[] winZ, int winZ_offset) {
double[] tmp = new double[3];
boolean res = project.gluProject(objX, objY, objZ, model, model_offset, proj, proj_offset, view, view_offset, tmp, 0);
winX[winX_offset] = tmp[0];
winY[winY_offset] = tmp[1];
winZ[winZ_offset] = tmp[2];
return res;
}
/** 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);
*/
public boolean gluProject(double objX, double objY, double objZ, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, DoubleBuffer winX, DoubleBuffer winY, DoubleBuffer winZ) {
DoubleBuffer tmp = BufferUtils.newDoubleBuffer(3);
boolean res = project.gluProject(objX, objY, objZ, model, proj, view, tmp);
winX.put(winX.position(), tmp.get(0));
winY.put(winY.position(), tmp.get(1));
winZ.put(winZ.position(), tmp.get(2));
return res;
}
/**
* Convenience routine for gluProject that 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(objX, objY, objZ, model, model_offset, proj, proj_offset, view, view_offset, winPos, winPos_offset);
}
/**
* Convenience routine for gluProject that accepts the outgoing window
* coordinates as a single buffer.
*/
public boolean gluProject(double objX, double objY, double objZ, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, DoubleBuffer 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);
*/
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[] objX, int objX_offset, double[] objY, int objY_offset, double[] objZ, int objZ_offset) {
double[] tmp = new double[3];
boolean res = project.gluUnProject(winX, winY, winZ, model, model_offset, proj, proj_offset, view, view_offset, tmp, 0);
objX[objX_offset] = tmp[0];
objY[objY_offset] = tmp[1];
objZ[objZ_offset] = tmp[2];
return res;
}
/** 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);
*/
public boolean gluUnProject(double winX, double winY, double winZ, DoubleBuffer model, int model_offset, DoubleBuffer proj, IntBuffer view, DoubleBuffer objX, DoubleBuffer objY, DoubleBuffer objZ) {
DoubleBuffer tmp = BufferUtils.newDoubleBuffer(3);
boolean res = project.gluUnProject(winX, winY, winZ, model, proj, view, tmp);
objX.put(objX.position(), tmp.get(0));
objY.put(objY.position(), tmp.get(1));
objZ.put(objZ.position(), tmp.get(2));
return res;
}
/**
* Convenience routine for gluUnProject that 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(winX, winY, winZ, model, model_offset, proj, proj_offset, view, view_offset, objPos, objPos_offset);
}
/**
* Convenience routine for gluUnProject that accepts the outgoing
* object coordinates (a 3-vector) as a single buffer.
*/
public boolean gluUnProject(double winX, double winY, double winZ, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, DoubleBuffer 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);
*/
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[] objX, int objX_offset, double[] objY, int objY_offset, double[] objZ, int objZ_offset, double[] objW, int objW_offset) {
double[] tmp = new double[4];
boolean res = project.gluUnProject4(winX, winY, winZ, clipW, model, model_offset, proj, proj_offset,
view, view_offset, nearVal, farVal, tmp, 0);
objX[objX_offset] = tmp[0];
objY[objY_offset] = tmp[1];
objZ[objZ_offset] = tmp[2];
objW[objW_offset] = tmp[3];
return res;
}
/** 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);
*/
public boolean gluUnProject4(double winX, double winY, double winZ, double clipW, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, double nearVal, double farVal, DoubleBuffer objX, DoubleBuffer objY, DoubleBuffer objZ, DoubleBuffer objW) {
DoubleBuffer tmp = BufferUtils.newDoubleBuffer(4);
boolean res = project.gluUnProject4(winX, winY, winZ, clipW, model, proj,
view, nearVal, farVal, tmp);
objX.put(objX.position(), tmp.get(0));
objY.put(objY.position(), tmp.get(1));
objZ.put(objZ.position(), tmp.get(2));
objW.put(objW.position(), tmp.get(3));
return res;
}
/**
* Convenience routine for gluUnProject4 that 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(winX, winY, winZ, clipW, model, model_offset, proj, proj_offset, view, view_offset, nearVal, farVal, objPos, objPos_offset);
}
/**
* Convenience routine for gluUnProject4 that accepts the outgoing
* object coordinates (a 4-vector) as a single buffer.
*/
public boolean gluUnProject4(double winX, double winY, double winZ, double clipW, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, double nearVal, double farVal, DoubleBuffer objPos) {
return project.gluUnProject4(winX, winY, winZ, clipW, model, proj, view, nearVal, farVal, objPos);
}
public void gluPickMatrix(double x, double y, double delX, double delY, int[] viewport, int viewport_offset) {
project.gluPickMatrix(getCurrentGL(), x, y, delX, delY, viewport, viewport_offset);
}
public void gluPickMatrix(double x, double y, double delX, double delY, IntBuffer viewport) {
project.gluPickMatrix(getCurrentGL(), x, y, delX, delY, viewport);
}
//----------------------------------------------------------------------
// Mipmap and image scaling functionality
// 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;
// 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;
// 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;
// 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;
// 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;
private ByteBuffer copyToByteBuffer(Buffer buf) {
if (buf instanceof ByteBuffer) {
if (buf.position() == 0) {
return (ByteBuffer) buf;
}
return BufferUtils.copyByteBuffer((ByteBuffer) buf);
} else if (buf instanceof ShortBuffer) {
return BufferUtils.copyShortBufferAsByteBuffer((ShortBuffer) buf);
} else if (buf instanceof IntBuffer) {
return BufferUtils.copyIntBufferAsByteBuffer((IntBuffer) buf);
} else if (buf instanceof FloatBuffer) {
return BufferUtils.copyFloatBufferAsByteBuffer((FloatBuffer) buf);
} else {
throw new IllegalArgumentException("Unsupported buffer type (must be one of byte, short, int, or float)");
}
}
private int gluScaleImageJava( int format, int widthin, int heightin,
int typein, Buffer datain, int widthout, int heightout,
int typeout, Buffer dataout ) {
ByteBuffer in = null;
ByteBuffer out = null;
in = copyToByteBuffer(datain);
if( dataout instanceof ByteBuffer ) {
out = (ByteBuffer)dataout;
} else if( dataout instanceof ShortBuffer ) {
out = BufferUtils.newByteBuffer(dataout.remaining() * BufferUtils.SIZEOF_SHORT);
} else if ( dataout instanceof IntBuffer ) {
out = BufferUtils.newByteBuffer(dataout.remaining() * BufferUtils.SIZEOF_INT);
} else if ( dataout instanceof FloatBuffer ) {
out = BufferUtils.newByteBuffer(dataout.remaining() * BufferUtils.SIZEOF_FLOAT);
} else {
throw new IllegalArgumentException("Unsupported destination buffer type (must be byte, short, int, or float)");
}
int errno = Mipmap.gluScaleImage( getCurrentGL(), format, widthin, heightin, typein, in,
widthout, heightout, typeout, out );
if( errno == 0 ) {
out.rewind();
if( dataout instanceof ShortBuffer ) {
((ShortBuffer) dataout).put(out.asShortBuffer());
} else if( dataout instanceof IntBuffer ) {
((IntBuffer) dataout).put(out.asIntBuffer());
} else if( dataout instanceof FloatBuffer ) {
((FloatBuffer) dataout).put(out.asFloatBuffer());
} else {
throw new RuntimeException("Should not reach here");
}
}
return( errno );
}
private int gluBuild1DMipmapLevelsJava( int target, int internalFormat, int width,
int format, int type, int userLevel, int baseLevel, int maxLevel,
Buffer data ) {
ByteBuffer buffer = copyToByteBuffer(data);
return( Mipmap.gluBuild1DMipmapLevels( getCurrentGL(), target, internalFormat, width,
format, type, userLevel, baseLevel, maxLevel, buffer ) );
}
private int gluBuild1DMipmapsJava( int target, int internalFormat, int width,
int format, int type, Buffer data ) {
ByteBuffer buffer = copyToByteBuffer(data);
return( Mipmap.gluBuild1DMipmaps( getCurrentGL(), target, internalFormat, width, format,
type, buffer ) );
}
private int gluBuild2DMipmapLevelsJava( int target, int internalFormat, int width,
int height, int format, int type, int userLevel, int baseLevel,
int maxLevel, Buffer data ) {
// While the code below handles other data types, it doesn't handle non-ByteBuffers
data = copyToByteBuffer(data);
return( Mipmap.gluBuild2DMipmapLevels( getCurrentGL(), target, internalFormat, width,
height, format, type, userLevel, baseLevel, maxLevel, data ) );
}
private int gluBuild2DMipmapsJava( int target, int internalFormat, int width,
int height, int format, int type, Buffer data ) {
// While the code below handles other data types, it doesn't handle non-ByteBuffers
data = copyToByteBuffer(data);
return( Mipmap.gluBuild2DMipmaps( getCurrentGL(), target, internalFormat, width, height,
format, type, data) );
}
private int gluBuild3DMipmapLevelsJava( int target, int internalFormat, int width,
int height, int depth, int format, int type, int userLevel, int baseLevel,
int maxLevel, Buffer data) {
ByteBuffer buffer = copyToByteBuffer(data);
return( Mipmap.gluBuild3DMipmapLevels( getCurrentGL(), target, internalFormat, width,
height, depth, format, type, userLevel, baseLevel, maxLevel, buffer) );
}
private int gluBuild3DMipmapsJava( int target, int internalFormat, int width,
int height, int depth, int format, int type, Buffer data ) {
ByteBuffer buffer = copyToByteBuffer(data);
return( Mipmap.gluBuild3DMipmaps( getCurrentGL(), target, internalFormat, width, height,
depth, format, type, buffer ) );
}
//----------------------------------------------------------------------
// Wrappers for mipmap and image scaling entry points which dispatch either
// to the Java or C versions.
//
/** Interface to C language function:
GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data);
*/
public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, java.nio.Buffer data) {
if (useJavaMipmapCode) {
return gluBuild1DMipmapLevelsJava(target, internalFormat, width, format, type, level, base, max, data);
} else {
return gluBuild1DMipmapLevelsC(target, internalFormat, width, format, type, level, base, max, data);
}
}
/** Interface to C language function:
GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data);
*/
public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, java.nio.Buffer data) {
if (useJavaMipmapCode) {
return gluBuild1DMipmapsJava(target, internalFormat, width, format, type, data);
} else {
return gluBuild1DMipmapsC(target, internalFormat, width, format, type, data);
}
}
/** Interface to C language function:
GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data);
*/
public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, java.nio.Buffer data) {
if (useJavaMipmapCode) {
return gluBuild2DMipmapLevelsJava(target, internalFormat, width, height, format, type, level, base, max, data);
} else {
return gluBuild2DMipmapLevelsC(target, internalFormat, width, height, format, type, level, base, max, data);
}
}
/** Interface to C language function:
GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data);
*/
public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, java.nio.Buffer data) {
if (useJavaMipmapCode) {
return gluBuild2DMipmapsJava(target, internalFormat, width, height, format, type, data);
} else {
return gluBuild2DMipmapsC(target, internalFormat, width, height, format, type, data);
}
}
/** Interface to C language function:
GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data);
*/
public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, java.nio.Buffer data) {
if (useJavaMipmapCode) {
return gluBuild3DMipmapLevelsJava(target, internalFormat, width, height, depth, format, type, level, base, max, data);
} else {
return gluBuild3DMipmapLevelsC(target, internalFormat, width, height, depth, format, type, level, base, max, data);
}
}
/** Interface to C language function:
GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data);
*/
public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, java.nio.Buffer data) {
if (useJavaMipmapCode) {
return gluBuild3DMipmapsJava(target, internalFormat, width, height, depth, format, type, data);
} else {
return gluBuild3DMipmapsC(target, internalFormat, width, height, depth, format, type, data);
}
}
/** Interface to C language function:
GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut);
*/
public int gluScaleImage(int format, int wIn, int hIn, int typeIn, java.nio.Buffer dataIn, int wOut, int hOut, int typeOut, java.nio.Buffer dataOut) {
if (useJavaMipmapCode) {
return gluScaleImageJava(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut);
} else {
return gluScaleImageC(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut);
}
}
//----------------------------------------------------------------------
// GLUProcAddressTable handling
//
private static GLUProcAddressTable gluProcAddressTable;
private static GLUProcAddressTable getGLUProcAddressTable() {
if (gluProcAddressTable == null) {
GLUProcAddressTable tmp = new GLUProcAddressTable();
GLDrawableFactoryImpl.getFactoryImpl().resetProcAddressTable(tmp);
gluProcAddressTable = tmp;
}
return gluProcAddressTable;
}