Java tutorial
/******************************************************************************* * Copyright (C) 2001 Daniel Selman * * First distributed with the book "Java 3D Programming" by Daniel Selman and * published by Manning Publications. http://manning.com/selman * * This program is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation, version 2. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * The license can be found on the WWW at: http://www.fsf.org/copyleft/gpl.html * * Or by writing to: Free Software Foundation, Inc., 59 Temple Place - Suite * 330, Boston, MA 02111-1307, USA. * * Authors can be contacted at: Daniel Selman: daniel@selman.org * * If you make changes you think others would like, please contact one of the * authors or someone at the www.j3d.org web site. ******************************************************************************/ import java.applet.Applet; import javax.media.j3d.Alpha; import javax.media.j3d.Appearance; import javax.media.j3d.Background; import javax.media.j3d.BoundingSphere; import javax.media.j3d.BranchGroup; import javax.media.j3d.DirectionalLight; import javax.media.j3d.Material; import javax.media.j3d.PositionInterpolator; import javax.media.j3d.Texture; import javax.media.j3d.Transform3D; import javax.media.j3d.TransformGroup; import javax.vecmath.Color3f; import javax.vecmath.Point3d; import javax.vecmath.Vector3f; import com.sun.j3d.utils.geometry.Primitive; import com.sun.j3d.utils.geometry.Sphere; import com.sun.j3d.utils.image.TextureLoader; import com.sun.j3d.utils.universe.SimpleUniverse; /* * 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 add as a child of the tg node will be effected by the // behvior (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, 80.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.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, 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); // 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(); } }