Java/3D/Gear

Gear Test

/*
 * @(#)GearTest.java 1.17 02/10/21 13:40:16
 * 
 * Copyright (c) 1996-2002 Sun Microsystems, Inc. All Rights Reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met: -
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer. - Redistribution in binary
 * form must reproduce the above copyright notice, this list of conditions and
 * the following disclaimer in the documentation and/or other materials provided
 * with the distribution.
 * 
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
 * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
 * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
 * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
 * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
 * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
 * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
 * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGES.
 * 
 * You acknowledge that Software is not designed,licensed or intended for use in
 * the design, construction, operation or maintenance of any nuclear facility.
 */
import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.GraphicsConfiguration;
import javax.media.j3d.Alpha;
import javax.media.j3d.AmbientLight;
import javax.media.j3d.Appearance;
import javax.media.j3d.Background;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.DirectionalLight;
import javax.media.j3d.GeometryArray;
import javax.media.j3d.Material;
import javax.media.j3d.QuadArray;
import javax.media.j3d.RotationInterpolator;
import javax.media.j3d.Shape3D;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.TriangleFanArray;
import javax.media.j3d.TriangleStripArray;
import javax.vecmath.Color3f;
import javax.vecmath.Point3d;
import javax.vecmath.Point3f;
import javax.vecmath.Vector3d;
import javax.vecmath.Vector3f;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.behaviors.vp.OrbitBehavior;
import com.sun.j3d.utils.universe.SimpleUniverse;
import com.sun.j3d.utils.universe.ViewingPlatform;
public class GearTest extends Applet {
  static final int defaultToothCount = 24;
  private int toothCount;
  private SimpleUniverse u = null;
  public BranchGroup createSceneGraph(int toothCount) {
    // Create the root of the branch graph
    BranchGroup objRoot = new BranchGroup();
    // Create a Transformgroup to scale all objects so they
    // appear in the scene.
    TransformGroup objScale = new TransformGroup();
    Transform3D t3d = new Transform3D();
    t3d.setScale(0.4);
    objScale.setTransform(t3d);
    objRoot.addChild(objScale);
    // Create a bounds for the background and lights
    BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0),
        100.0);
    // Set up the background
    Color3f bgColor = new Color3f(0.05f, 0.05f, 0.2f);
    Background bgNode = new Background(bgColor);
    bgNode.setApplicationBounds(bounds);
    objScale.addChild(bgNode);
    // Set up the global lights
    Color3f light1Color = new Color3f(1.0f, 1.0f, 0.9f);
    Vector3f light1Direction = new Vector3f(4.0f, -7.0f, -12.0f);
    Color3f light2Color = new Color3f(0.3f, 0.3f, 0.4f);
    Vector3f light2Direction = new Vector3f(-6.0f, -2.0f, -1.0f);
    Color3f ambientColor = new Color3f(0.1f, 0.1f, 0.1f);
    AmbientLight ambientLightNode = new AmbientLight(ambientColor);
    ambientLightNode.setInfluencingBounds(bounds);
    objScale.addChild(ambientLightNode);
    DirectionalLight light1 = new DirectionalLight(light1Color,
        light1Direction);
    light1.setInfluencingBounds(bounds);
    objScale.addChild(light1);
    DirectionalLight light2 = new DirectionalLight(light2Color,
        light2Direction);
    light2.setInfluencingBounds(bounds);
    objScale.addChild(light2);
    // Create the transform group node and initialize it to the
    // identity. Enable the TRANSFORM_WRITE capability so that
    // our behavior code can modify it at runtime. Add it to the
    // root of the subgraph.
    TransformGroup objTrans = new TransformGroup();
    objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
    objScale.addChild(objTrans);
    // Create an Appearance.
    Appearance look = new Appearance();
    Color3f objColor = new Color3f(0.5f, 0.5f, 0.6f);
    Color3f black = new Color3f(0.0f, 0.0f, 0.0f);
    Color3f white = new Color3f(1.0f, 1.0f, 1.0f);
    look
        .setMaterial(new Material(objColor, black, objColor, white,
            100.0f));
    // Create a gear, add it to the scene graph.
    //  SpurGear gear = new SpurGear(toothCount, 1.0f, 0.2f,
    SpurGear gear = new SpurGearThinBody(toothCount, 1.0f, 0.2f, 0.05f,
        0.05f, 0.3f, 0.28f, look);
    objTrans.addChild(gear);
    // Create a new Behavior object that will rotate the object and
    // add it into the scene graph.
    Transform3D yAxis = new Transform3D();
    Alpha rotationAlpha = new Alpha(-1, Alpha.INCREASING_ENABLE, 0, 0,
        8000, 0, 0, 0, 0, 0);
    RotationInterpolator rotator = new RotationInterpolator(rotationAlpha,
        objTrans, yAxis, 0.0f, (float) Math.PI * 2.0f);
    rotator.setSchedulingBounds(bounds);
    objTrans.addChild(rotator);
    // Have Java 3D perform optimizations on this scene graph.
    objRoot.rupile();
    return objRoot;
  }
  public GearTest() {
    this(defaultToothCount);
  }
  public GearTest(int toothCount) {
    this.toothCount = toothCount;
  }
  public void init() {
    setLayout(new BorderLayout());
    GraphicsConfiguration config = SimpleUniverse
        .getPreferredConfiguration();
    Canvas3D c = new Canvas3D(config);
    add("Center", c);
    // Create a simple scene and attach it to the virtual universe
    BranchGroup scene = createSceneGraph(toothCount);
    u = new SimpleUniverse(c);
    // This will move the ViewPlatform back a bit so the
    // objects in the scene can be viewed.
    u.getViewingPlatform().setNominalViewingTransform();
    u.addBranchGraph(scene);
  }
  public void destroy() {
    u.cleanup();
  }
  //
  // The following allows GearTest to be run as an application
  // as well as an applet
  //
  public static void main(String[] args) {
    int value;
    if (args.length > 1) {
      System.out.println("Usage: java GearTest [#teeth]");
      System.exit(0);
    } else if (args.length == 0) {
      new MainFrame(new GearTest(), 700, 700);
    } else {
      try {
        value = Integer.parseInt(args[0]);
      } catch (NumberFormatException e) {
        System.out.println("Illegal integer specified");
        System.out.println("Usage: java GearTest [#teeth]");
        value = 0;
        System.exit(0);
      }
      if (value <= 0) {
        System.out.println("Integer must be positive (> 0)");
        System.out.println("Usage: java GearBox [#teeth]");
        System.exit(0);
      }
      new MainFrame(new GearTest(value), 700, 700);
    }
  }
}
class Gear extends javax.media.j3d.TransformGroup {
  // Specifiers determining whether to generate outward facing normals or
  // inward facing normals.
  static final int OutwardNormals = 1;
  static final int InwardNormals = -1;
  // The number of teeth in the gear
  int toothCount;
  // Gear start differential angle. All gears are constructed with the
  // center of a tooth at Z-axis angle = 0.
  double gearStartAngle;
  // The Z-rotation angle to place the tooth center at theta = 0
  float toothTopCenterAngle;
  // The Z-rotation angle to place the valley center at theta = 0
  float valleyCenterAngle;
  // The angle about Z subtended by one tooth and its associated valley
  float circularPitchAngle;
  // Increment angles
  float toothValleyAngleIncrement;
  // Front and rear facing normals for the gear"s body
  final Vector3f frontNormal = new Vector3f(0.0f, 0.0f, -1.0f);
  final Vector3f rearNormal = new Vector3f(0.0f, 0.0f, 1.0f);
  Gear(int toothCount) {
    this.toothCount = toothCount;
  }
  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;
    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);
  }
  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;
    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);
  }
  public float getToothTopCenterAngle() {
    return toothTopCenterAngle;
  }
  public float getValleyCenterAngle() {
    return valleyCenterAngle;
  }
  public float getCircularPitchAngle() {
    return circularPitchAngle;
  }
}
class GearBox extends Applet {
  static final int defaultToothCount = 48;
  private int toothCount;
  private SimpleUniverse u = null;
  public BranchGroup createGearBox(int toothCount) {
    Transform3D tempTransform = new Transform3D();
    // Create the root of the branch graph
    BranchGroup branchRoot = createBranchEnvironment();
    // Create a Transformgroup to scale all objects so they
    // appear in the scene.
    TransformGroup objScale = new TransformGroup();
    Transform3D t3d = new Transform3D();
    t3d.setScale(0.4);
    objScale.setTransform(t3d);
    branchRoot.addChild(objScale);
    // Create an Appearance.
    Appearance look = new Appearance();
    Color3f objColor = new Color3f(0.5f, 0.5f, 0.6f);
    Color3f black = new Color3f(0.0f, 0.0f, 0.0f);
    Color3f white = new Color3f(1.0f, 1.0f, 1.0f);
    look
        .setMaterial(new Material(objColor, black, objColor, white,
            100.0f));
    // Create the transform group node and initialize it to the
    // identity. Enable the TRANSFORM_WRITE capability so that
    // our behavior code can modify it at runtime. Add it to the
    // root of the subgraph.
    TransformGroup gearboxTrans = new TransformGroup();
    gearboxTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
    gearboxTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
    objScale.addChild(gearboxTrans);
    // Create a bounds for the mouse behavior methods
    BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0),
        100.0);
    // Define the shaft base information
    int shaftCount = 4;
    int secondsPerRevolution = 8000;
    // Create the Shaft(s)
    Shaft shafts[] = new Shaft[shaftCount];
    TransformGroup shaftTGs[] = new TransformGroup[shaftCount];
    Alpha shaftAlphas[] = new Alpha[shaftCount];
    RotationInterpolator shaftRotors[] = new RotationInterpolator[shaftCount];
    Transform3D shaftAxis[] = new Transform3D[shaftCount];
    // Note: the following arrays we"re incorporated to make changing
    // the gearbox easier.
    float shaftRatios[] = new float[shaftCount];
    shaftRatios[0] = 1.0f;
    shaftRatios[1] = 0.5f;
    shaftRatios[2] = 0.75f;
    shaftRatios[3] = 5.0f;
    float shaftRadius[] = new float[shaftCount];
    shaftRadius[0] = 0.2f;
    shaftRadius[1] = 0.2f;
    shaftRadius[2] = 0.2f;
    shaftRadius[3] = 0.2f;
    float shaftLength[] = new float[shaftCount];
    shaftLength[0] = 1.8f;
    shaftLength[1] = 0.8f;
    shaftLength[2] = 0.8f;
    shaftLength[3] = 0.8f;
    float shaftDirection[] = new float[shaftCount];
    shaftDirection[0] = 1.0f;
    shaftDirection[1] = -1.0f;
    shaftDirection[2] = 1.0f;
    shaftDirection[3] = -1.0f;
    Vector3d shaftPlacement[] = new Vector3d[shaftCount];
    shaftPlacement[0] = new Vector3d(-0.75, -0.9, 0.0);
    shaftPlacement[1] = new Vector3d(0.75, -0.9, 0.0);
    shaftPlacement[2] = new Vector3d(0.75, 0.35, 0.0);
    shaftPlacement[3] = new Vector3d(-0.75, 0.60, -0.7);
    // Create the shafts.
    for (int i = 0; i < shaftCount; i++) {
      shafts[i] = new Shaft(shaftRadius[i], shaftLength[i], 25, look);
    }
    // Create a transform group node for placing each shaft
    for (int i = 0; i < shaftCount; i++) {
      shaftTGs[i] = new TransformGroup();
      gearboxTrans.addChild(shaftTGs[i]);
      shaftTGs[i].getTransform(tempTransform);
      tempTransform.setTranslation(shaftPlacement[i]);
      shaftTGs[i].setTransform(tempTransform);
      shaftTGs[i].addChild(shafts[i]);
    }
    // Add rotation interpolators to rotate the shaft in the appropriate
    // direction and at the appropriate rate
    for (int i = 0; i < shaftCount; i++) {
      shaftAlphas[i] = new Alpha(-1, Alpha.INCREASING_ENABLE, 0, 0,
          (long) (secondsPerRevolution * shaftRatios[i]), 0, 0, 0, 0,
          0);
      shaftAxis[i] = new Transform3D();
      shaftAxis[i].rotX(Math.PI / 2.0);
      shaftRotors[i] = new RotationInterpolator(shaftAlphas[i],
          shafts[i], shaftAxis[i], 0.0f, shaftDirection[i]
              * (float) Math.PI * 2.0f);
      shaftRotors[i].setSchedulingBounds(bounds);
      shaftTGs[i].addChild(shaftRotors[i]);
    }
    // Define the gear base information. Again, these arrays exist to
    // make the process of changing the GearBox via an editor faster
    int gearCount = 5;
    float valleyToCircularPitchRatio = .15f;
    float pitchCircleRadius = 1.0f;
    float addendum = 0.05f;
    float dedendum = 0.05f;
    float gearThickness = 0.3f;
    float toothTipThickness = 0.27f;
    // Create an array of gears and their associated information
    SpurGear gears[] = new SpurGear[gearCount];
    TransformGroup gearTGs[] = new TransformGroup[gearCount];
    int gearShaft[] = new int[gearCount];
    gearShaft[0] = 0;
    gearShaft[1] = 1;
    gearShaft[2] = 2;
    gearShaft[3] = 0;
    gearShaft[4] = 3;
    float ratio[] = new float[gearCount];
    ratio[0] = 1.0f;
    ratio[1] = 0.5f;
    ratio[2] = 0.75f;
    ratio[3] = 0.25f;
    ratio[4] = 1.25f;
    Vector3d placement[] = new Vector3d[gearCount];
    placement[0] = new Vector3d(0.0, 0.0, 0.0);
    placement[1] = new Vector3d(0.0, 0.0, 0.0);
    placement[2] = new Vector3d(0.0, 0.0, 0.0);
    placement[3] = new Vector3d(0.0, 0.0, -0.7);
    placement[4] = new Vector3d(0.0, 0.0, 0.0);
    // Create the gears.
    for (int i = 0; i < gearCount; i++) {
      gears[i] = new SpurGearThinBody(
          ((int) ((float) toothCount * ratio[i])), pitchCircleRadius
              * ratio[i], shaftRadius[0], addendum, dedendum,
          gearThickness, toothTipThickness,
          valleyToCircularPitchRatio, look);
    }
    // Create a transform group node for arranging the gears on a shaft
    // and attach the gear to its associated shaft
    for (int i = 0; i < gearCount; i++) {
      gearTGs[i] = new TransformGroup();
      gearTGs[i].getTransform(tempTransform);
      tempTransform
          .rotZ((shaftDirection[gearShaft[i]] == -1.0) ? gears[i]
              .getCircularPitchAngle()
              / -2.0f : 0.0f);
      tempTransform.setTranslation(placement[i]);
      gearTGs[i].setTransform(tempTransform);
      gearTGs[i].addChild(gears[i]);
      shafts[gearShaft[i]].addChild(gearTGs[i]);
    }
    // Have Java 3D perform optimizations on this scene graph.
    branchRoot.rupile();
    return branchRoot;
  }
  BranchGroup createBranchEnvironment() {
    // Create the root of the branch graph
    BranchGroup branchRoot = new BranchGroup();
    // Create a bounds for the background and lights
    BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0),
        100.0);
    // Set up the background
    Color3f bgColor = new Color3f(0.05f, 0.05f, 0.5f);
    Background bgNode = new Background(bgColor);
    bgNode.setApplicationBounds(bounds);
    branchRoot.addChild(bgNode);
    // Set up the ambient light
    Color3f ambientColor = new Color3f(0.1f, 0.1f, 0.1f);
    AmbientLight ambientLightNode = new AmbientLight(ambientColor);
    ambientLightNode.setInfluencingBounds(bounds);
    branchRoot.addChild(ambientLightNode);
    // Set up the directional lights
    Color3f light1Color = new Color3f(1.0f, 1.0f, 0.9f);
    Vector3f light1Direction = new Vector3f(1.0f, 1.0f, 1.0f);
    Color3f light2Color = new Color3f(1.0f, 1.0f, 0.9f);
    Vector3f light2Direction = new Vector3f(-1.0f, -1.0f, -1.0f);
    DirectionalLight light1 = new DirectionalLight(light1Color,
        light1Direction);
    light1.setInfluencingBounds(bounds);
    branchRoot.addChild(light1);
    DirectionalLight light2 = new DirectionalLight(light2Color,
        light2Direction);
    light2.setInfluencingBounds(bounds);
    branchRoot.addChild(light2);
    return branchRoot;
  }
  public GearBox() {
    this(defaultToothCount);
  }
  public GearBox(int toothCount) {
    this.toothCount = toothCount;
  }
  public void init() {
    setLayout(new BorderLayout());
    GraphicsConfiguration config = SimpleUniverse
        .getPreferredConfiguration();
    Canvas3D c = new Canvas3D(config);
    add("Center", c);
    // Create the gearbox and attach it to the virtual universe
    BranchGroup scene = createGearBox(toothCount);
    u = new SimpleUniverse(c);
    // add mouse behaviors to the ViewingPlatform
    ViewingPlatform viewingPlatform = u.getViewingPlatform();
    // This will move the ViewPlatform back a bit so the
    // objects in the scene can be viewed.
    viewingPlatform.setNominalViewingTransform();
    // add orbit behavior to the ViewingPlatform
    OrbitBehavior orbit = new OrbitBehavior(c, OrbitBehavior.REVERSE_ALL);
    BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0),
        100.0);
    orbit.setSchedulingBounds(bounds);
    viewingPlatform.setViewPlatformBehavior(orbit);
    u.addBranchGraph(scene);
  }
  public void destroy() {
    u.cleanup();
  }
  //
  // The following allows GearBox to be run as an application
  // as well as an applet
  //
  public static void main(String[] args) {
    int value;
    if (args.length > 1) {
      System.out.println("Usage: java GearBox  #teeth (LCD 4)");
      System.exit(0);
    } else if (args.length == 0) {
      new MainFrame(new GearBox(), 700, 700);
    } else {
      try {
        value = Integer.parseInt(args[0]);
      } catch (NumberFormatException e) {
        System.out.println("Illegal integer specified");
        System.out.println("Usage: java GearBox  #teeth (LCD 4)");
        value = 0;
        System.exit(0);
      }
      if (value <= 0 | (value % 4) != 0) {
        System.out.println("Integer not a positive multiple of 4");
        System.out.println("Usage: java GearBox  #teeth (LCD 4)");
        System.exit(0);
      }
      new MainFrame(new GearBox(value), 700, 700);
    }
  }
}
class SpurGear extends Gear {
  float toothTopAngleIncrement;
  float toothDeclineAngleIncrement;
  float rootRadius;
  float outsideRadius;
  //The angle subtended by the ascending or descending portion of a tooth
  float circularToothEdgeAngle;
  // The angle subtended by a flat (either a tooth top or a valley
  // between teeth
  float circularToothFlatAngle;
  /**
   * internal constructor for SpurGear, used by subclasses to establish
   * SpurGear"s required state
   * 
   * @return a new spur gear that contains sufficient information to continue
   *         building
   * @param toothCount
   *            number of teeth
   * @param pitchCircleRadius
   *            radius at center of teeth
   * @param addendum
   *            distance from pitch circle to top of teeth
   * @param dedendum
   *            distance from pitch circle to root of teeth
   * @param toothToValleyAngleRatio
   *            the ratio of the angle subtended by the tooth to the angle
   *            subtended by the valley (must be <= .25)
   */
  SpurGear(int toothCount, float pitchCircleRadius, float addendum,
      float dedendum, float toothToValleyAngleRatio) {
    super(toothCount);
    // The angle about Z subtended by one tooth and its associated valley
    circularPitchAngle = (float) (2.0 * Math.PI / (double) toothCount);
    // The angle subtended by a flat (either a tooth top or a valley
    // between teeth
    circularToothFlatAngle = circularPitchAngle * toothToValleyAngleRatio;
    //The angle subtended by the ascending or descending portion of a tooth
    circularToothEdgeAngle = circularPitchAngle / 2.0f
        - circularToothFlatAngle;
    // Increment angles
    toothTopAngleIncrement = circularToothEdgeAngle;
    toothDeclineAngleIncrement = toothTopAngleIncrement
        + circularToothFlatAngle;
    toothValleyAngleIncrement = toothDeclineAngleIncrement
        + circularToothEdgeAngle;
    // Differential angles for offsetting to the center of tooth"s top
    // and valley
    toothTopCenterAngle = toothTopAngleIncrement + circularToothFlatAngle
        / 2.0f;
    valleyCenterAngle = toothValleyAngleIncrement + circularToothFlatAngle
        / 2.0f;
    // Gear start differential angle. All gears are constructed with the
    // center of a tooth at Z-axis angle = 0.
    gearStartAngle = -1.0 * toothTopCenterAngle;
    // The radial distance to the root and top of the teeth, respectively
    rootRadius = pitchCircleRadius - dedendum;
    outsideRadius = pitchCircleRadius + addendum;
    // Allow this object to spin. etc.
    this.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
  }
  /**
   * Construct a SpurGear;
   * 
   * @return a new spur gear that conforms to the input paramters
   * @param toothCount
   *            number of teeth
   * @param pitchCircleRadius
   *            radius at center of teeth
   * @param shaftRadius
   *            radius of hole at center
   * @param addendum
   *            distance from pitch circle to top of teeth
   * @param dedendum
   *            distance from pitch circle to root of teeth
   * @param gearThickness
   *            thickness of the gear
   */
  public SpurGear(int toothCount, float pitchCircleRadius, float shaftRadius,
      float addendum, float dedendum, float gearThickness) {
    this(toothCount, pitchCircleRadius, shaftRadius, addendum, dedendum,
        gearThickness, gearThickness, 0.25f, null);
  }
  /**
   * Construct a SpurGear;
   * 
   * @return a new spur gear that conforms to the input paramters
   * @param toothCount
   *            number of teeth
   * @param pitchCircleRadius
   *            radius at center of teeth
   * @param shaftRadius
   *            radius of hole at center
   * @param addendum
   *            distance from pitch circle to top of teeth
   * @param dedendum
   *            distance from pitch circle to root of teeth
   * @param gearThickness
   *            thickness of the gear
   * @param look
   *            the gear"s appearance
   */
  public SpurGear(int toothCount, float pitchCircleRadius, float shaftRadius,
      float addendum, float dedendum, float gearThickness, Appearance look) {
    this(toothCount, pitchCircleRadius, shaftRadius, addendum, dedendum,
        gearThickness, gearThickness, 0.25f, look);
  }
  /**
   * Construct a SpurGear;
   * 
   * @return a new spur gear that conforms to the input paramters
   * @param toothCount
   *            number of teeth
   * @param pitchCircleRadius
   *            radius at center of teeth
   * @param shaftRadius
   *            radius of hole at center
   * @param addendum
   *            distance from pitch circle to top of teeth
   * @param dedendum
   *            distance from pitch circle to root of teeth
   * @param gearThickness
   *            thickness of the gear
   * @param toothTipThickness
   *            thickness of the tip of the tooth
   * @param look
   *            the gear"s appearance
   */
  public SpurGear(int toothCount, float pitchCircleRadius, float shaftRadius,
      float addendum, float dedendum, float gearThickness,
      float toothTipThickness, Appearance look) {
    this(toothCount, pitchCircleRadius, shaftRadius, addendum, dedendum,
        gearThickness, toothTipThickness, 0.25f, look);
  }
  /**
   * Construct a SpurGear;
   * 
   * @return a new spur gear that conforms to the input paramters
   * @param toothCount
   *            number of teeth
   * @param pitchCircleRadius
   *            radius at center of teeth
   * @param shaftRadius
   *            radius of hole at center
   * @param addendum
   *            distance from pitch circle to top of teeth
   * @param dedendum
   *            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
   */
  public SpurGear(int toothCount, float pitchCircleRadius, float shaftRadius,
      float addendum, float dedendum, float gearThickness,
      float toothTipThickness, float toothToValleyAngleRatio,
      Appearance look) {
    this(toothCount, pitchCircleRadius, addendum, dedendum,
        toothToValleyAngleRatio);
    // Generate the gear"s body disks
    addBodyDisks(shaftRadius, rootRadius, gearThickness, look);
    // Generate the gear"s interior shaft
    addCylinderSkins(shaftRadius, gearThickness, InwardNormals, look);
    // Generate the gear"s teeth
    addTeeth(pitchCircleRadius, rootRadius, outsideRadius, gearThickness,
        toothTipThickness, toothToValleyAngleRatio, look);
  }
  /**
   * Construct a SpurGear"s teeth by adding the teeth shape nodes
   * 
   * @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);
  }
}
class SpurGearThinBody extends SpurGear {
  /**
   * Construct a SpurGearThinBody;
   * 
   * @return a new spur gear that conforms to the input paramters
   * @param toothCount
   *            number of teeth
   * @param pitchCircleRadius
   *            radius at center of teeth
   * @param shaftRadius
   *            radius of hole at center
   * @param addendum
   *            distance from pitch circle to top of teeth
   * @param dedendum
   *            distance from pitch circle to root of teeth
   * @param gearThickness
   *            thickness of the gear
   */
  public SpurGearThinBody(int toothCount, float pitchCircleRadius,
      float shaftRadius, float addendum, float dedendum,
      float gearThickness) {
    this(toothCount, pitchCircleRadius, shaftRadius, addendum, dedendum,
        gearThickness, gearThickness, 0.25f, null);
  }
  /**
   * Construct a SpurGearThinBody;
   * 
   * @return a new spur gear that conforms to the input paramters
   * @param toothCount
   *            number of teeth
   * @param pitchCircleRadius
   *            radius at center of teeth
   * @param shaftRadius
   *            radius of hole at center
   * @param addendum
   *            distance from pitch circle to top of teeth
   * @param dedendum
   *            distance from pitch circle to root of teeth
   * @param gearThickness
   *            thickness of the gear
   * @param look
   *            the gear"s appearance
   */
  public SpurGearThinBody(int toothCount, float pitchCircleRadius,
      float shaftRadius, float addendum, float dedendum,
      float gearThickness, Appearance look) {
    this(toothCount, pitchCircleRadius, shaftRadius, addendum, dedendum,
        gearThickness, gearThickness, 0.25f, look);
  }
  /**
   * Construct a SpurGearThinBody;
   * 
   * @return a new spur gear that conforms to the input paramters
   * @param toothCount
   *            number of teeth
   * @param pitchCircleRadius
   *            radius at center of teeth
   * @param shaftRadius
   *            radius of hole at center
   * @param addendum
   *            distance from pitch circle to top of teeth
   * @param dedendum
   *            distance from pitch circle to root of teeth
   * @param gearThickness
   *            thickness of the gear
   * @param toothTipThickness
   *            thickness of the tip of the tooth
   * @param look
   *            the gear"s appearance
   */
  public SpurGearThinBody(int toothCount, float pitchCircleRadius,
      float shaftRadius, float addendum, float dedendum,
      float gearThickness, float toothTipThickness, Appearance look) {
    this(toothCount, pitchCircleRadius, shaftRadius, addendum, dedendum,
        gearThickness, toothTipThickness, 0.25f, look);
  }
  /**
   * Construct a SpurGearThinBody;
   * 
   * @return a new spur gear that conforms to the input paramters
   * @param toothCount
   *            number of teeth
   * @param pitchCircleRadius
   *            radius at center of teeth
   * @param shaftRadius
   *            radius of hole at center
   * @param addendum
   *            distance from pitch circle to top of teeth
   * @param dedendum
   *            distance from pitch circle to root of teeth
   * @param gearThickness
   *            thickness of the gear
   * @param toothTipThickness
   *            thickness of the tip of the tooth
   * @param toothToValleyRatio
   *            ratio of tooth valley to circular pitch (must be <= .25)
   * @param look
   *            the gear"s appearance object
   */
  public SpurGearThinBody(int toothCount, float pitchCircleRadius,
      float shaftRadius, float addendum, float dedendum,
      float gearThickness, float toothTipThickness,
      float toothToValleyAngleRatio, Appearance look) {
    this(toothCount, pitchCircleRadius, shaftRadius, addendum, dedendum,
        gearThickness, toothTipThickness, 0.25f, look,
        0.6f * gearThickness, 0.75f * (pitchCircleRadius - shaftRadius));
  }
  /**
   * Construct a SpurGearThinBody;
   * 
   * @return a new spur gear that conforms to the input paramters
   * @param toothCount
   *            number of teeth
   * @param pitchCircleRadius
   *            radius at center of teeth
   * @param shaftRadius
   *            radius of hole at center
   * @param addendum
   *            distance from pitch circle to top of teeth
   * @param dedendum
   *            distance from pitch circle to root of teeth
   * @param gearThickness
   *            thickness of the gear
   * @param toothTipThickness
   *            thickness of the tip of the tooth
   * @param toothToValleyRatio
   *            ratio of tooth valley to circular pitch (must be <= .25)
   * @param look
   *            the gear"s appearance object
   * @param bodyThickness
   *            the thickness of the gear body
   * @param crossSectionWidth
   *            the width of the depressed portion of the gear"s body
   */
  public SpurGearThinBody(int toothCount, float pitchCircleRadius,
      float shaftRadius, float addendum, float dedendum,
      float gearThickness, float toothTipThickness,
      float toothToValleyAngleRatio, Appearance look,
      float bodyThickness, float crossSectionWidth) {
    super(toothCount, pitchCircleRadius, addendum, dedendum,
        toothToValleyAngleRatio);
    float diskCrossSectionWidth = (rootRadius - shaftRadius - crossSectionWidth) / 2.0f;
    float outerShaftRadius = shaftRadius + diskCrossSectionWidth;
    float innerToothRadius = rootRadius - diskCrossSectionWidth;
    // Generate the gear"s body disks, first by the shaft, then in
    // the body and, lastly, by the teeth
    addBodyDisks(shaftRadius, outerShaftRadius, gearThickness, look);
    addBodyDisks(innerToothRadius, rootRadius, gearThickness, look);
    addBodyDisks(outerShaftRadius, innerToothRadius, bodyThickness, look);
    // Generate the gear"s "shaft" equivalents the two at the teeth
    // and the two at the shaft
    addCylinderSkins(innerToothRadius, gearThickness, InwardNormals, look);
    addCylinderSkins(outerShaftRadius, gearThickness, OutwardNormals, look);
    // Generate the gear"s interior shaft
    addCylinderSkins(shaftRadius, gearThickness, InwardNormals, look);
    // Generate the gear"s teeth
    addTeeth(pitchCircleRadius, rootRadius, outsideRadius, gearThickness,
        toothTipThickness, toothToValleyAngleRatio, look);
  }
}
class Shaft extends javax.media.j3d.TransformGroup {
  /**
   * Construct a Shaft;
   * 
   * @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);
  }
}