|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object javax.media.opengl.glu.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()
Instantiates a new OpenGL Utility Library object. |
Method Summary | |
static GL |
getCurrentGL()
Returns the GL object associated with the OpenGL context current on the current thread. |
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 level,
int base,
int max,
Buffer data)
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); |
int |
gluBuild1DMipmaps(int target,
int internalFormat,
int width,
int format,
int type,
Buffer data)
Interface to C language function: GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); |
int |
gluBuild2DMipmapLevels(int target,
int internalFormat,
int width,
int height,
int format,
int type,
int level,
int base,
int max,
Buffer 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); |
int |
gluBuild2DMipmaps(int target,
int internalFormat,
int width,
int height,
int format,
int type,
Buffer data)
Interface to C language function: GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); |
int |
gluBuild3DMipmapLevels(int target,
int internalFormat,
int width,
int height,
int depth,
int format,
int type,
int level,
int base,
int max,
Buffer 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); |
int |
gluBuild3DMipmaps(int target,
int internalFormat,
int width,
int height,
int depth,
int format,
int type,
Buffer 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); |
boolean |
gluCheckExtension(String extName,
String extString)
|
void |
gluCylinder(GLUquadric quad,
double base,
double top,
double height,
int slices,
int stacks)
Interface to C language function: void gluCylinder(GLUquadric * quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks); |
void |
gluDeleteQuadric(GLUquadric quad)
Interface to C language function: void gluDeleteQuadric(GLUquadric * quad); |
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)
Interface to C language function: void gluDisk(GLUquadric * quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops); |
void |
gluEndPolygon(GLUtessellator tessellator)
gluEndPolygon and gluBeginPolygon delimit the definition of a nonconvex polygon. |
String |
gluErrorString(int errorCode)
|
String |
gluGetString(int name)
|
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)
|
GLUquadric |
gluNewQuadric()
Interface to C language function: GLUquadric * gluNewQuadric(void); |
GLUtessellator |
gluNewTess()
gluNewTess creates and returns a new tessellation object. |
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 |
gluPartialDisk(GLUquadric quad,
double inner,
double outer,
int slices,
int loops,
double start,
double sweep)
Interface to C language function: void gluPartialDisk(GLUquadric * quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep); |
void |
gluPerspective(double fovy,
double aspect,
double zNear,
double 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)
|
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(double objX,
double objY,
double objZ,
DoubleBuffer model,
DoubleBuffer proj,
IntBuffer view,
DoubleBuffer 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)
Interface to C language function: void gluQuadricDrawStyle(GLUquadric * quad, GLenum draw); |
void |
gluQuadricNormals(GLUquadric quad,
int normal)
Interface to C language function: void gluQuadricNormals(GLUquadric * quad, GLenum normal); |
void |
gluQuadricOrientation(GLUquadric quad,
int orientation)
Interface to C language function: void gluQuadricOrientation(GLUquadric * quad, GLenum orientation); |
void |
gluQuadricTexture(GLUquadric quad,
boolean texture)
Interface to C language function: void gluQuadricTexture(GLUquadric * quad, GLboolean texture); |
int |
gluScaleImage(int format,
int wIn,
int hIn,
int typeIn,
Buffer dataIn,
int wOut,
int hOut,
int typeOut,
Buffer dataOut)
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); |
void |
gluSphere(GLUquadric quad,
double radius,
int slices,
int stacks)
Interface to C language function: void gluSphere(GLUquadric * quad, GLdouble radius, GLint slices, GLint stacks); |
void |
gluTessBeginContour(GLUtessellator tessellator)
gluTessBeginContour and gluTessEndContour delimit
the definition of a polygon contour. |
void |
gluTessBeginPolygon(GLUtessellator tessellator,
Object data)
gluTessBeginPolygon and gluTessEndPolygon delimit
the definition of a convex, concave or self-intersecting polygon. |
void |
gluTessCallback(GLUtessellator tessellator,
int which,
GLUtessellatorCallback aCallback)
gluTessCallback is used to indicate a callback to be used by a tessellation object. |
void |
gluTessEndContour(GLUtessellator tessellator)
gluTessEndContour and gluTessBeginContour
delimit the definition of a polygon contour. |
void |
gluTessEndPolygon(GLUtessellator tessellator)
gluTessEndPolygon and gluTessBeginPolygon
delimit the definition of a convex, concave or self-intersecting polygon. |
void |
gluTessNormal(GLUtessellator tessellator,
double x,
double y,
double z)
gluTessNormal describes a normal for a polygon that the program is defining. |
void |
gluTessProperty(GLUtessellator tessellator,
int which,
double value)
gluTessProperty is used to control properites stored in a tessellation object. |
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(double winX,
double winY,
double winZ,
DoubleBuffer model,
DoubleBuffer proj,
IntBuffer view,
DoubleBuffer 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(double winX,
double winY,
double winZ,
double clipW,
DoubleBuffer model,
DoubleBuffer proj,
IntBuffer view,
double nearVal,
double farVal,
DoubleBuffer 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. |
Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
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_ERROR
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_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_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
Constructor Detail |
public GLU()
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.
Method Detail |
public static GL getCurrentGL() throws GLException
GLException
public String gluErrorString(int errorCode)
public boolean gluCheckExtension(String extName, String extString)
public String gluGetString(int name)
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 GLUtessellator gluNewTess()
gluTessBeginPolygon
,
gluDeleteTess
,
gluTessCallback
public void gluDeleteTess(GLUtessellator tessellator)
gluNewTess
).
tessellator
- Specifies the tessellation object to destroy.gluBeginPolygon
,
gluNewTess
,
gluTessCallback
public void gluTessProperty(GLUtessellator tessellator, int which, double value)
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 void gluGetTessProperty(GLUtessellator tessellator, int which, double[] value, int value_offset)
gluTessProperty
reference
page for information about the properties and what they do.
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 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.
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 void gluTessCallback(GLUtessellator tessellator, int which, GLUtessellatorCallback aCallback)
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 void gluTessVertex(GLUtessellator tessellator, double[] coords, int coords_offset, Object data)
gluTessBeginContour
and
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 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 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.
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 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
.
tessellator
- Specifies the tessellation object (created with
gluNewTess
).gluNewTess
,
gluTessBeginPolygon
,
gluTessVertex
,
gluTessCallback
,
gluTessProperty
,
gluTessNormal
,
gluTessEndPolygon
public 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
.
tessellator
- Specifies the tessellation object (created with
gluNewTess
).gluNewTess
,
gluTessBeginPolygon
,
gluTessVertex
,
gluTessCallback
,
gluTessProperty
,
gluTessNormal
,
gluTessEndPolygon
public 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.
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 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.
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 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.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 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.
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 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 void gluDeleteQuadric(GLUquadric quad)
void gluDeleteQuadric(GLUquadric * quad);
public 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 GLUquadric gluNewQuadric()
GLUquadric * gluNewQuadric(void);
public 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 void gluQuadricDrawStyle(GLUquadric quad, int draw)
void gluQuadricDrawStyle(GLUquadric * quad, GLenum draw);
public void gluQuadricNormals(GLUquadric quad, int normal)
void gluQuadricNormals(GLUquadric * quad, GLenum normal);
public void gluQuadricOrientation(GLUquadric quad, int orientation)
void gluQuadricOrientation(GLUquadric * quad, GLenum orientation);
public void gluQuadricTexture(GLUquadric quad, boolean texture)
void gluQuadricTexture(GLUquadric * quad, GLboolean texture);
public void gluSphere(GLUquadric quad, double radius, int slices, int stacks)
void gluSphere(GLUquadric * quad, GLdouble radius, GLint slices, GLint stacks);
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 gluProject(double objX, double objY, double objZ, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, DoubleBuffer 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(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 gluUnProject(double winX, double winY, double winZ, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, DoubleBuffer 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(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 boolean gluUnProject4(double winX, double winY, double winZ, double clipW, DoubleBuffer model, DoubleBuffer proj, IntBuffer view, double nearVal, double farVal, DoubleBuffer 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(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 gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, Buffer data)
GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data);
public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, Buffer data)
GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data);
public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, Buffer data)
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 gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, Buffer data)
GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, 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, Buffer data)
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 gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, Buffer data)
GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data);
public int gluScaleImage(int format, int wIn, int hIn, int typeIn, Buffer dataIn, int wOut, int hOut, int typeOut, Buffer dataOut)
GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut);
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |