< Zurück | Inhalt | Weiter >

From SimpleTest.java

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(0.8f, 0.2f, 1.0f);

Color3f black = new Color3f(0.0f, 0.0f, 0.0f); app.setMaterial(new Material(objColor, black, objColor, black,


// 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.1f, Primitive.GENERATE_NORMALS, app );

// add the sphere to the BranchGroup to wire

// it into the scene. bg.addChild( sphere ); return bg;



* Add a directional light to the BranchGroup.


public void addLights( BranchGroup bg )


// create the color for the light

Color3f color = new Color3f( 1.0f,1.0f,0.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,


// 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();


// 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,









4000 );

// 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,


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();