com.jogamp.opengl.impl.glu
Class GLUquadricImpl

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

public class GLUquadricImpl
extends Object
implements GLUquadric

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

Author:
Erik Duijs, Kenneth Russell, Sven Gothel

Field Summary
 GL gl
           
 int normalType
           
static boolean USE_NORM
           
static boolean USE_TEXT
           
 
Constructor Summary
GLUquadricImpl(GL gl, boolean useGLSL)
           
 
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.
 void enableImmModeSink(boolean val)
           
 int getDrawStyle()
          Returns the drawStyle.
 boolean getImmMode()
           
 int getNormals()
          Returns the normals.
 int getOrientation()
          Returns the orientation.
 boolean getTextureFlag()
          Returns the textureFlag.
 boolean isImmModeSinkEnabled()
           
 ImmModeSink replaceImmModeSink()
           
 void resetImmModeSink(GL gl)
           
 void setDrawStyle(int drawStyle)
          specifies the draw style for quadrics.
 void setImmMode(boolean val)
           
 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
 

Field Detail

normalType

public int normalType

gl

public GL gl

USE_NORM

public static final boolean USE_NORM
See Also:
Constant Field Values

USE_TEXT

public static final boolean USE_TEXT
See Also:
Constant Field Values
Constructor Detail

GLUquadricImpl

public GLUquadricImpl(GL gl,
                      boolean useGLSL)
Method Detail

enableImmModeSink

public void enableImmModeSink(boolean val)
Specified by:
enableImmModeSink in interface GLUquadric

isImmModeSinkEnabled

public boolean isImmModeSinkEnabled()
Specified by:
isImmModeSinkEnabled in interface GLUquadric

setImmMode

public void setImmMode(boolean val)
Specified by:
setImmMode in interface GLUquadric

getImmMode

public boolean getImmMode()
Specified by:
getImmMode in interface GLUquadric

replaceImmModeSink

public ImmModeSink replaceImmModeSink()
Specified by:
replaceImmModeSink in interface GLUquadric

resetImmModeSink

public void resetImmModeSink(GL gl)
Specified by:
resetImmModeSink in interface GLUquadric

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 2010 JogAmp Community.