com.sun.opengl.impl
Class GLUquadricImpl

java.lang.Object
  extended by com.sun.opengl.impl.GLUquadricImpl
All Implemented Interfaces:
GLUquadric

public class GLUquadricImpl
extends java.lang.Object
implements GLUquadric

GLUquadricImpl.java Created 22-dec-2003 (originally Quadric.java)

Author:
Erik Duijs, Kenneth Russell

Constructor Summary
GLUquadricImpl()
           
 
Method Summary
 void drawCylinder(GL gl, float baseRadius, float topRadius, float height, int slices, int stacks)
          draws a cylinder oriented along the z axis.
 void drawDisk(GL gl, float innerRadius, float outerRadius, int slices, int loops)
          renders a disk on the z = 0 plane.
 void drawPartialDisk(GL gl, float innerRadius, float outerRadius, int slices, int loops, float startAngle, float sweepAngle)
          renders a partial disk on the z=0 plane.
 void drawSphere(GL gl, float radius, int slices, int stacks)
          draws a sphere of the given radius centered around the origin.
 int getDrawStyle()
          Returns the drawStyle.
 int getNormals()
          Returns the normals.
 int getOrientation()
          Returns the orientation.
 boolean getTextureFlag()
          Returns the textureFlag.
 void setDrawStyle(int drawStyle)
          specifies the draw style for quadrics.
 void setNormals(int normals)
          specifies what kind of normals are desired for quadrics.
 void setOrientation(int orientation)
          specifies what kind of orientation is desired for.
 void setTextureFlag(boolean textureFlag)
          specifies if texture coordinates should be generated for quadrics rendered with qobj.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

GLUquadricImpl

public GLUquadricImpl()
Method Detail

setDrawStyle

public void setDrawStyle(int drawStyle)
specifies the draw style for quadrics. The legal values are as follows: GLU.FILL: Quadrics are rendered with polygon primitives. The polygons are drawn in a counterclockwise fashion with respect to their normals (as defined with glu.quadricOrientation). GLU.LINE: Quadrics are rendered as a set of lines. GLU.SILHOUETTE: Quadrics are rendered as a set of lines, except that edges separating coplanar faces will not be drawn. GLU.POINT: Quadrics are rendered as a set of points.

Parameters:
drawStyle - The drawStyle to set

setNormals

public void setNormals(int normals)
specifies what kind of normals are desired for quadrics. The legal values are as follows: GLU.NONE: No normals are generated. GLU.FLAT: One normal is generated for every facet of a quadric. GLU.SMOOTH: One normal is generated for every vertex of a quadric. This is the default.

Parameters:
normals - The normals to set

setOrientation

public void setOrientation(int orientation)
specifies what kind of orientation is desired for. The orientation values are as follows: GLU.OUTSIDE: Quadrics are drawn with normals pointing outward. GLU.INSIDE: Normals point inward. The default is GLU.OUTSIDE. Note that the interpretation of outward and inward depends on the quadric being drawn.

Parameters:
orientation - The orientation to set

setTextureFlag

public void setTextureFlag(boolean textureFlag)
specifies if texture coordinates should be generated for quadrics rendered with qobj. If the value of textureCoords is true, then texture coordinates are generated, and if textureCoords is false, they are not.. The default is false. The manner in which texture coordinates are generated depends upon the specific quadric rendered.

Parameters:
textureFlag - The textureFlag to set

getDrawStyle

public int getDrawStyle()
Returns the drawStyle.

Returns:
int

getNormals

public int getNormals()
Returns the normals.

Returns:
int

getOrientation

public int getOrientation()
Returns the orientation.

Returns:
int

getTextureFlag

public boolean getTextureFlag()
Returns the textureFlag.

Returns:
boolean

drawCylinder

public void drawCylinder(GL gl,
                         float baseRadius,
                         float topRadius,
                         float height,
                         int slices,
                         int stacks)
draws a cylinder oriented along the z axis. The base of the cylinder is placed at z = 0, and the top at z=height. Like a sphere, a cylinder is subdivided around the z axis into slices, and along the z axis into stacks. Note that if topRadius is set to zero, then this routine will generate a cone. If the orientation is set to GLU.OUTSIDE (with glu.quadricOrientation), then any generated normals point away from the z axis. Otherwise, they point toward the z axis. If texturing is turned on (with glu.quadricTexture), then texture coordinates are generated so that t ranges linearly from 0.0 at z = 0 to 1.0 at z = height, and s ranges from 0.0 at the +y axis, to 0.25 at the +x axis, to 0.5 at the -y axis, to 0.75 at the -x axis, and back to 1.0 at the +y axis.

Parameters:
baseRadius - Specifies the radius of the cylinder at z = 0.
topRadius - Specifies the radius of the cylinder at z = height.
height - Specifies the height of the cylinder.
slices - Specifies the number of subdivisions around the z axis.
stacks - Specifies the number of subdivisions along the z axis.

drawDisk

public void drawDisk(GL gl,
                     float innerRadius,
                     float outerRadius,
                     int slices,
                     int loops)
renders a disk on the z = 0 plane. The disk has a radius of outerRadius, and contains a concentric circular hole with a radius of innerRadius. If innerRadius is 0, then no hole is generated. The disk is subdivided around the z axis into slices (like pizza slices), and also about the z axis into rings (as specified by slices and loops, respectively). With respect to orientation, the +z side of the disk is considered to be "outside" (see glu.quadricOrientation). This means that if the orientation is set to GLU.OUTSIDE, then any normals generated point along the +z axis. Otherwise, they point along the -z axis. If texturing is turned on (with glu.quadricTexture), texture coordinates are generated linearly such that where r=outerRadius, the value at (r, 0, 0) is (1, 0.5), at (0, r, 0) it is (0.5, 1), at (-r, 0, 0) it is (0, 0.5), and at (0, -r, 0) it is (0.5, 0).


drawPartialDisk

public void drawPartialDisk(GL gl,
                            float innerRadius,
                            float outerRadius,
                            int slices,
                            int loops,
                            float startAngle,
                            float sweepAngle)
renders a partial disk on the z=0 plane. A partial disk is similar to a full disk, except that only the subset of the disk from startAngle through startAngle + sweepAngle is included (where 0 degrees is along the +y axis, 90 degrees along the +x axis, 180 along the -y axis, and 270 along the -x axis). The partial disk has a radius of outerRadius, and contains a concentric circular hole with a radius of innerRadius. If innerRadius is zero, then no hole is generated. The partial disk is subdivided around the z axis into slices (like pizza slices), and also about the z axis into rings (as specified by slices and loops, respectively). With respect to orientation, the +z side of the partial disk is considered to be outside (see gluQuadricOrientation). This means that if the orientation is set to GLU.GLU_OUTSIDE, then any normals generated point along the +z axis. Otherwise, they point along the -z axis. If texturing is turned on (with gluQuadricTexture), texture coordinates are generated linearly such that where r=outerRadius, the value at (r, 0, 0) is (1, 0.5), at (0, r, 0) it is (0.5, 1), at (-r, 0, 0) it is (0, 0.5), and at (0, -r, 0) it is (0.5, 0).


drawSphere

public void drawSphere(GL gl,
                       float radius,
                       int slices,
                       int stacks)
draws a sphere of the given radius centered around the origin. The sphere is subdivided around the z axis into slices and along the z axis into stacks (similar to lines of longitude and latitude). If the orientation is set to GLU.OUTSIDE (with glu.quadricOrientation), then any normals generated point away from the center of the sphere. Otherwise, they point toward the center of the sphere. If texturing is turned on (with glu.quadricTexture), then texture coordinates are generated so that t ranges from 0.0 at z=-radius to 1.0 at z=radius (t increases linearly along longitudinal lines), and s ranges from 0.0 at the +y axis, to 0.25 at the +x axis, to 0.5 at the -y axis, to 0.75 at the -x axis, and back to 1.0 at the +y axis.



Copyright 2005 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms.