Introduction

In the previous Objective Viewpoint article, we learned the steps required to develop a simple Java3D application. This article explains how to create a scene graph for a Java3D application using the Simple3D source code from our previous tutorial to derive the graph.

This tutorial is presented in the following way: first, we briefly explain the Java3D programming model and show the scene graph and source code for the Simple3D.java program developed in the last article. Then we step through the source code and show how that code relates to the scene graph. In this way, you should be able to see how the two are related and have have a better understanding of how to begin developing complex Java3D programs from a design perspective.

Java3D Architecture

A Java3D virtual universe is specified using a non-cyclic, directed scene graph. A directed scene graph is a tree structure that describes the scene to be rendered. The nodes in the graph form a parent-child relationship, where a parent node has one or more child nodes. Figure 1 depicts the scene graph that represents the Java3D program structure constructed in the preceding article.

Figure 1: Simple3D.java program scene graph

Graph Element	Description
VirtualUniverse	Represents a virtual environment.
Locale	High-resolution 3D coordinate that provides a frame of reference for objects within the universe.

Table 1

Listing 1 shows the definition of the SimpleUniverse class (the file is located in package com.sun.j3d.utils). This class is provided by Sun to enable rapid development and prototyping of 3D environments. Now look at the declaration in Listing 1.

public class SimpleUniverse extends VirtualUniverse

Listing 1: SimpleUniverse class definition

The top node is a VirtualUniverse object. This object must be created before other Java3D objects can be added to the scene graph. The code used to create the VirtualUniverse object in our Simple3D.java program is shown in Listing 2.

SimpleUniverse simpleUniverse = new SimpleUniverse(canvas3D);

Listing 2: Code to create the VirtualUniverse object

This single line of code hides much of the complexity associated with the creation of a VirtualUniverse. To get a deeper understanding of Java3D, we will have to look at what is going on behind the scenes.

The Locale

The SimpleUniverse object that we created in our previous program only required one parameter. If you look at the source code for the SimpleUniverse utility class, you will see that the single-parameter constructor actually calls a constructor that accepts four parameters. The four-parameter constructor is defined as shown in Listing 3.

public SimpleUniverse(HiResCoord origin, int numTransforms, Canvas3D canvas, URL userConfig)

Listing 3: SimpleUniverse Constructor that accepts four parameters

In our program, however, only the Canvas3D parameter is used. The SimpleUniverse constructor code creates default objects in place of those we omitted. What we are most concerned with right now is the segment of code that is used to create the Locale object:

if(origin == null)
	locale = new Locale(this);
else
	locale = new locale(this, origin); 

The ViewPlatform

If you traverse the right side of the scene graph from the Locale object, the first node encountered is a BranchGroup node. Sun has provided another utility class called the ViewingPlatform that extends the BranchGroup class. This class can be found in the com.sun.j3d.util.universe package. An instance of this class is created in the SimpleUniverse constructor: viewingPlatform = new ViewingPlatform(numTransforms);

Again, this code hides a lot of details that are of interest to us. For the purposes of this article, we are only interested in the creation of the TransformGroup node and the ViewPlatform node.

TransformGroup Node

TransformGroup tg = mtg.getTransformGroup(0);
addChild(tg);

The mtg object is an instance of a MultiTransformGroup that is used to hold all TransformGroup objects between the BranchGroup and the View object. In our case, we only have one Transform Group between the two.

ViewPlatform Node

  viewPlatform = new ViewPlatform();
    ... // Set capability flags
  tg.addChild(viewPlatform);

This completes the graph from the right side of the Locale node to the ViewPlatform node.

View

Viewer

  if(physicalBody == null) {
    physicalBody = new PhysicalBody();
 	 ....
  }
  if(physicalEnvironment == null) {
    physicalEnvironment = new PhysicalEnvironment();
	...
  }
  if(userCanvas == null)
    canvas = new Canvas3D(null);
  	... // code to create the frame and add the canvas here
  }
  view = new View();
  view.addCanvas3D(canvas);
  view.setPhysicalBody(physicalBody);
  view.setPhysicalEnvironment(physicalEnvironment);
  
  ... // set the clipping planes  

Background

Shape3D

Conclusion

/*
 * Simple3D.java
 * 
 * Author: George Crawford III
 *
 * Permission to use and modify this source code is hereby granted provided
 * the author's name is included in all modified versions of this software.
 */
import java.applet.Applet;
import java.awt.Frame;
import java.awt.BorderLayout;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.universe.SimpleUniverse;
import com.sun.j3d.utils.image.TextureLoader;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.Background;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.vecmath.Point3d;

public class Simple3D extends Applet {
 public void createSimpleUniverse() {
    SimpleUniverse simpleUniverse = new SimpleUniverse(canvas3D);
    simpleUniverse.getViewingPlatform().setNominalViewingTransform();
    simpleUniverse.addBranchGraph(sceneGraph);
  }
  public void createBackground() {
    BoundingSphere boundingSphere = 
	  new BoundingSphere(new Point3d(0.0, 0.0, 0.0), 100.0);
	TextureLoader backgroundTexture = 
      new TextureLoader(backgroundImage, this);
	Background background = 
	  new Background(backgroundTexture.getImage());
	background.setApplicationBounds(boundingSphere);
	sceneGraph.addChild(background);
  }
  public void createSceneGraph() {
	// Create the root of the scene graph
	sceneGraph = new BranchGroup();

	// Create the background for the scene and add it to the scene graph
	createBackground();

	// Create a 3D transformation and add it to the scene graph.
	createTransformation(); 

	// Allow Java3D to optimize the scene graph.
    sceneGraph.compile();	
  }
  public void createTransformation() {
    // Create a 3D transformation that will 
 	// rotate the cube a specified number of degrees on the x axis
	Transform3D transform3D = new Transform3D();
    transform3D.rotX(xRotationAngle);

	// Create the transform group node and add the transformation
    // to the node. Add the transformation group to the scene graph.
	TransformGroup transformGroup = new TransformGroup(transform3D);
	sceneGraph.addChild(transformGroup); 

	// Add a colored cube to the transform group node.
	transformGroup.addChild(new ColorCube(cubeScale));
  }
  public void layoutComponents() {
    setLayout(new BorderLayout());
    canvas3D = new Canvas3D(null);
    add("Center", canvas3D);
  void layoutComponents() {
    setLayout(new BorderLayout());
    canvas3D = new Canvas3D(null);
    add("Center", canvas3D);
  }
  public Simple3D(String background, double scale, double xAngle) {
	backgroundImage = background;
	cubeScale = scale;
	xRotationAngle = (Math.PI/180)*xAngle; // Convert to radians
	layoutComponents();
	createSceneGraph();
	createSimpleUniverse();
  }
  public static void main(String[] args) {
	String backgroundImage = "m18.jpg";
	double scale = 0.5;
	double xAngle = 90.0;
	if(args.length > 0) 
	  try { 
	    for(int i = 0; i  <-xAngle [degrees]>");
	System.err.println("Where: ");
	System.err.print("\t[image] is the image to display in the");
	System.err.println("background");
	System.err.println("\t[scale] is the size of the bounding sphere");
	System.err.print("\t[degrees] is the angle in degrees ");
	System.err.println("for axis rotation");
	System.exit(0);
  }
  private String backgroundImage;	// Background image filename
  private double cubeScale;		// Used to scale the 3D cube
  private double xRotationAngle; // The rotation angle in degrees
  private Canvas3D canvas3D;	// Used to render the 3D scene
  private BranchGroup sceneGraph; // Contains 3D scene information
}

Resources

1

Sun Microsystems, Inc. The Java 3D API. Sun Microsystems, Inc. October 4, 1997.

2

Sun Microsystems, Inc. Java 3D API Documentation. July, 1998.

3

Sun Microsystems, Inc. Java 3D API Specification Version 1.1 Beta 01. Sun Microsystems, Inc.

Copyright 1999 George Crawford III

Last Modified:
Location: www.acm.org/crossroads/xrds5-3/ovp53.html