simpletest.java

Java3D程序,实现各种立体变换.适于基础编程.

import java.applet.Applet;


import javax.media.j3d.*;
import javax.vecmath.*;


import com.sun.j3d.utils.geometry.*;
import com.sun.j3d.utils.universe.*;
import com.sun.j3d.utils.image.TextureLoader;

/*
 * This example builds a simple Java 3D application using the
 * Sun utility classes: MainFrame and SimpleUniverse.
 * The example displays a moving sphere, in front of a
 * background image. It uses a texture image and one light
 * to increase the visual impact of the scene.
 */
public class SimpleTest extends Applet
{
 /*
  * Create a simple Java 3D environment containing:
  * a sphere (geometry), a light,background geometry
  * with an applied texture, and a behavior that will
  * move the sphere along the X-axis.
  */
 public SimpleTest()
 {
  // create the SimpleUniverse class that will
  // encapsulate the scene that we are building.
  // SimpleUniverse is a helper class (utility)
  // from SUN that is included with the core Java 3D
  // distribution.
  SimpleUniverse u = new SimpleUniverse();

  // create a BranchGroup. A BranchGroup is a node in
  // a Tree data structure that can have child nodes
  BranchGroup bgRoot = new BranchGroup();

  // create the Background node and add it to the SimpleUniverse
  u.addBranchGraph( createBackground() );

  // create the behaviors to move the geometry along the X-axis.
  // The behavior is added as a child of the bgRoot node. 
  // Anything added as a child of the tg node will be effected by the
  // behavior (will be moved along the X-axis).
  TransformGroup tg = createBehaviors( bgRoot );

  // add the Sphere geometry as a child of the tg
  // so that it will be moved along the X-axis.
  tg.addChild( createSceneGraph() );

  // because the sphere was added at the 0,0,0 coordinate
  // and by default the viewer is also located at 0,0,0
  // we have to move the viewer back a little so that
  // she can see the scene.
  u.getViewingPlatform().setNominalViewingTransform();

  // add a light to the root BranchGroup to illuminate the scene
  addLights( bgRoot );

  // finally wire everything together by adding the root
  // BranchGroup to the SimpleUniverse
  u.addBranchGraph( bgRoot );
 }

 /*
  * Create the geometry for the scene. In this case
  * we simply create a Sphere 
  * (a built-in Java 3D primitive).
  */
 public BranchGroup createSceneGraph()
 {
  // create a parent BranchGroup node for the Sphere
  BranchGroup bg = new BranchGroup();

  // create an Appearance for the Sphere.
  // The Appearance object controls various rendering
  // options for the Sphere geometry.
  Appearance app = new Appearance();

  // assign a Material to the Appearance. For the Sphere
  // to respond to the light in the scene it must have a Material.
  // Assign some colors to the Material and a shininess setting
  // that controls how reflective the surface is to lighting.
  Color3f objColor = new Color3f(1.0f, 1.0f, 1.0f);
  Color3f black = new Color3f(0.0f, 0.0f, 0.0f);
  app.setMaterial(new Material(objColor, black, objColor, black,
    20.0f));

  // create a Sphere with a radius of 0.1
  // and associate the Appearance that we described.
  // the option GENERATE_NORMALS is required to ensure that the
  // Sphere responds correctly to lighting.
    //Sphere sphere = new Sphere( 0.3f, Primitive.GENERATE_NORMALS,app );
  Cone myCone = new Cone(0.2f,1.4f);
    
  // add the sphere to the BranchGroup to wire
  // it into the scene.
    //bg.addChild( sphere );
    bg.addChild(myCone);
  return bg;
 }


 /*
  * Add a directional light to the BranchGroup.
  */
 public void addLights( BranchGroup bg )
 {
  // create the color for the light
  Color3f color = new Color3f( 0.0f,0.0f,1.0f );


  // create a vector that describes the direction that
  // the light is shining.
  Vector3f direction  = new Vector3f( -1.0f,-1.0f,1.0f );


  // create the directional light with the color and direction
  DirectionalLight light = new DirectionalLight( color, direction );


  // set the volume of influence of the light. 
  // Only objects within the Influencing Bounds
  // will be illuminated.
  light.setInfluencingBounds( getBoundingSphere() );


  // add the light to the BranchGroup
  bg.addChild( light );
 }


 /*
  * Create some Background geometry to use as
  * a backdrop for the application. Here we create
  * a Sphere that will enclose the entire scene and
  * apply a texture image onto the inside of the Sphere
  * to serve as a graphical backdrop for the scene.
  */
 public BranchGroup createBackground()
 {
  // create a parent BranchGroup for the Background
  BranchGroup backgroundGroup = new BranchGroup();


  // create a new Background node
  Background back = new Background();


  // set the range of influence of the background
  back.setApplicationBounds( getBoundingSphere() );


  // create a BranchGroup that will hold
  // our Sphere geometry
  BranchGroup bgGeometry = new BranchGroup();


  // create an appearance for the Sphere
  Appearance app = new Appearance(); 


  // load a texture image using the Java 3D texture loader   
  Texture tex = new TextureLoader( "back.jpg", this).getTexture();


  // apply the texture to the Appearance
  app.setTexture( tex );


  // create the Sphere geometry with radius 1.0.
  // we tell the Sphere to generate texture coordinates
  // to enable the texture image to be rendered
  // and because we are *inside* the Sphere we have to generate 
  // Normal coordinates inwards or the Sphere will not be visible.
  Sphere sphere = new Sphere( 1.0f,
              Primitive.GENERATE_TEXTURE_COORDS |

              Primitive.GENERATE_NORMALS_INWARD, app );


  // start wiring everything together,
  // add the Sphere to its parent BranchGroup.

  bgGeometry.addChild( sphere );

  // assign the BranchGroup to the Background as geometry.

  back.setGeometry( bgGeometry );

  // add the Background node to its parent BranchGroup.

  backgroundGroup.addChild( back );
  return backgroundGroup;
 }


 /*
  * Create a behavior to move child nodes along the X-axis.
  * The behavior is added to the BranchGroup bg, whereas
  * any nodes added to the returned TransformGroup will be
  * effected by the behavior.
  */

 public TransformGroup createBehaviors( BranchGroup bg )

 {
  // create a TransformGroup.
  //
  // A TransformGroup is a Group node (can have children)
  // and contains a Transform3D member.
  //
  // The Transform3D member contains a 4x4 transformation matrix
  // that is applied during rendering to all the TransformGroup's
  // child nodes. The 4x4 matrix can describe:
  // scaling, translation and rotation in one neat package!
  // enable the TRANSFORM_WRITE capability so that
  // our behavior code can modify it at runtime.

  TransformGroup objTrans = new TransformGroup();
  objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

  // create a new Transform3D that will describe
  // the direction we want to move.

  Transform3D xAxis = new Transform3D();

  // create an Alpha object.
  // The Alpha object describes a function against time.
  // The Alpha will output a value that ranges between 0 and 1
  // using the time parameters (in milliseconds).

  Alpha xAlpha = new Alpha( -1,
            Alpha.DECREASING_ENABLE |
            Alpha.INCREASING_ENABLE,
 //         1000,1000,5000,1000,1000,10000,2000,4000);
            0,0,400,400,0,400,400,0);

  // create a PositionInterpolator.
  // The PositionInterpolator will modify the translation components
  // of a TransformGroup's Transform3D (objTrans) based on the output
  // from the Alpha. In this case the movement will range from
  // -0.8 along the X-axis with Alpha=0 to X=0.8 when Alpha=1.

  PositionInterpolator posInt = new PositionInterpolator(  xAlpha,
                 objTrans,
                 xAxis, -0.8f, 0.8f );

  // set the range of influence of the PositionInterpolator

  posInt.setSchedulingBounds( getBoundingSphere() );

  // wire the PositionInterpolator into its parent
  // TransformGroup. Just like rendering nodes behaviors
  // must be added to the scenegraph.

  objTrans.addChild( posInt );

  // add the TransformGroup to its parent BranchGroup

  bg.addChild( objTrans );

  // we return the TransformGroup with the
  // behavior attached so that we can add nodes to it
  // (which will be effected by the PositionInterpolator).

  return objTrans;
 }

 /*
  * Return a BoundingSphere that describes the 
  * volume of the scene.
  */

 BoundingSphere getBoundingSphere()

 {
  return new BoundingSphere( new Point3d(0.0,0.0,0.0), 200.0 );
 }

 /*
  * main entry point for the Application.
  */

 public static void main(String[] args)
 {
  SimpleTest simpleTest = new SimpleTest();
 }
}