DOC

The Joy of Java 3D

By Veronica Bradley,2014-04-24 11:38
26 views 0
The Joy of Java 3D

The Joy of Java 3D

by Greg Hopkins

Copyright ? 2001-2007

    Introduction

Java 3D is an addition to Java for displaying three-dimensional graphics. Programs written in Java 3D can

    be run on several different types of computer and over the internet.

The Java 3D class library provides a simpler interface than most other graphics libraries, but has enough

    capabilities to produce good games and animation. Java 3D builds on existing technology such as DirectX

    and OpenGL so the programs do not run as slowly as you might expect. Also, Java 3D can incorporate

    objects created by 3D modeling packages like TrueSpace and VRML models.

This tutorial is an introduction to Java 3D. Examples lead you through the basic methods for producing 3D

    images and animation. You do not need to have any knowledge of 3D graphics or Java 3D to learn from

    this tutorial, but it will help if you have a basic understanding of the Java programming language.

    Programming in three dimensions can seem complicated because of the amount of jargon and the

    mathematics involved, this tutorial will keep things as simple as possible.

Please help to improve this tutorial for future readers by reporting any mistakes you find or suggesting

    improvements to editor@java3d.org.

Installing and Running Java 3D

The software you need to use Java 3D is available free from Sun Microsystems at http://java.sun.com/.

Sun often releases new versions so it is better to look at their site than rely on this document to find what

    you need. You will have to register as a member of "Java Developer Connection" to download some of the

    files.

At time of writing, the newest version of Java (6.3) is at http://java.sun.com/javase/downloads/index.jsp.

    The current version of the Java 3D extension (1.5.1) is at https://java3d.dev.java.net/#Downloads Netscape

    and Internet Explorer both require you to download plug-ins if you want to use up-to-date versions of Java

    and Java3D in applets, the plug-in can be found at http://java.sun.com/products/plugin/.

Once you have installed Java and Java 3D you can compile programs using the command:

javac FileName.java

And run them using:

java FileName

The FileName should always be the same as the name of the public class defined in that file. In some

    versions of Java 3D you may get a message about a null graphics configuration, but you can just ignore this.

     1

Getting Started Your First Program

The following program shows you the basic steps needed to display 3D objects.

    1. Create a virtual universe to contain your scene. 2. Create a data structure to contain a group of objects. 3. Add an object to the group

    4. Position the viewer so that they are looking at the object

    5. Add the group of objects to the universe

Look at the Hello3d() constructor and you will see the five lines that perform each of these steps. The

    program displays a glowing cube, the viewer is looking directly at the red face of the cube, so what you

    actually see is a red square on a black background

import com.sun.j3d.utils.universe.SimpleUniverse;

    import com.sun.j3d.utils.geometry.ColorCube;

    import com.sun.j3d.utils.geometry.Sphere;

    import javax.media.j3d.BranchGroup;

public class Hello3d {

public Hello3d()

    {

     SimpleUniverse universe = new SimpleUniverse();

     BranchGroup group = new BranchGroup();

     group.addChild(new ColorCube(0.3));

     universe.getViewingPlatform().setNominalViewingTransform();

     universe.addBranchGraph(group);

    }

public static void main( String[] args ) {

     new Hello3d();

    }

    } // end of class Hello3d

The import statements at the beginning of this program use various parts of Java 3D, so compiling and

    running this program is a good test that you have installed Java 3D correctly.

     2

Lighting up the World

OK, the first example was a good start, but was it 3D? If you don’t think a square

    qualifies as three-dimensional, you are going to need to add some lights to your

    universe. The way the light falls on an object provides us with the shading that

    helps us see shapes in three dimensions

The next example illustrates how to display a ball lit by a red light:

import com.sun.j3d.utils.geometry.*;

    import com.sun.j3d.utils.universe.*;

    import javax.media.j3d.*;

    import javax.vecmath.*;

public class Ball {

     public Ball() {

     // Create the universe

     SimpleUniverse universe = new SimpleUniverse();

     // Create a structure to contain objects

     BranchGroup group = new BranchGroup();

     // Create a ball and add it to the group of objects

     Sphere sphere = new Sphere(0.5f);

     group.addChild(sphere);

     // Create a red light that shines for 100m from the origin

     Color3f light1Color = new Color3f(1.8f, 0.1f, 0.1f);

     BoundingSphere bounds =

     new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);

     Vector3f light1Direction = new Vector3f(4.0f, -7.0f, -12.0f);

     DirectionalLight light1

     = new DirectionalLight(light1Color, light1Direction);

     light1.setInfluencingBounds(bounds);

     group.addChild(light1);

     // look towards the ball

     universe.getViewingPlatform().setNominalViewingTransform();

     // add the group of objects to the Universe

     universe.addBranchGraph(group);

    }

     public static void main(String[] args) { new Ball(); }

    }

    The sphere we created is white (the default), it appears red because of the colored light. Since it is a DirectionalLight, we also have to specify how far the light shines and in what direction. In the example, the light shines for 100 meters from the origin and the direction is to the right, down and into the screen (this is defined by the vector: 4.0 right, -7.0 down, and -12.0 into the screen).

    You can also create an AmbientLight which will produce a directionless light, or a SpotLight if you want to focus on a particular part of your scene. A combination of a strong directional light and a weaker ambient light gives a natural-looking appearance to your scene. Java 3D lights do not produce shadows.

     3

Positioning the Objects

So far, the examples have created objects in the same place, the center

    of the universe. In Java 3D, locations are described by using x, y, z

    coordinates. Increasing coordinates go along the x-axis to the right,

    along the y-axis upwards, and along the z-axis out of the screen. In the

    picture, x, y and z are represented by spheres, cones and cylinders.

This is called a “right-handed” coordinate system because the thumb

    and first two fingers of your right hand can be used to represent the

    three directions. All the distances are measured in meters.

    To place your objects in the scene, you start at point (0,0,0), and then move the objects wherever you want.

    Moving the objects is called a “transformation”, so the classes you use are: TransformGroup and

    Transform3D. You add both the object and the Transform3D to a TransformGroup before adding the

    TransformGroup to the rest of your scene.

1. Create a transform, a transform group and an object Transform transform= new Transform3D();

    TransformGroup tg = new TransformGroup();

    Cone cone = new Cone(0.5f, 0.5f);

    2. Specify a location for the object Vector3f vector = new Vector3f(-.2f,.1f , -.4f);

    3. Set the transform to move (translate) the object to transform.setTranslation(vector);

    that location

    4. Add the transform to the transform group tg.setTransform(transform); 5. Add the object to the transform group tg.addChild(cone);

This may seem complicated, but the transform groups enable you to collect objects together and move them

    as one unit. For example, a table could be made up of cylinders for legs and a box for the top. If you add all

    the parts of the table to a single transform group, you can move the whole table with one translation.

The Transform3D class can do much more than specifying the co-ordinates of the object. The functions

    include setScale to change the size of an object and rotX, rotY and rotZ for rotating an object around each

    axis (counter clockwise).

This example displays the different objects on each axis.

import com.sun.j3d.utils.geometry.*;

    import com.sun.j3d.utils.universe.*;

    import javax.media.j3d.*;

    import javax.vecmath.*;

public class Position {

     public Position() {

     SimpleUniverse universe = new SimpleUniverse();

     BranchGroup group = new BranchGroup();

     // X axis made of spheres

     for (float x = -1.0f; x <= 1.0f; x = x + 0.1f)

     {

     Sphere sphere = new Sphere(0.05f);

     TransformGroup tg = new TransformGroup();

     Transform3D transform = new Transform3D();

     Vector3f vector = new Vector3f( x, .0f, .0f);

     4

     transform.setTranslation(vector);

     tg.setTransform(transform);

     tg.addChild(sphere);

     group.addChild(tg);

     }

     // Y axis made of cones

     for (float y = -1.0f; y <= 1.0f; y = y + 0.1f)

     {

     TransformGroup tg = new TransformGroup();

     Transform3D transform = new Transform3D();

     Cone cone = new Cone(0.05f, 0.1f);

     Vector3f vector = new Vector3f(.0f, y, .0f);

     transform.setTranslation(vector);

     tg.setTransform(transform);

     tg.addChild(cone);

     group.addChild(tg);

     }

     // Z axis made of cylinders

     for (float z = -1.0f; z <= 1.0f; z = z+ 0.1f)

     {

     TransformGroup tg = new TransformGroup();

     Transform3D transform = new Transform3D();

     Cylinder cylinder = new Cylinder(0.05f, 0.1f);

     Vector3f vector = new Vector3f(.0f, .0f, z);

     transform.setTranslation(vector);

     tg.setTransform(transform);

     tg.addChild(cylinder);

     group.addChild(tg);

     }

     Color3f light1Color = new Color3f(.1f, 1.4f, .1f); // green light

     BoundingSphere bounds =

     new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);

     Vector3f light1Direction = new Vector3f(4.0f, -7.0f, -12.0f);

     DirectionalLight light1

     = new DirectionalLight(light1Color, light1Direction);

     light1.setInfluencingBounds(bounds);

     group.addChild(light1);

     universe.getViewingPlatform().setNominalViewingTransform();

     // add the group of objects to the Universe

     universe.addBranchGraph(group);

    }

     public static void main(String[] args) {

     new Position();

     }

    }

     5

Appearance Is Everything

There are many ways to change the way that objects in your scene look.

    You can change their color, how much light they reflect. You can paint

    them with two-dimensional images, or add rough textures to their

    surfaces. The Appearance class contains the functions for making these

    changes. This section shows you how to use these functions.

The simplest way of setting the appearance is by specifying only the

    color and the shading method. This works for setting an object to being

    a simple color, but to make an object look realistic, you need to specify

    how an object appears under lights. You do this by creating a Material.

    1. Create an object Sphere sphere = new Sphere(); 2. Create an appearance Appearance ap = new Appearance(); 3. Create a color Color3f col = new Color3f(0.0f, 0.0f, 1.0f); 4. Create the coloring attributes ColoringAttributes ca = new ColoringAttributes

    (col, ColoringAttributes.NICEST); 5. Add the attributes to the appearance ap.setColoringAttributes(ca); 6. Set the appearance for the object sphere.setAppearance(ap); Materials

    Materials have five properties that enable you to specify how the object appears. There are four colors:

    Ambient, Emissive, Diffuse, and Specular. The fifth property is shininess, that you specify with a number.

    Each color specifies what light is given off in a certain situation.

? Ambient color reflects light that been scattered so much by the environment that the direction is

    impossible to determine. This is created by an AmbientLight in Java 3D.

    ? Emissive color is given off even in darkness. You could use this for a neon sign or a glow-in-the-dark

    object

    ? Diffuse color reflects light that comes from one direction, so it's brighter if it comes squarely down on

    a surface that if it barely glances off the surface. This is used with a DirectionalLight.

    ? Specular light comes from a particular direction, and it tends to bounce off the surface in a preferred

    direction. Shiny metal or plastic have a high specular component. The amount of specular light that

    reaches the viewer depends on the location of the viewer and the angle of the light bouncing off the

    object.

Changing the shininess factor affects not just how shiny the object is, but whether it shines with a small

    glint in one area, or a larger area with less of a gleaming look.

For most objects you can use one color for both Ambient and Diffuse components, and black for Emissive

    (most things don’t glow in the dark). If it’s a shiny object, you would use a lighter color for Specular

    reflections. For example, the material for a red billiard ball might be:

// billiard ball

    // ambient emissive diffuse specular shininess

// Material mat = new Material(red, black, red, white, 70f);

     6

     For a rubber ball, you could use a black or red specular light instead of white which would make the ball appear less shiny. Reducing the shininess factor from 70 to 0 would not work the way you might expect, it would spread the white reflection across the whole object instead of it being concentrated in one spot.

     Texture

    Materials make change the appearance of a whole shape, but sometimes even the shiniest objects can seem dull. By adding texture you can produce more interesting effects like marbling or wrapping a two-dimensional image around your object.

    The TextureLoader class enables you to load an image to use as a texture. The dimensions of your image must be powers of two, for example 128 pixels by 256. When you load the texture you can also specify how you want to use the image. For example, RGB to use the color of the image or LUMINANCE to see the image in black and white.

    After the texture is loaded, you can change the TextureAttributes to say whether you want the image to replace the object underneath or modulate the underlying color. You can also apply it as a decal or blend the image with the color of your choice.

    If you are using a simple object like a sphere then you will also have to enable texturing by setting the “primitive flags”. These can be set to Primitive.GENERATE_NORMALS +

    Primitive.GENERATE_TEXTURE_COORDS when you create the object.

    In case this is starting to sound a bit complicated, here is an example. You can experiment with the texture settings in this example and compare the results. You can download the picture I used from http://www.java3d.org/Arizona.jpg or you can substitute a picture of your own.

import com.sun.j3d.utils.geometry.*;

    import com.sun.j3d.utils.universe.*;

    import com.sun.j3d.utils.image.*;

    import javax.media.j3d.*;

    import javax.vecmath.*;

    import java.awt.Container;

public class PictureBall {

     public PictureBall() {

     // Create the universe

     SimpleUniverse universe = new SimpleUniverse();

     // Create a structure to contain objects

     BranchGroup group = new BranchGroup();

     // Set up colors

     Color3f black = new Color3f(0.0f, 0.0f, 0.0f);

     Color3f white = new Color3f(1.0f, 1.0f, 1.0f);

     Color3f red = new Color3f(0.7f, .15f, .15f);

     // Set up the texture map

     TextureLoader loader = new TextureLoader("K:\\3d\\Arizona.jpg",

     "LUMINANCE", new Container());

     Texture texture = loader.getTexture();

     texture.setBoundaryModeS(Texture.WRAP);

     texture.setBoundaryModeT(Texture.WRAP);

     texture.setBoundaryColor( new Color4f( 0.0f, 1.0f, 0.0f, 0.0f ) );

     7

     // Set up the texture attributes

     //could be REPLACE, BLEND or DECAL instead of MODULATE

     TextureAttributes texAttr = new TextureAttributes();

     texAttr.setTextureMode(TextureAttributes.MODULATE);

     Appearance ap = new Appearance();

     ap.setTexture(texture);

     ap.setTextureAttributes(texAttr);

     //set up the material

     ap.setMaterial(new Material(red, black, red, black, 1.0f));

     // Create a ball to demonstrate textures

     int primflags = Primitive.GENERATE_NORMALS +

     Primitive.GENERATE_TEXTURE_COORDS;

     Sphere sphere = new Sphere(0.5f, primflags, ap);

     group.addChild(sphere);

     // Create lights

     Color3f light1Color = new Color3f(1f, 1f, 1f);

     BoundingSphere bounds =

     new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0);

     Vector3f light1Direction = new Vector3f(4.0f, -7.0f, -12.0f);

     DirectionalLight light1

     = new DirectionalLight(light1Color, light1Direction);

     light1.setInfluencingBounds(bounds);

     group.addChild(light1);

     AmbientLight ambientLight =

    new AmbientLight(new Color3f(.5f,.5f,.5f));

     ambientLight.setInfluencingBounds(bounds);

     group.addChild(ambientLight);

     // look towards the ball

     universe.getViewingPlatform().setNominalViewingTransform();

     // add the group of objects to the Universe

     universe.addBranchGraph(group);

     }

     public static void main(String[] args) {

     new PictureBall();

     }

    }

    You can also set up three-dimensional textures, using shapes instead of a flat image. Unfortunately, these

    do not currently work very well across different platforms. Special Effects

     Look at the AppearanceTest example that comes with Java 3D for more effects you can use. For example

    you can display objects as wire-frames, display only the corners of an object and so on. You can even make

    objects transparent, with the following settings:

    TransparencyAttributes t_attr =

     new TransparencyAttributes(TransparencyAttributes.BLENDED,0.5f,

     TransparencyAttributes.BLEND_SRC_ALPHA,

     TransparencyAttributes.BLEND_ONE);

    ap.setTransparencyAttributes( t_attr );

     8

Java 3D and the User Interface

    Most real-life applications use a mixture of three dimensional and two-dimensional elements. This section describes how to combine your Java 3D with the rest of your program.

    Canvas3D

    Each area where three-dimensional graphics can be painted is called a Canvas3D. This is a rectangle that contains a view of the objects in your universe. You place the canvas inside a frame, then you create a universe to be displayed in the canvas.

     The following example shows how to create a canvas in a frame with labels at the top and bottom. The program can be run as either an applet or an application.

import com.sun.j3d.utils.universe.SimpleUniverse;

    import com.sun.j3d.utils.geometry.ColorCube;

    import javax.media.j3d.BranchGroup;

    import javax.media.j3d.Canvas3D;

    import java.awt.GraphicsConfiguration;

    import java.awt.BorderLayout;

    import java.awt.Label;

    import java.applet.Applet;

    import com.sun.j3d.utils.applet.MainFrame;

    public class CanvasDemo extends Applet {

     public CanvasDemo() {

     setLayout(new BorderLayout());

     GraphicsConfiguration config =

     SimpleUniverse.getPreferredConfiguration();

     Canvas3D canvas = new Canvas3D(config);

     add("North",new Label("This is the top"));

     add("Center", canvas);

     add("South",new Label("This is the bottom"));

     BranchGroup contents = new BranchGroup();

     contents.addChild(new ColorCube(0.3));

     SimpleUniverse universe = new SimpleUniverse(canvas);

     universe.getViewingPlatform().setNominalViewingTransform();

     universe.addBranchGraph(contents);

     }

     public static void main( String[] args ) {

     CanvasDemo demo = new CanvasDemo();

     new MainFrame(demo,400,400);

     }

    }

    Java 3D and Swing

    The Canvas3D takes advantage of your computer’s graphics card to increase performance. Unfortunately, this means that it does not mix very well with Sun’s swing user interface components. These components

    are called “lightweight” Lightweight components can be hidden by a Canvas3D even if they are supposed to be at the front.

There are several solutions to this problem:

     9

? You can mix lightweight and heavyweight components on the same screen if you keep them in

    separate containers.

? If you use Popup menus, a static function on JPopupMenu fixes the problem:

    setDefaultLightWeightPopupEnabled(false);

? You can use the older AWT components instead of swing.

     10

Report this document

For any questions or suggestions please email
cust-service@docsford.com