|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object javax.media.opengl.glu.GLU
public class GLU
Provides access to the OpenGL Utility Library (GLU). This library provides standard methods for setting up view volumes, building mipmaps and performing other common operations. The GLU NURBS routines are not currently exposed.
Notes from the Reference Implementation for this class: Thanks to the contributions of many individuals, this class is a pure Java port of SGI's original C sources. All of the projection, mipmap, scaling, and tessellation routines that are exposed are compatible with the GLU 1.3 specification. The GLU NURBS routines are not currently exposed.
Constructor Summary | |
---|---|
GLU()
|
Method Summary | |
---|---|
static GLU |
createGLU()
Instantiates a GLU implementation object in respect to the given GL profile of this thread current GL. |
static GLU |
createGLU(GL gl)
Instantiates a GLU implementation object in respect to the given GL profile of the given GL. |
void |
destroy()
|
static GL |
getCurrentGL()
|
static void |
gluBeginPolygon(GLUtessellator tessellator)
gluBeginPolygon and gluEndPolygon
delimit the definition of a nonconvex polygon. |
int |
gluBuild1DMipmapLevels(int target,
int internalFormat,
int width,
int format,
int type,
int userLevel,
int baseLevel,
int maxLevel,
Buffer data)
Optional, throws GLException if not available in profile |
int |
gluBuild1DMipmaps(int target,
int internalFormat,
int width,
int format,
int type,
Buffer data)
Optional, throws GLException if not available in profile |
int |
gluBuild2DMipmapLevels(int target,
int internalFormat,
int width,
int height,
int format,
int type,
int userLevel,
int baseLevel,
int maxLevel,
Buffer data)
Optional, throws GLException if not available in profile |
int |
gluBuild2DMipmaps(int target,
int internalFormat,
int width,
int height,
int format,
int type,
Buffer data)
Optional, throws GLException if not available in profile |
int |
gluBuild3DMipmapLevels(int target,
int internalFormat,
int width,
int height,
int depth,
int format,
int type,
int userLevel,
int baseLevel,
int maxLevel,
Buffer data)
Optional, throws GLException if not available in profile |
int |
gluBuild3DMipmaps(int target,
int internalFormat,
int width,
int height,
int depth,
int format,
int type,
Buffer data)
Optional, throws GLException if not available in profile |
boolean |
gluCheckExtension(String extName,
String extString)
|
void |
gluCylinder(GLUquadric quad,
double base,
double top,
double height,
int slices,
int stacks)
Option (throws GLException if not available in profile). |
void |
gluDeleteQuadric(GLUquadric quad)
Option (throws GLException if not available in profile). |
static void |
gluDeleteTess(GLUtessellator tessellator)
gluDeleteTess destroys the indicated tessellation object (which was created with gluNewTess ). |
void |
gluDisk(GLUquadric quad,
double inner,
double outer,
int slices,
int loops)
Option (throws GLException if not available in profile). |
static void |
gluEndPolygon(GLUtessellator tessellator)
gluEndPolygon and gluBeginPolygon delimit the definition of a nonconvex polygon. |
String |
gluErrorString(int errorCode)
|
String |
gluGetString(int name)
|
static void |
gluGetTessProperty(GLUtessellator tessellator,
int which,
double[] value,
int value_offset)
gluGetTessProperty retrieves properties stored in a tessellation object. |
void |
gluLookAt(double eyeX,
double eyeY,
double eyeZ,
double centerX,
double centerY,
double centerZ,
double upX,
double upY,
double upZ)
|
void |
gluLookAt(float eyeX,
float eyeY,
float eyeZ,
float centerX,
float centerY,
float centerZ,
float upX,
float upY,
float upZ)
|
GLUquadric |
gluNewQuadric()
Option (throws GLException if not available in profile). |
GLUquadric |
gluNewQuadric(boolean useGLSL)
|
static GLUtessellator |
gluNewTess()
gluNewTess creates and returns a new tessellation object. |
static void |
gluNextContour(GLUtessellator tessellator,
int type)
gluNextContour is used to describe polygons with multiple contours. |
void |
gluOrtho2D(double left,
double right,
double bottom,
double top)
|
void |
gluOrtho2D(float left,
float right,
float bottom,
float top)
|
void |
gluPartialDisk(GLUquadric quad,
double inner,
double outer,
int slices,
int loops,
double start,
double sweep)
Option (throws GLException if not available in profile). |
void |
gluPerspective(double fovy,
double aspect,
double zNear,
double zFar)
|
void |
gluPerspective(float fovy,
float aspect,
float zNear,
float zFar)
|
void |
gluPickMatrix(double x,
double y,
double delX,
double delY,
int[] viewport,
int viewport_offset)
|
void |
gluPickMatrix(double x,
double y,
double delX,
double delY,
IntBuffer viewport)
|
void |
gluPickMatrix(float x,
float y,
float delX,
float delY,
int[] viewport,
int viewport_offset)
|
void |
gluPickMatrix(float x,
float y,
float delX,
float delY,
IntBuffer viewport)
|
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)
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); |
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)
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); |
boolean |
gluProject(float objX,
float objY,
float objZ,
FloatBuffer model,
FloatBuffer proj,
IntBuffer view,
FloatBuffer winPos)
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); |
void |
gluQuadricDrawStyle(GLUquadric quad,
int draw)
Option (throws GLException if not available in profile). |
void |
gluQuadricNormals(GLUquadric quad,
int normal)
Option (throws GLException if not available in profile). |
void |
gluQuadricOrientation(GLUquadric quad,
int orientation)
Option (throws GLException if not available in profile). |
void |
gluQuadricTexture(GLUquadric quad,
boolean texture)
Option (throws GLException if not available in profile). |
int |
gluScaleImage(int format,
int widthin,
int heightin,
int typein,
Buffer datain,
int widthout,
int heightout,
int typeout,
Buffer dataout)
Optional, throws GLException if not available in profile |
void |
gluSphere(GLUquadric quad,
double radius,
int slices,
int stacks)
Option (throws GLException if not available in profile). |
static void |
gluTessBeginContour(GLUtessellator tessellator)
gluTessBeginContour and gluTessEndContour delimit
the definition of a polygon contour. |
static void |
gluTessBeginPolygon(GLUtessellator tessellator,
Object data)
gluTessBeginPolygon and gluTessEndPolygon delimit
the definition of a convex, concave or self-intersecting polygon. |
static void |
gluTessCallback(GLUtessellator tessellator,
int which,
GLUtessellatorCallback aCallback)
gluTessCallback is used to indicate a callback to be used by a tessellation object. |
static void |
gluTessEndContour(GLUtessellator tessellator)
gluTessEndContour and gluTessBeginContour
delimit the definition of a polygon contour. |
static void |
gluTessEndPolygon(GLUtessellator tessellator)
gluTessEndPolygon and gluTessBeginPolygon
delimit the definition of a convex, concave or self-intersecting polygon. |
static void |
gluTessNormal(GLUtessellator tessellator,
double x,
double y,
double z)
gluTessNormal describes a normal for a polygon that the program is defining. |
static void |
gluTessProperty(GLUtessellator tessellator,
int which,
double value)
gluTessProperty is used to control properites stored in a tessellation object. |
static void |
gluTessVertex(GLUtessellator tessellator,
double[] coords,
int coords_offset,
Object data)
gluTessVertex describes a vertex on a polygon that the program defines. |
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)
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); |
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)
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); |
boolean |
gluUnProject(float winX,
float winY,
float winZ,
FloatBuffer model,
FloatBuffer proj,
IntBuffer view,
FloatBuffer objPos)
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); |
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)
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); |
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)
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); |
boolean |
gluUnProject4(float winX,
float winY,
float winZ,
float clipW,
FloatBuffer model,
FloatBuffer proj,
IntBuffer view,
float nearVal,
float farVal,
FloatBuffer 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); |
boolean |
isFunctionAvailable(String gluFunctionName)
Returns true if the specified GLU core- or extension-function can be successfully used through this GLU instance. |
protected static void |
validateGLUquadricImpl()
Optional, throws GLException if not available in profile |
protected static void |
validateGLUtessellatorImpl()
|
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
protected static boolean availableGLUtessellatorImpl
protected static boolean checkedGLUtessellatorImpl
public static final int GLU_FALSE
public static final int GLU_TRUE
public static final int GLU_VERSION
public static final int GLU_EXTENSIONS
public static final String versionString
public static final String extensionString
public static final int GLU_INVALID_ENUM
public static final int GLU_INVALID_VALUE
public static final int GLU_OUT_OF_MEMORY
public static final int GLU_INVALID_OPERATION
public static final int GLU_POINT
public static final int GLU_LINE
public static final int GLU_FILL
public static final int GLU_SILHOUETTE
public static final int GLU_SMOOTH
public static final int GLU_FLAT
public static final int GLU_NONE
public static final int GLU_OUTSIDE
public static final int GLU_INSIDE
public static final int GLU_ERROR
public static final int GLU_TESS_BEGIN
public static final int GLU_BEGIN
public static final int GLU_TESS_VERTEX
public static final int GLU_VERTEX
public static final int GLU_TESS_END
public static final int GLU_END
public static final int GLU_TESS_ERROR
public static final int GLU_TESS_EDGE_FLAG
public static final int GLU_EDGE_FLAG
public static final int GLU_TESS_COMBINE
public static final int GLU_TESS_BEGIN_DATA
public static final int GLU_TESS_VERTEX_DATA
public static final int GLU_TESS_END_DATA
public static final int GLU_TESS_ERROR_DATA
public static final int GLU_TESS_EDGE_FLAG_DATA
public static final int GLU_TESS_COMBINE_DATA
public static final int GLU_CW
public static final int GLU_CCW
public static final int GLU_INTERIOR
public static final int GLU_EXTERIOR
public static final int GLU_UNKNOWN
public static final int GLU_TESS_WINDING_RULE
public static final int GLU_TESS_BOUNDARY_ONLY
public static final int GLU_TESS_TOLERANCE
public static final int GLU_TESS_AVOID_DEGENERATE_TRIANGLES
public static final int GLU_TESS_ERROR1
public static final int GLU_TESS_ERROR2
public static final int GLU_TESS_ERROR3
public static final int GLU_TESS_ERROR4
public static final int GLU_TESS_ERROR5
public static final int GLU_TESS_ERROR6
public static final int GLU_TESS_ERROR7
public static final int GLU_TESS_ERROR8
public static final int GLU_TESS_MISSING_BEGIN_POLYGON
public static final int GLU_TESS_MISSING_BEGIN_CONTOUR
public static final int GLU_TESS_MISSING_END_POLYGON
public static final int GLU_TESS_MISSING_END_CONTOUR
public static final int GLU_TESS_COORD_TOO_LARGE
public static final int GLU_TESS_NEED_COMBINE_CALLBACK
public static final int GLU_TESS_WINDING_ODD
public static final int GLU_TESS_WINDING_NONZERO
public static final int GLU_TESS_WINDING_POSITIVE
public static final int GLU_TESS_WINDING_NEGATIVE
public static final int GLU_TESS_WINDING_ABS_GEQ_TWO
public static final double GLU_TESS_MAX_COORD
protected static boolean availableGLUquadricImpl
protected static boolean checkedGLUquadricImpl
protected static volatile Object syncObject
Constructor Detail |
---|
public GLU()
Method Detail |
---|
public boolean isFunctionAvailable(String gluFunctionName)
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.
GLEventListener#displayChanged(GLAutoDrawable,boolean,boolean)
.
gluFunctionName
- the name of the OpenGL function (e.g., use
"gluNurbsCallbackDataEXT" to check if the
gluNurbsCallbackDataEXT(GLUnurbs, GLvoid)
extension is available).public static final GLU createGLU() throws GLException
GLException
public static final GLU createGLU(GL gl) throws GLException
GLException
public void destroy()
public static final GL getCurrentGL() throws GLException
GLException
public final String gluErrorString(int errorCode)
public final boolean gluCheckExtension(String extName, String extString)
public final String gluGetString(int name)
protected static final void validateGLUtessellatorImpl()
public static final GLUtessellator gluNewTess()
gluTessBeginPolygon
,
gluDeleteTess
,
gluTessCallback
public static final void gluDeleteTess(GLUtessellator tessellator)
gluNewTess
).
Optional, throws GLException if not available in profile
tessellator
- Specifies the tessellation object to destroy.gluBeginPolygon
,
gluNewTess
,
gluTessCallback
public static final void gluTessProperty(GLUtessellator tessellator, int which, double value)
Optional, throws GLException if not available in profile 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.
tessellator
- Specifies the tessellation object created with
gluNewTess
which
- Specifies the property to be set. Valid values are
GLU_TESS_WINDING_RULE, GLU_TESS_BOUNDARDY_ONLY,
GLU_TESS_TOLERANCE.value
- Specifices the value of the indicated property.gluGetTessProperty
,
gluNewTess
public static final void gluGetTessProperty(GLUtessellator tessellator, int which, double[] value, int value_offset)
gluTessProperty
reference
page for information about the properties and what they do.
Optional, throws GLException if not available in profile
tessellator
- Specifies the tessellation object (created with
gluNewTess
).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.value
- Specifices an array into which the value of the named property is
written.gluNewTess
,
gluTessProperty
public static final void gluTessNormal(GLUtessellator tessellator, double x, double y, double z)
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
tessellator
- Specifies the tessellation object (created by
gluNewTess
).x
- Specifies the first component of the normal.y
- Specifies the second component of the normal.z
- Specifies the third component of the normal.gluTessBeginPolygon
,
gluTessEndPolygon
public static final void gluTessCallback(GLUtessellator tessellator, int which, GLUtessellatorCallback aCallback)
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
gluTessBeginPolygon
was called. The legal callbacks are as follows:
GLU_TESS_BEGIN
glBegin
to indicate the start of a (triangle) primitive. The method
takes a single argument of type int. If the
GLU_TESS_BOUNDARY_ONLY property is set to GL_FALSE, then
the argument is set to either GL_TRIANGLE_FAN,
GL_TRIANGLE_STRIP, or GL_TRIANGLES. If the
GLU_TESS_BOUNDARY_ONLY property is set to GL_TRUE, then the
argument will be set to GL_LINE_LOOP. The method prototype for
this callback is:
void begin(int type);
GLU_TESS_BEGIN_DATA
gluTessBeginPolygon
was called. The method prototype for this callback is:
void beginData(int type, Object polygonData);GLU_TESS_EDGE_FLAG
glEdgeFlag
. The method takes
a single boolean boundaryEdge that indicates which edges lie on the
polygon boundary. If the boundaryEdge is GL_TRUE, then each vertex
that follows begins an edge that lies on the polygon boundary, that is,
an edge that separates an interior region from an exterior one. If the
boundaryEdge is GL_FALSE, then each vertex that follows begins an
edge that lies in the polygon interior. The edge flag callback (if
defined) is invoked before the first vertex callback.Since triangle fans and triangle strips do not support edge flags, the begin callback is not called with GL_TRIANGLE_FAN or GL_TRIANGLE_STRIP if a non-null edge flag callback is provided. (If the callback is initialized to null, there is no impact on performance). Instead, the fans and strips are converted to independent triangles. The method prototype for this callback is:
void edgeFlag(boolean boundaryEdge);GLU_TESS_EDGE_FLAG_DATA
gluTessBeginPolygon
was called. The method prototype for this callback is:
void edgeFlagData(boolean boundaryEdge, Object polygonData);GLU_TESS_VERTEX
glVertex3f
, and it
defines the vertices of the triangles created by the tessellation
process. The method takes a reference as its only argument. This
reference is identical to the opaque reference provided by the user when
the vertex was described (see
gluTessVertex
). The method
prototype for this callback is:
void vertex(Object vertexData);GLU_TESS_VERTEX_DATA
gluTessBeginPolygon
was called. The method prototype for this callback is:
void vertexData(Object vertexData, Object polygonData);GLU_TESS_END
glEnd
. It indicates the end of a
primitive and it takes no arguments. The method prototype for this
callback is:
void end();GLU_TESS_END_DATA
gluTessBeginPolygon
was called. The method prototype for this callback is:
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
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; }
gluTessBeginPolygon
was called. The method prototype for this callback is:
void combineData(double[] coords, Object[] data, float[] weight, Object[] outData, Object polygonData);GLU_TESS_ERROR
gluErrorString
call. The
method prototype for this callback is:
void error(int errnum);
gluTessBeginPolygon
was called. The method prototype for this callback is:
void errorData(int errnum, Object polygonData);
tessellator
- Specifies the tessellation object (created with
gluNewTess
).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.aCallback
- Specifies the callback object to be called.glBegin
,
glEdgeFlag
,
glVertex3f
,
gluNewTess
,
gluErrorString
,
gluTessVertex
,
gluTessBeginPolygon
,
gluTessBeginContour
,
gluTessProperty
,
gluTessNormal
public static final void gluTessVertex(GLUtessellator tessellator, double[] coords, int coords_offset, Object data)
gluTessBeginContour
and
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 gluTessCallback
reference page).
tessellator
- Specifies the tessellation object (created with
gluNewTess
).coords
- Specifies the coordinates of the vertex.data
- Specifies an opaque reference passed back to the program with the
vertex callback (as specified by
gluTessCallback
).gluTessBeginPolygon
,
gluNewTess
,
gluTessBeginContour
,
gluTessCallback
,
gluTessProperty
,
gluTessNormal
,
gluTessEndPolygon
public static final void gluTessBeginPolygon(GLUtessellator tessellator, Object data)
gluTessEndPolygon
delimit
the definition of a convex, concave or self-intersecting polygon. Within
each gluTessBeginPolygon/
gluTessEndPolygon
pair,
there must be one or more calls to
gluTessBeginContour
/
gluTessEndContour
. Within
each contour, there are zero or more calls to
gluTessVertex
. The vertices
specify a closed contour (the last vertex of each contour is automatically
linked to the first). See the gluTessVertex
, gluTessBeginContour
, and 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
gluTessCallback
), then this
reference is returned to the callback method(s). Thus, it is a convenient
way to store per-polygon information.
Once gluTessEndPolygon
is
called, the polygon is tessellated, and the resulting triangles are
described through callbacks. See
gluTessCallback
for
descriptions of the callback methods.
tessellator
- Specifies the tessellation object (created with
gluNewTess
).data
- Specifies a reference to user polygon data.gluNewTess
,
gluTessBeginContour
,
gluTessVertex
,
gluTessCallback
,
gluTessProperty
,
gluTessNormal
,
gluTessEndPolygon
public static final void gluTessBeginContour(GLUtessellator tessellator)
gluTessEndContour
delimit
the definition of a polygon contour. Within each
gluTessBeginContour/
gluTessEndContour
pair,
there can be zero or more calls to
gluTessVertex
. The vertices
specify a closed contour (the last vertex of each contour is automatically
linked to the first). See the gluTessVertex
reference page for more details. gluTessBeginContour
can only be called between
gluTessBeginPolygon
and
gluTessEndPolygon
.
Optional, throws GLException if not available in profile
tessellator
- Specifies the tessellation object (created with
gluNewTess
).gluNewTess
,
gluTessBeginPolygon
,
gluTessVertex
,
gluTessCallback
,
gluTessProperty
,
gluTessNormal
,
gluTessEndPolygon
public static final void gluTessEndContour(GLUtessellator tessellator)
gluTessBeginContour
delimit the definition of a polygon contour. Within each
gluTessBeginContour
/
gluTessEndContour pair, there can be zero or more calls to
gluTessVertex
. The vertices
specify a closed contour (the last vertex of each contour is automatically
linked to the first). See the gluTessVertex
reference page for more details.
gluTessBeginContour
can
only be called between gluTessBeginPolygon
and
gluTessEndPolygon
.
Optional, throws GLException if not available in profile
tessellator
- Specifies the tessellation object (created with
gluNewTess
).gluNewTess
,
gluTessBeginPolygon
,
gluTessVertex
,
gluTessCallback
,
gluTessProperty
,
gluTessNormal
,
gluTessEndPolygon
public static final void gluTessEndPolygon(GLUtessellator tessellator)
gluTessBeginPolygon
delimit the definition of a convex, concave or self-intersecting polygon.
Within each gluTessBeginPolygon
/gluTessEndPolygon pair, there must be one or
more calls to gluTessBeginContour
/gluTessEndContour
. Within each contour, there are zero or more calls to
gluTessVertex
. The vertices
specify a closed contour (the last vertex of each contour is automatically
linked to the first). See the gluTessVertex
, gluTessBeginContour
and 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
gluTessCallback
for
descriptions of the callback functions.
tessellator
- Specifies the tessellation object (created with
gluNewTess
).gluNewTess
,
gluTessBeginContour
,
gluTessVertex
,
gluTessCallback
,
gluTessProperty
,
gluTessNormal
,
gluTessBeginPolygon
public static final void gluBeginPolygon(GLUtessellator tessellator)
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 gluTessVertex
for each vertex and gluNextContour
to start each new contour. Finally, call gluEndPolygon
to signal the end of the
definition. See the gluTessVertex
and 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 gluTessCallback
for descriptions of the callback methods.
tessellator
- Specifies the tessellation object (created with
gluNewTess
).gluNewTess
,
gluNextContour
,
gluTessCallback
,
gluTessVertex
,
gluTessBeginPolygon
,
gluTessBeginContour
public static final void gluNextContour(GLUtessellator tessellator, int type)
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
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
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.
gluTessEndContour
followed by
gluTessBeginContour
.
tessellator
- Specifies the tessellation object (created with
gluNewTess
).type
- The type of the contour being defined.gluNewTess
,
gluTessBeginContour
,
gluTessBeginPolygon
,
gluTessCallback
,
gluTessEndContour
,
gluTessVertex
public static final void gluEndPolygon(GLUtessellator tessellator)
gluBeginPolygon
delimit the definition of a nonconvex polygon. To define
such a polygon, first call gluBeginPolygon
. Then define the contours of the polygon by calling
gluTessVertex
for each vertex
and gluNextContour
to start
each new contour. Finally, call gluEndPolygon to signal the end of
the definition. See the gluTessVertex
and 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
gluTessCallback
for
descriptions of the callback methods.
tessellator
- Specifies the tessellation object (created with
gluNewTess
).gluNewTess
,
gluNextContour
,
gluTessCallback
,
gluTessVertex
,
gluTessBeginPolygon
,
gluTessBeginContour
protected static final void validateGLUquadricImpl()
public final void gluCylinder(GLUquadric quad, double base, double top, double height, int slices, int stacks)
void gluCylinder(GLUquadric * quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks);
public final void gluDeleteQuadric(GLUquadric quad)
void gluDeleteQuadric(GLUquadric * quad);
public final void gluDisk(GLUquadric quad, double inner, double outer, int slices, int loops)
void gluDisk(GLUquadric * quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops);
public final GLUquadric gluNewQuadric()
GLUquadric * gluNewQuadric(void);
public final GLUquadric gluNewQuadric(boolean useGLSL)
public final void gluPartialDisk(GLUquadric quad, double inner, double outer, int slices, int loops, double start, double sweep)
void gluPartialDisk(GLUquadric * quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep);
public final void gluQuadricDrawStyle(GLUquadric quad, int draw)
void gluQuadricDrawStyle(GLUquadric * quad, GLenum draw);
public final void gluQuadricNormals(GLUquadric quad, int normal)
void gluQuadricNormals(GLUquadric * quad, GLenum normal);
public final void gluQuadricOrientation(GLUquadric quad, int orientation)
void gluQuadricOrientation(GLUquadric * quad, GLenum orientation);
public final void gluQuadricTexture(GLUquadric quad, boolean texture)
void gluQuadricTexture(GLUquadric * quad, GLboolean texture);
public final void gluSphere(GLUquadric quad, double radius, int slices, int stacks)
void gluSphere(GLUquadric * quad, GLdouble radius, GLint slices, GLint stacks);
public void gluOrtho2D(float left, float right, float bottom, float top)
public void gluPerspective(float fovy, float aspect, float zNear, float zFar)
public void gluLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ)
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)
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, FloatBuffer model, FloatBuffer proj, IntBuffer view, FloatBuffer winPos)
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 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)
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, FloatBuffer model, FloatBuffer proj, IntBuffer view, FloatBuffer objPos)
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 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)
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, FloatBuffer model, FloatBuffer proj, IntBuffer view, float nearVal, float farVal, FloatBuffer objPos)
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 void gluPickMatrix(float x, float y, float delX, float delY, int[] viewport, int viewport_offset)
public void gluPickMatrix(float x, float y, float delX, float delY, IntBuffer viewport)
public void gluOrtho2D(double left, double right, double bottom, double top)
public void gluPerspective(double fovy, double aspect, double zNear, double zFar)
public void gluLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ)
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)
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 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)
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 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)
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 void gluPickMatrix(double x, double y, double delX, double delY, int[] viewport, int viewport_offset)
public void gluPickMatrix(double x, double y, double delX, double delY, IntBuffer viewport)
public int gluScaleImage(int format, int widthin, int heightin, int typein, Buffer datain, int widthout, int heightout, int typeout, Buffer dataout)
public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int userLevel, int baseLevel, int maxLevel, Buffer data)
public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, Buffer data)
public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int userLevel, int baseLevel, int maxLevel, Buffer data)
public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, Buffer data)
public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int userLevel, int baseLevel, int maxLevel, Buffer data)
public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, Buffer data)
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |