Example usage for javax.media.j3d TriangleStripArray setCoordinate

List of usage examples for javax.media.j3d TriangleStripArray setCoordinate

Introduction

In this page you can find the example usage for javax.media.j3d TriangleStripArray setCoordinate.

Prototype

public void setCoordinate(int index, float coordinate[]) 

Source Link

Document

Sets the coordinate associated with the vertex at the specified index for this object.

Usage

From source file:LightScopeApp.java

Shape3D createLampShape() {
    Shape3D lamp = new Shape3D();
    int stripCounts[] = { 10, 10 };
    TriangleStripArray lampGeom = new TriangleStripArray(20, GeometryArray.COORDINATES | GeometryArray.NORMALS,
            stripCounts);//from   w w w.j av a 2  s  . c  om
    lampGeom.setCoordinate(0, new Point3f(-0.01f, 0.9f, 0.01f));
    lampGeom.setCoordinate(1, new Point3f(-0.01f, 0.0f, 0.01f));
    lampGeom.setCoordinate(2, new Point3f(0.01f, 0.9f, 0.01f));
    lampGeom.setCoordinate(3, new Point3f(0.01f, 0.0f, 0.01f));
    lampGeom.setCoordinate(4, new Point3f(0.01f, 0.9f, -0.01f));
    lampGeom.setCoordinate(5, new Point3f(0.01f, 0.0f, -0.01f));
    lampGeom.setCoordinate(6, new Point3f(-0.01f, 0.9f, -0.01f));
    lampGeom.setCoordinate(7, new Point3f(-0.01f, 0.0f, -0.01f));
    lampGeom.setCoordinate(8, new Point3f(-0.01f, 0.9f, 0.01f));
    lampGeom.setCoordinate(9, new Point3f(-0.01f, 0.0f, 0.01f));
    lampGeom.setCoordinate(10, new Point3f(-0.1f, 0.9f, 0.1f));
    lampGeom.setCoordinate(11, new Point3f(-0.2f, 0.5f, 0.2f));
    lampGeom.setCoordinate(12, new Point3f(0.1f, 0.9f, 0.1f));
    lampGeom.setCoordinate(13, new Point3f(0.2f, 0.5f, 0.2f));
    lampGeom.setCoordinate(14, new Point3f(0.1f, 0.9f, -0.1f));
    lampGeom.setCoordinate(15, new Point3f(0.2f, 0.5f, -0.2f));
    lampGeom.setCoordinate(16, new Point3f(-0.1f, 0.9f, -0.1f));
    lampGeom.setCoordinate(17, new Point3f(-0.2f, 0.5f, -0.2f));
    lampGeom.setCoordinate(18, new Point3f(-0.1f, 0.9f, 0.1f));
    lampGeom.setCoordinate(19, new Point3f(-0.2f, 0.5f, 0.2f));

    Vector3f norm = new Vector3f(-0.7f, 0.0f, 0.7f);
    lampGeom.setNormal(0, norm);
    lampGeom.setNormal(1, norm);
    norm.set(0.7f, 0.0f, 0.7f);
    lampGeom.setNormal(2, norm);
    lampGeom.setNormal(3, norm);
    norm.set(0.7f, 0.0f, -0.7f);
    lampGeom.setNormal(4, norm);
    lampGeom.setNormal(5, norm);
    norm.set(-0.7f, 0.0f, -0.7f);
    lampGeom.setNormal(6, norm);
    lampGeom.setNormal(7, norm);
    norm.set(-0.7f, 0.0f, 0.7f);
    lampGeom.setNormal(8, norm);
    lampGeom.setNormal(9, norm);
    norm.set(-0.7f, 0.0f, 0.7f);
    lampGeom.setNormal(10, norm);
    lampGeom.setNormal(11, norm);
    norm.set(0.7f, 0.0f, 0.7f);
    lampGeom.setNormal(12, norm);
    lampGeom.setNormal(13, norm);
    norm.set(0.7f, 0.0f, -0.7f);
    lampGeom.setNormal(14, norm);
    lampGeom.setNormal(15, norm);
    norm.set(-0.7f, 0.0f, -0.7f);
    lampGeom.setNormal(16, norm);
    lampGeom.setNormal(17, norm);
    norm.set(-0.7f, 0.0f, 0.7f);
    lampGeom.setNormal(18, norm);
    lampGeom.setNormal(19, norm);

    lamp.setGeometry(lampGeom);
    return lamp;
}

From source file:GearTest.java

/**
 * Construct a Shaft;//from  ww  w  . ja v a 2s .c o m
 * 
 * @return a new shaft that with the specified radius centered about the
 *         origin an laying in the XY plane and of a specified length
 *         extending in the Z dimension
 * @param radius
 *            radius of shaft
 * @param length
 *            shaft length shaft extends from -length/2 to length/2 in the Z
 *            dimension
 * @param segmentCount
 *            number of segments for the shaft face
 * @param look
 *            the Appearance to associate with this shaft
 */
public Shaft(float radius, float length, int segmentCount, Appearance look) {
    // The direction of the ray from the shaft's center
    float xDirection, yDirection;
    float xShaft, yShaft;

    // The z coordinates for the shaft's faces (never change)
    float frontZ = -0.5f * length;
    float rearZ = 0.5f * length;

    int shaftFaceVertexCount; // #(vertices) per shaft face
    int shaftFaceTotalVertexCount; // total #(vertices) in all teeth
    int shaftFaceStripCount[] = new int[1]; // per shaft vertex count
    int shaftVertexCount; // #(vertices) for shaft
    int shaftStripCount[] = new int[1]; // #(vertices) in strip/strip

    // Front and rear facing normals for the shaft's faces
    Vector3f frontNormal = new Vector3f(0.0f, 0.0f, -1.0f);
    Vector3f rearNormal = new Vector3f(0.0f, 0.0f, 1.0f);
    // Outward facing normal
    Vector3f outNormal = new Vector3f(1.0f, 0.0f, 0.0f);

    // Temporary variables for storing coordinates and vectors
    Point3f coordinate = new Point3f(0.0f, 0.0f, 0.0f);
    Shape3D newShape;

    // The angle subtended by a single segment
    double segmentAngle = 2.0 * Math.PI / segmentCount;
    double tempAngle;

    // Allow this object to spin. etc.
    this.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

    /*
     * for the forward facing fan: ___3___ - | - / | \ 4/\ | /\2 / \ | / \ / \ | / \ : \ | / :
     * |--------------- *----------------| 5 0 1
     * 
     * for backward facing fan exchange 1 with 5; 2 with 4, etc.
     */

    // Construct the shaft's front and rear face
    shaftFaceVertexCount = segmentCount + 2;
    shaftFaceStripCount[0] = shaftFaceVertexCount;

    TriangleFanArray frontShaftFace = new TriangleFanArray(shaftFaceVertexCount,
            GeometryArray.COORDINATES | GeometryArray.NORMALS, shaftFaceStripCount);

    TriangleFanArray rearShaftFace = new TriangleFanArray(shaftFaceVertexCount,
            GeometryArray.COORDINATES | GeometryArray.NORMALS, shaftFaceStripCount);

    coordinate.set(0.0f, 0.0f, frontZ);
    frontShaftFace.setCoordinate(0, coordinate);
    frontShaftFace.setNormal(0, frontNormal);

    coordinate.set(0.0f, 0.0f, rearZ);
    rearShaftFace.setCoordinate(0, coordinate);
    rearShaftFace.setNormal(0, rearNormal);

    for (int index = 1; index < segmentCount + 2; index++) {

        tempAngle = segmentAngle * -(double) index;
        coordinate.set(radius * (float) Math.cos(tempAngle), radius * (float) Math.sin(tempAngle), frontZ);
        frontShaftFace.setCoordinate(index, coordinate);
        frontShaftFace.setNormal(index, frontNormal);

        tempAngle = -tempAngle;
        coordinate.set(radius * (float) Math.cos(tempAngle), radius * (float) Math.sin(tempAngle), rearZ);
        rearShaftFace.setCoordinate(index, coordinate);
        rearShaftFace.setNormal(index, rearNormal);
    }
    newShape = new Shape3D(frontShaftFace, look);
    this.addChild(newShape);
    newShape = new Shape3D(rearShaftFace, look);
    this.addChild(newShape);

    // Construct shaft's outer skin (the cylinder body)
    shaftVertexCount = 2 * segmentCount + 2;
    shaftStripCount[0] = shaftVertexCount;

    TriangleStripArray shaft = new TriangleStripArray(shaftVertexCount,
            GeometryArray.COORDINATES | GeometryArray.NORMALS, shaftStripCount);

    outNormal.set(1.0f, 0.0f, 0.0f);

    coordinate.set(radius, 0.0f, rearZ);
    shaft.setCoordinate(0, coordinate);
    shaft.setNormal(0, outNormal);

    coordinate.set(radius, 0.0f, frontZ);
    shaft.setCoordinate(1, coordinate);
    shaft.setNormal(1, outNormal);

    for (int count = 0; count < segmentCount; count++) {
        int index = 2 + count * 2;

        tempAngle = segmentAngle * (double) (count + 1);
        xDirection = (float) Math.cos(tempAngle);
        yDirection = (float) Math.sin(tempAngle);
        xShaft = radius * xDirection;
        yShaft = radius * yDirection;
        outNormal.set(xDirection, yDirection, 0.0f);

        coordinate.set(xShaft, yShaft, rearZ);
        shaft.setCoordinate(index, coordinate);
        shaft.setNormal(index, outNormal);

        coordinate.set(xShaft, yShaft, frontZ);
        shaft.setCoordinate(index + 1, coordinate);
        shaft.setNormal(index + 1, outNormal);
    }
    newShape = new Shape3D(shaft, look);
    this.addChild(newShape);
}

From source file:GearTest.java

void addBodyDisks(float shaftRadius, float bodyOuterRadius, float thickness, Appearance look) {
    int gearBodySegmentVertexCount; // #(segments) per tooth-unit
    int gearBodyTotalVertexCount; // #(vertices) in a gear face
    int gearBodyStripCount[] = new int[1]; // per strip (1) vertex count

    // A ray from the gear center, used in normal calculations
    float xDirection, yDirection;

    // The x and y coordinates at each point of a facet and at each
    // point on the gear: at the shaft, the root of the teeth, and
    // the outer point of the teeth
    float xRoot0, yRoot0, xShaft0, yShaft0;
    float xRoot3, yRoot3, xShaft3, yShaft3;
    float xRoot4, yRoot4, xShaft4, yShaft4;

    // Temporary variables for storing coordinates and vectors
    Point3f coordinate = new Point3f(0.0f, 0.0f, 0.0f);

    // Gear start differential angle. All gears are constructed with the
    // center of a tooth at Z-axis angle = 0.
    double gearStartAngle = -1.0 * toothTopCenterAngle;

    // Temporaries that store start angle for each portion of tooth facet
    double toothStartAngle, toothTopStartAngle, toothDeclineStartAngle, toothValleyStartAngle,
            nextToothStartAngle;/*from w  w  w.  j a  v a2  s  .c o  m*/

    Shape3D newShape;
    int index;

    // The z coordinates for the body disks
    final float frontZ = -0.5f * thickness;
    final float rearZ = 0.5f * thickness;

    /*
     * Construct the gear's front body (front facing torus disk) __2__ - | -
     * 4 - /| /- / / | /| \ 0\ / | / / > \ / | / | > \ / | / / | \ / ____|/ | >
     * \-- --__/ | 1 3 5
     *  
     */
    gearBodySegmentVertexCount = 4;
    gearBodyTotalVertexCount = 2 + gearBodySegmentVertexCount * toothCount;
    gearBodyStripCount[0] = gearBodyTotalVertexCount;

    TriangleStripArray frontGearBody = new TriangleStripArray(gearBodyTotalVertexCount,
            GeometryArray.COORDINATES | GeometryArray.NORMALS, gearBodyStripCount);

    xDirection = (float) Math.cos(gearStartAngle);
    yDirection = (float) Math.sin(gearStartAngle);
    xShaft0 = shaftRadius * xDirection;
    yShaft0 = shaftRadius * yDirection;
    xRoot0 = bodyOuterRadius * xDirection;
    yRoot0 = bodyOuterRadius * yDirection;

    coordinate.set(xRoot0, yRoot0, frontZ);
    frontGearBody.setCoordinate(0, coordinate);
    frontGearBody.setNormal(0, frontNormal);

    coordinate.set(xShaft0, yShaft0, frontZ);
    frontGearBody.setCoordinate(1, coordinate);
    frontGearBody.setNormal(1, frontNormal);

    for (int count = 0; count < toothCount; count++) {
        index = 2 + count * 4;
        toothStartAngle = gearStartAngle + circularPitchAngle * (double) count;
        toothValleyStartAngle = toothStartAngle + toothValleyAngleIncrement;
        nextToothStartAngle = toothStartAngle + circularPitchAngle;

        xDirection = (float) Math.cos(toothValleyStartAngle);
        yDirection = (float) Math.sin(toothValleyStartAngle);
        xShaft3 = shaftRadius * xDirection;
        yShaft3 = shaftRadius * yDirection;
        xRoot3 = bodyOuterRadius * xDirection;
        yRoot3 = bodyOuterRadius * yDirection;

        xDirection = (float) Math.cos(nextToothStartAngle);
        yDirection = (float) Math.sin(nextToothStartAngle);
        xShaft4 = shaftRadius * xDirection;
        yShaft4 = shaftRadius * yDirection;
        xRoot4 = bodyOuterRadius * xDirection;
        yRoot4 = bodyOuterRadius * yDirection;

        coordinate.set(xRoot3, yRoot3, frontZ);
        frontGearBody.setCoordinate(index, coordinate);
        frontGearBody.setNormal(index, frontNormal);

        coordinate.set(xShaft3, yShaft3, frontZ);
        frontGearBody.setCoordinate(index + 1, coordinate);
        frontGearBody.setNormal(index + 1, frontNormal);

        coordinate.set(xRoot4, yRoot4, frontZ);
        frontGearBody.setCoordinate(index + 2, coordinate);
        frontGearBody.setNormal(index + 2, frontNormal);

        coordinate.set(xShaft4, yShaft4, frontZ);
        frontGearBody.setCoordinate(index + 3, coordinate);
        frontGearBody.setNormal(index + 3, frontNormal);
    }
    newShape = new Shape3D(frontGearBody, look);
    this.addChild(newShape);

    // Construct the gear's rear body (rear facing torus disc)
    TriangleStripArray rearGearBody = new TriangleStripArray(gearBodyTotalVertexCount,
            GeometryArray.COORDINATES | GeometryArray.NORMALS, gearBodyStripCount);
    xDirection = (float) Math.cos(gearStartAngle);
    yDirection = (float) Math.sin(gearStartAngle);
    xShaft0 = shaftRadius * xDirection;
    yShaft0 = shaftRadius * yDirection;
    xRoot0 = bodyOuterRadius * xDirection;
    yRoot0 = bodyOuterRadius * yDirection;

    coordinate.set(xShaft0, yShaft0, rearZ);
    rearGearBody.setCoordinate(0, coordinate);
    rearGearBody.setNormal(0, rearNormal);

    coordinate.set(xRoot0, yRoot0, rearZ);
    rearGearBody.setCoordinate(1, coordinate);
    rearGearBody.setNormal(1, rearNormal);

    for (int count = 0; count < toothCount; count++) {
        index = 2 + count * 4;
        toothStartAngle = gearStartAngle + circularPitchAngle * (double) count;
        toothValleyStartAngle = toothStartAngle + toothValleyAngleIncrement;
        nextToothStartAngle = toothStartAngle + circularPitchAngle;

        xDirection = (float) Math.cos(toothValleyStartAngle);
        yDirection = (float) Math.sin(toothValleyStartAngle);
        xShaft3 = shaftRadius * xDirection;
        yShaft3 = shaftRadius * yDirection;
        xRoot3 = bodyOuterRadius * xDirection;
        yRoot3 = bodyOuterRadius * yDirection;

        xDirection = (float) Math.cos(nextToothStartAngle);
        yDirection = (float) Math.sin(nextToothStartAngle);
        xShaft4 = shaftRadius * xDirection;
        yShaft4 = shaftRadius * yDirection;
        xRoot4 = bodyOuterRadius * xDirection;
        yRoot4 = bodyOuterRadius * yDirection;

        coordinate.set(xShaft3, yShaft3, rearZ);
        rearGearBody.setCoordinate(index, coordinate);
        rearGearBody.setNormal(index, rearNormal);

        coordinate.set(xRoot3, yRoot3, rearZ);
        rearGearBody.setCoordinate(index + 1, coordinate);
        rearGearBody.setNormal(index + 1, rearNormal);

        coordinate.set(xShaft4, yShaft4, rearZ);
        rearGearBody.setCoordinate(index + 2, coordinate);
        rearGearBody.setNormal(index + 2, rearNormal);

        coordinate.set(xRoot4, yRoot4, rearZ);
        rearGearBody.setCoordinate(index + 3, coordinate);
        rearGearBody.setNormal(index + 3, rearNormal);

    }
    newShape = new Shape3D(rearGearBody, look);
    this.addChild(newShape);
}

From source file:GearTest.java

void addCylinderSkins(float shaftRadius, float length, int normalDirection, Appearance look) {
    int insideShaftVertexCount; // #(vertices) for shaft
    int insideShaftStripCount[] = new int[1]; // #(vertices) in strip/strip
    double toothStartAngle, nextToothStartAngle, toothValleyStartAngle;

    // A ray from the gear center, used in normal calculations
    float xDirection, yDirection;

    // The z coordinates for the body disks
    final float frontZ = -0.5f * length;
    final float rearZ = 0.5f * length;

    // Temporary variables for storing coordinates, points, and vectors
    float xShaft3, yShaft3, xShaft4, yShaft4;
    Point3f coordinate = new Point3f(0.0f, 0.0f, 0.0f);
    Vector3f surfaceNormal = new Vector3f();

    Shape3D newShape;//from   w  ww.j  ava  2s.  c  om
    int index;
    int firstIndex;
    int secondIndex;

    /*
     * Construct gear's inside shaft cylinder First the tooth's up, flat
     * outer, and down distances Second the tooth's flat inner distance
     * 
     * Outward facing vertex order: 0_______2____4 | /| /| | / | / | | / | / |
     * |/______|/___| 1 3 5
     * 
     * Inward facing vertex order: 1_______3____5 |\ |\ | | \ | \ | | \ | \ |
     * |______\|___\| 0 2 4
     */
    insideShaftVertexCount = 4 * toothCount + 2;
    insideShaftStripCount[0] = insideShaftVertexCount;

    TriangleStripArray insideShaft = new TriangleStripArray(insideShaftVertexCount,
            GeometryArray.COORDINATES | GeometryArray.NORMALS, insideShaftStripCount);
    xShaft3 = shaftRadius * (float) Math.cos(gearStartAngle);
    yShaft3 = shaftRadius * (float) Math.sin(gearStartAngle);

    if (normalDirection == OutwardNormals) {
        surfaceNormal.set(1.0f, 0.0f, 0.0f);
        firstIndex = 1;
        secondIndex = 0;
    } else {
        surfaceNormal.set(-1.0f, 0.0f, 0.0f);
        firstIndex = 0;
        secondIndex = 1;
    }

    // Coordinate labeled 0 in the strip
    coordinate.set(shaftRadius, 0.0f, frontZ);
    insideShaft.setCoordinate(firstIndex, coordinate);
    insideShaft.setNormal(firstIndex, surfaceNormal);

    // Coordinate labeled 1 in the strip
    coordinate.set(shaftRadius, 0.0f, rearZ);
    insideShaft.setCoordinate(secondIndex, coordinate);
    insideShaft.setNormal(secondIndex, surfaceNormal);

    for (int count = 0; count < toothCount; count++) {
        index = 2 + count * 4;

        toothStartAngle = circularPitchAngle * (double) count;
        toothValleyStartAngle = toothStartAngle + toothValleyAngleIncrement;
        nextToothStartAngle = toothStartAngle + circularPitchAngle;

        xDirection = (float) Math.cos(toothValleyStartAngle);
        yDirection = (float) Math.sin(toothValleyStartAngle);
        xShaft3 = shaftRadius * xDirection;
        yShaft3 = shaftRadius * yDirection;
        if (normalDirection == OutwardNormals)
            surfaceNormal.set(xDirection, yDirection, 0.0f);
        else
            surfaceNormal.set(-xDirection, -yDirection, 0.0f);

        // Coordinate labeled 2 in the strip
        coordinate.set(xShaft3, yShaft3, frontZ);
        insideShaft.setCoordinate(index + firstIndex, coordinate);
        insideShaft.setNormal(index + firstIndex, surfaceNormal);

        // Coordinate labeled 3 in the strip
        coordinate.set(xShaft3, yShaft3, rearZ);
        insideShaft.setCoordinate(index + secondIndex, coordinate);
        insideShaft.setNormal(index + secondIndex, surfaceNormal);

        xDirection = (float) Math.cos(nextToothStartAngle);
        yDirection = (float) Math.sin(nextToothStartAngle);
        xShaft4 = shaftRadius * xDirection;
        yShaft4 = shaftRadius * yDirection;
        if (normalDirection == OutwardNormals)
            surfaceNormal.set(xDirection, yDirection, 0.0f);
        else
            surfaceNormal.set(-xDirection, -yDirection, 0.0f);

        // Coordinate labeled 4 in the strip
        coordinate.set(xShaft4, yShaft4, frontZ);
        insideShaft.setCoordinate(index + 2 + firstIndex, coordinate);
        insideShaft.setNormal(index + 2 + firstIndex, surfaceNormal);

        // Coordinate labeled 5 in the strip
        coordinate.set(xShaft4, yShaft4, rearZ);
        insideShaft.setCoordinate(index + 2 + secondIndex, coordinate);
        insideShaft.setNormal(index + 2 + secondIndex, surfaceNormal);

    }
    newShape = new Shape3D(insideShaft, look);
    this.addChild(newShape);
}

From source file:GearTest.java

/**
 * Construct a SpurGear's teeth by adding the teeth shape nodes
 * //from www.j a v  a  2  s  .c  om
 * @param pitchCircleRadius
 *            radius at center of teeth
 * @param rootRadius
 *            distance from pitch circle to top of teeth
 * @param outsideRadius
 *            distance from pitch circle to root of teeth
 * @param gearThickness
 *            thickness of the gear
 * @param toothTipThickness
 *            thickness of the tip of the tooth
 * @param toothToValleyAngleRatio
 *            the ratio of the angle subtended by the tooth to the angle
 *            subtended by the valley (must be <= .25)
 * @param look
 *            the gear's appearance object
 */
void addTeeth(float pitchCircleRadius, float rootRadius, float outsideRadius, float gearThickness,
        float toothTipThickness, float toothToValleyAngleRatio, Appearance look) {
    int index;
    Shape3D newShape;

    // Temporaries that store start angle for each portion of tooth facet
    double toothStartAngle, toothTopStartAngle, toothDeclineStartAngle, toothValleyStartAngle,
            nextToothStartAngle;

    // The x and y coordinates at each point of a facet and at each
    // point on the gear: at the shaft, the root of the teeth, and
    // the outer point of the teeth
    float xRoot0, yRoot0;
    float xOuter1, yOuter1;
    float xOuter2, yOuter2;
    float xRoot3, yRoot3;
    float xRoot4, yRoot4;

    // The z coordinates for the gear
    final float frontZ = -0.5f * gearThickness;
    final float rearZ = 0.5f * gearThickness;

    // The z coordinates for the tooth tip of the gear
    final float toothTipFrontZ = -0.5f * toothTipThickness;
    final float toothTipRearZ = 0.5f * toothTipThickness;

    int toothFacetVertexCount; // #(vertices) per tooth facet
    int toothFacetCount; // #(facets) per tooth
    int toothFaceTotalVertexCount; // #(vertices) in all teeth
    int toothFaceStripCount[] = new int[toothCount];
    // per tooth vertex count
    int topVertexCount; // #(vertices) for teeth tops
    int topStripCount[] = new int[1]; // #(vertices) in strip/strip

    // Front and rear facing normals for the teeth faces
    Vector3f frontToothNormal = new Vector3f(0.0f, 0.0f, -1.0f);
    Vector3f rearToothNormal = new Vector3f(0.0f, 0.0f, 1.0f);

    // Normals for teeth tops up incline, tooth top, and down incline
    Vector3f leftNormal = new Vector3f(-1.0f, 0.0f, 0.0f);
    Vector3f rightNormal = new Vector3f(1.0f, 0.0f, 0.0f);
    Vector3f outNormal = new Vector3f(1.0f, 0.0f, 0.0f);
    Vector3f inNormal = new Vector3f(-1.0f, 0.0f, 0.0f);

    // Temporary variables for storing coordinates and vectors
    Point3f coordinate = new Point3f(0.0f, 0.0f, 0.0f);
    Point3f tempCoordinate1 = new Point3f(0.0f, 0.0f, 0.0f);
    Point3f tempCoordinate2 = new Point3f(0.0f, 0.0f, 0.0f);
    Point3f tempCoordinate3 = new Point3f(0.0f, 0.0f, 0.0f);
    Vector3f tempVector1 = new Vector3f(0.0f, 0.0f, 0.0f);
    Vector3f tempVector2 = new Vector3f(0.0f, 0.0f, 0.0f);

    /*
     * Construct the gear's front facing teeth facets 0______2 / /\ / / \ / / \
     * //___________\ 1 3
     */
    toothFacetVertexCount = 4;
    toothFaceTotalVertexCount = toothFacetVertexCount * toothCount;
    for (int i = 0; i < toothCount; i++)
        toothFaceStripCount[i] = toothFacetVertexCount;

    TriangleStripArray frontGearTeeth = new TriangleStripArray(toothFaceTotalVertexCount,
            GeometryArray.COORDINATES | GeometryArray.NORMALS, toothFaceStripCount);

    for (int count = 0; count < toothCount; count++) {
        index = count * toothFacetVertexCount;

        toothStartAngle = gearStartAngle + circularPitchAngle * (double) count;
        toothTopStartAngle = toothStartAngle + toothTopAngleIncrement;
        toothDeclineStartAngle = toothStartAngle + toothDeclineAngleIncrement;
        toothValleyStartAngle = toothStartAngle + toothValleyAngleIncrement;

        xRoot0 = rootRadius * (float) Math.cos(toothStartAngle);
        yRoot0 = rootRadius * (float) Math.sin(toothStartAngle);
        xOuter1 = outsideRadius * (float) Math.cos(toothTopStartAngle);
        yOuter1 = outsideRadius * (float) Math.sin(toothTopStartAngle);
        xOuter2 = outsideRadius * (float) Math.cos(toothDeclineStartAngle);
        yOuter2 = outsideRadius * (float) Math.sin(toothDeclineStartAngle);
        xRoot3 = rootRadius * (float) Math.cos(toothValleyStartAngle);
        yRoot3 = rootRadius * (float) Math.sin(toothValleyStartAngle);

        tempCoordinate1.set(xRoot0, yRoot0, frontZ);
        tempCoordinate2.set(xRoot3, yRoot3, frontZ);
        tempVector1.sub(tempCoordinate2, tempCoordinate1);

        tempCoordinate2.set(xOuter1, yOuter1, toothTipFrontZ);
        tempVector2.sub(tempCoordinate2, tempCoordinate1);

        frontToothNormal.cross(tempVector1, tempVector2);
        frontToothNormal.normalize();

        coordinate.set(xOuter1, yOuter1, toothTipFrontZ);
        frontGearTeeth.setCoordinate(index, coordinate);
        frontGearTeeth.setNormal(index, frontToothNormal);

        coordinate.set(xRoot0, yRoot0, frontZ);
        frontGearTeeth.setCoordinate(index + 1, coordinate);
        frontGearTeeth.setNormal(index + 1, frontToothNormal);

        coordinate.set(xOuter2, yOuter2, toothTipFrontZ);
        frontGearTeeth.setCoordinate(index + 2, coordinate);
        frontGearTeeth.setNormal(index + 2, frontToothNormal);

        coordinate.set(xRoot3, yRoot3, frontZ);
        frontGearTeeth.setCoordinate(index + 3, coordinate);
        frontGearTeeth.setNormal(index + 3, frontToothNormal);
    }
    newShape = new Shape3D(frontGearTeeth, look);
    this.addChild(newShape);

    /*
     * Construct the gear's rear facing teeth facets (Using Quads) 1______2 / \ / \ / \
     * /____________\ 0 3
     */
    toothFacetVertexCount = 4;
    toothFaceTotalVertexCount = toothFacetVertexCount * toothCount;

    QuadArray rearGearTeeth = new QuadArray(toothCount * toothFacetVertexCount,
            GeometryArray.COORDINATES | GeometryArray.NORMALS);

    for (int count = 0; count < toothCount; count++) {

        index = count * toothFacetVertexCount;
        toothStartAngle = gearStartAngle + circularPitchAngle * (double) count;
        toothTopStartAngle = toothStartAngle + toothTopAngleIncrement;
        toothDeclineStartAngle = toothStartAngle + toothDeclineAngleIncrement;
        toothValleyStartAngle = toothStartAngle + toothValleyAngleIncrement;

        xRoot0 = rootRadius * (float) Math.cos(toothStartAngle);
        yRoot0 = rootRadius * (float) Math.sin(toothStartAngle);
        xOuter1 = outsideRadius * (float) Math.cos(toothTopStartAngle);
        yOuter1 = outsideRadius * (float) Math.sin(toothTopStartAngle);
        xOuter2 = outsideRadius * (float) Math.cos(toothDeclineStartAngle);
        yOuter2 = outsideRadius * (float) Math.sin(toothDeclineStartAngle);
        xRoot3 = rootRadius * (float) Math.cos(toothValleyStartAngle);
        yRoot3 = rootRadius * (float) Math.sin(toothValleyStartAngle);

        tempCoordinate1.set(xRoot0, yRoot0, rearZ);
        tempCoordinate2.set(xRoot3, yRoot3, rearZ);
        tempVector1.sub(tempCoordinate2, tempCoordinate1);
        tempCoordinate2.set(xOuter1, yOuter1, toothTipRearZ);
        tempVector2.sub(tempCoordinate2, tempCoordinate1);
        rearToothNormal.cross(tempVector2, tempVector1);
        rearToothNormal.normalize();

        coordinate.set(xRoot0, yRoot0, rearZ);
        rearGearTeeth.setCoordinate(index, coordinate);
        rearGearTeeth.setNormal(index, rearToothNormal);

        coordinate.set(xOuter1, yOuter1, toothTipRearZ);
        rearGearTeeth.setCoordinate(index + 1, coordinate);
        rearGearTeeth.setNormal(index + 1, rearToothNormal);

        coordinate.set(xOuter2, yOuter2, toothTipRearZ);
        rearGearTeeth.setCoordinate(index + 2, coordinate);
        rearGearTeeth.setNormal(index + 2, rearToothNormal);

        coordinate.set(xRoot3, yRoot3, rearZ);
        rearGearTeeth.setCoordinate(index + 3, coordinate);
        rearGearTeeth.setNormal(index + 3, rearToothNormal);

    }
    newShape = new Shape3D(rearGearTeeth, look);
    this.addChild(newShape);

    /*
     * Construct the gear's top teeth faces (As seen from above) Root0
     * Outer1 Outer2 Root3 Root4 (RearZ) 0_______3 2_______5 4_______7
     * 6_______9 |0 3| |4 7| |8 11| |12 15| | | | | | | | | | | | | | | | |
     * |1_____2| |5_____6| |9____10| |13___14| 1 2 3 4 5 6 7 8 Root0 Outer1
     * Outer2 Root3 Root4 (FrontZ)
     * 
     * Quad 0123 uses a left normal Quad 2345 uses an out normal Quad 4567
     * uses a right normal Quad 6789 uses an out normal
     */
    topVertexCount = 8 * toothCount + 2;
    topStripCount[0] = topVertexCount;

    toothFacetVertexCount = 4;
    toothFacetCount = 4;

    QuadArray topGearTeeth = new QuadArray(toothCount * toothFacetVertexCount * toothFacetCount,
            GeometryArray.COORDINATES | GeometryArray.NORMALS);

    for (int count = 0; count < toothCount; count++) {
        index = count * toothFacetCount * toothFacetVertexCount;
        toothStartAngle = gearStartAngle + circularPitchAngle * (double) count;
        toothTopStartAngle = toothStartAngle + toothTopAngleIncrement;
        toothDeclineStartAngle = toothStartAngle + toothDeclineAngleIncrement;
        toothValleyStartAngle = toothStartAngle + toothValleyAngleIncrement;
        nextToothStartAngle = toothStartAngle + circularPitchAngle;

        xRoot0 = rootRadius * (float) Math.cos(toothStartAngle);
        yRoot0 = rootRadius * (float) Math.sin(toothStartAngle);
        xOuter1 = outsideRadius * (float) Math.cos(toothTopStartAngle);
        yOuter1 = outsideRadius * (float) Math.sin(toothTopStartAngle);
        xOuter2 = outsideRadius * (float) Math.cos(toothDeclineStartAngle);
        yOuter2 = outsideRadius * (float) Math.sin(toothDeclineStartAngle);
        xRoot3 = rootRadius * (float) Math.cos(toothValleyStartAngle);
        yRoot3 = rootRadius * (float) Math.sin(toothValleyStartAngle);
        xRoot4 = rootRadius * (float) Math.cos(nextToothStartAngle);
        yRoot4 = rootRadius * (float) Math.sin(nextToothStartAngle);

        // Compute normal for quad 1
        tempCoordinate1.set(xRoot0, yRoot0, frontZ);
        tempCoordinate2.set(xOuter1, yOuter1, toothTipFrontZ);
        tempVector1.sub(tempCoordinate2, tempCoordinate1);
        leftNormal.cross(frontNormal, tempVector1);
        leftNormal.normalize();

        // Coordinate labeled 0 in the quad
        coordinate.set(xRoot0, yRoot0, rearZ);
        topGearTeeth.setCoordinate(index, coordinate);
        topGearTeeth.setNormal(index, leftNormal);

        // Coordinate labeled 1 in the quad
        coordinate.set(tempCoordinate1);
        topGearTeeth.setCoordinate(index + 1, coordinate);
        topGearTeeth.setNormal(index + 1, leftNormal);

        // Coordinate labeled 2 in the quad
        topGearTeeth.setCoordinate(index + 2, tempCoordinate2);
        topGearTeeth.setNormal(index + 2, leftNormal);
        topGearTeeth.setCoordinate(index + 5, tempCoordinate2);

        // Coordinate labeled 3 in the quad
        coordinate.set(xOuter1, yOuter1, toothTipRearZ);
        topGearTeeth.setCoordinate(index + 3, coordinate);
        topGearTeeth.setNormal(index + 3, leftNormal);
        topGearTeeth.setCoordinate(index + 4, coordinate);

        // Compute normal for quad 2
        tempCoordinate1.set(xOuter1, yOuter1, toothTipFrontZ);
        tempCoordinate2.set(xOuter2, yOuter2, toothTipFrontZ);
        tempVector1.sub(tempCoordinate2, tempCoordinate1);
        outNormal.cross(frontNormal, tempVector1);
        outNormal.normalize();

        topGearTeeth.setNormal(index + 4, outNormal);
        topGearTeeth.setNormal(index + 5, outNormal);

        // Coordinate labeled 4 in the quad
        topGearTeeth.setCoordinate(index + 6, tempCoordinate2);
        topGearTeeth.setNormal(index + 6, outNormal);
        topGearTeeth.setCoordinate(index + 9, tempCoordinate2);

        // Coordinate labeled 5 in the quad
        coordinate.set(xOuter2, yOuter2, toothTipRearZ);
        topGearTeeth.setCoordinate(index + 7, coordinate);
        topGearTeeth.setNormal(index + 7, outNormal);
        topGearTeeth.setCoordinate(index + 8, coordinate);

        // Compute normal for quad 3
        tempCoordinate1.set(xOuter2, yOuter2, toothTipFrontZ);
        tempCoordinate2.set(xRoot3, yRoot3, frontZ);
        tempVector1.sub(tempCoordinate2, tempCoordinate1);
        rightNormal.cross(frontNormal, tempVector1);
        rightNormal.normalize();

        topGearTeeth.setNormal(index + 8, rightNormal);
        topGearTeeth.setNormal(index + 9, rightNormal);

        // Coordinate labeled 7 in the quad
        topGearTeeth.setCoordinate(index + 10, tempCoordinate2);
        topGearTeeth.setNormal(index + 10, rightNormal);
        topGearTeeth.setCoordinate(index + 13, tempCoordinate2);

        // Coordinate labeled 6 in the quad
        coordinate.set(xRoot3, yRoot3, rearZ);
        topGearTeeth.setCoordinate(index + 11, coordinate);
        topGearTeeth.setNormal(index + 11, rightNormal);
        topGearTeeth.setCoordinate(index + 12, coordinate);

        // Compute normal for quad 4
        tempCoordinate1.set(xRoot3, yRoot3, frontZ);
        tempCoordinate2.set(xRoot4, yRoot4, frontZ);
        tempVector1.sub(tempCoordinate2, tempCoordinate1);
        outNormal.cross(frontNormal, tempVector1);
        outNormal.normalize();

        topGearTeeth.setNormal(index + 12, outNormal);
        topGearTeeth.setNormal(index + 13, outNormal);

        // Coordinate labeled 9 in the quad
        topGearTeeth.setCoordinate(index + 14, tempCoordinate2);
        topGearTeeth.setNormal(index + 14, outNormal);

        // Coordinate labeled 8 in the quad
        coordinate.set(xRoot4, yRoot4, rearZ);
        topGearTeeth.setCoordinate(index + 15, coordinate);
        topGearTeeth.setNormal(index + 15, outNormal);

        // Prepare for the loop by computing the new normal
        toothTopStartAngle = nextToothStartAngle + toothTopAngleIncrement;
        xOuter1 = outsideRadius * (float) Math.cos(toothTopStartAngle);
        yOuter1 = outsideRadius * (float) Math.sin(toothTopStartAngle);

        tempCoordinate1.set(xRoot4, yRoot4, toothTipFrontZ);
        tempCoordinate2.set(xOuter1, yOuter1, toothTipFrontZ);
        tempVector1.sub(tempCoordinate2, tempCoordinate1);
        leftNormal.cross(frontNormal, tempVector1);
        leftNormal.normalize();
    }
    newShape = new Shape3D(topGearTeeth, look);
    this.addChild(newShape);
}