The following is a selected excerpt of Chapter 14 from Killer Game Programming in Java (ISBN
0-596-00730-2) published by O'Reilly.
--
I'll
summarize the main elements of Java 3D in this chapter, leaving program
examples aside for the moment. Then, I'll examine Java 3D's suitability
for games programming by considering the criticisms leveled against it.
Java 3D
The
Java 3D API provides a collection of high-level constructs for
creating, rendering, and manipulating a 3D scene graph composed of
geometry, materials, lights, sounds, and more. Java 3D was developed by
Sun Microsystems, and the most recent stable release is Version 1.3.1.
TIP: There
is a Version 1.3.2, but it's a bug fix release under review as I write
this in December 2004. For example, a rarely occurring bug with the J3DTimer class has been fixed.
By the time you read this, Version 1.3.2 will have been finalized (an FCS release will be available).
There
are two Java 3D variants: one implemented on top of OpenGL, and the
other above DirectX Graphics. OpenGL is a popular software API for
writing 3D (and 2D) graphics applications across a wide range of
hardware and operating systems (http://www.opengl.org/). It's a low-level API based around a graphics pipeline for pixel and vertex manipulation.
TIP: Prior
to the 1.3.2 bug fix release, a programmer had to choose whether to
download the OpenGL version of Java 3D or the DirectX implementation
since they were offered as separate installers. With Version 1.3.2
(build 7 and later), both versions are in a single download.
DirectX
Graphics supports a traditional graphics pipeline, describing all
geometry in terms of vertices and pixels. It's part of DirectX, a
collection of related gaming modules aimed at MS Windows ( http://www.microsoft.com/directx). The other DirectX APIs support 3D audio, networking, input device integration, multimedia, and installation management.
DirectX or OpenGL?
Often,
the debate about which version of Java 3D is better is a debate about
the relative merits of DirectX Graphics and OpenGL.
In
most technical areas, DirectX Graphics and OpenGL are almost equivalent
since both are based on the same graphics pipeline architecture and
ideas flow between the two. The most significant differences between
the two APIs are unrelated to their functionality. OpenGL is ported to
a wide range of platforms and OSs, and DirectX is limited to PCs
running Windows and the Xbox. DirectX is controlled by Microsoft alone,
and the OpenGL Architecture Review Board (ARB) allows input from many
partners.
The
Direct X Graphics version of Java 3D is only available for Windows,
where some users report that it's marginally faster than the OpenGL
implementation. However, I've never noticed any difference when I've
tried both systems.
The
future seems brightest for the OpenGL version, which is the main focus
of the current "bug fix" release of Java 3D, Version 1.3.2. I'll use
the stable OpenGL version (1.3.1) in the rest of this book. It can be
downloaded from http://java.sun.com/products/java-media/3D/, together with ample documentation and a long tutorial.
TIP: The FCS release of Version 1.3.2 will be available by the time you read this. You can obtain it from https://java3d.dev.java.net/.
The Scene Graph
Java
3D uses a scene graph to organize and manage a 3D application. The
underlying graphics pipeline is hidden, replaced by a tree-like
structure built from nodes representing 3D models, lights, sounds, the
background, the camera, and many other scene elements.
The nodes are typed, the main division being between Group and Leaf nodes. A Group
node is one with child nodes, grouping the children so operations such
as translations, rotations, and scaling can be applied en masse. Leaf
nodes are the leaves of the graph (did you guess that?), which often
represent the visible things in the scene such as the models, but may
be nontangible entities, such as lighting and sounds. Additionally, a Leaf node (e.g., for a 3D shape) may have node components , specifying color, reflectivity, and other attributes of the leaf.
The
scene graph can contain behaviors , nodes holding code that can affect
other nodes in the graph at runtime. Typical behavior nodes move
shapes, detect and respond to shape collisions, and cycle lighting from
day to night.
Scene graph is used, rather than scene tree, because it's possible for nodes to be shared (i.e., have more than one parent).
Before
looking at a real Java 3D scene graph, Figure 14-1 shows how the scene
graph idea can be applied to defining the contents of an office.
|
|
 |
 |
 |
Figure 14-1. Scene graph for an office
|
The office Group node is the parent of Leaf nodes representing a desk and two chairs. Each Leaf
utilizes geometry (shape) and color node components, and the chair
geometry information is shared. This sharing means that both chairs
will have the same shape but will be colored differently.
The
choice of symbols in Figure 14-1 comes from a standard symbol set
(shown in Figure 14-2), used in all of this book's Java 3D scene graph
diagrams. I'll explain the VirtualUniverse and Locale nodes and the Reference relationship in due course.
Some Java 3D scene graph nodes
The Java 3D API can be viewed as a set of classes that subclass the Group and Leaf nodes in various ways. The Leaf class is subclassed to define different kinds of 3D shapes and environmental nodes (i.e., nodes representing lighting, sounds, and behaviors).
|
|
 |
 |
 |
Figure 14-2. Scene graph symbols
|
The main shape class is called Shape3D, which uses two node components to define its geometry and appearance; these classes are called Geometry and Appearance.
The Group
class supports basic node positioning and orientation for its children
and is subclassed to extend those operations. For instance, BranchGroup allows children to be added or removed from the graph at runtime; TransformGroup permits the position and orientation of its children to be changed.
The HelloUniverse scene graph
The standard first example for Java 3D programmers is HelloUniverse. (It appears in Chapter 1 of Sun's Java 3D tutorial.) It displays a rotating colored cube, as in Figure 14-3.
The scene graph for this application is given in Figure 14-4.
VirtualUniverse is the top node in every scene graph and represents the virtual world space and its coordinate system. Locale acts as the scene graph's location in the virtual world. Below the Locale node are two subgraphs—the left branch is the content branch graph,
holding program-specific content such as geometry, lighting, textures,
and the world's background. The content branch graph differs
significantly from one application to another.
The ColorCube is composed from a Shape3D node and associated Geometry and Appearance components. Its rotation is carried out by a Behavior node, which affects the TransformGroup parent of the ColorCube's shape.
|
|
 |
 |
 |
Figure 14-3. A rotating colored cube
|
|
|
 |
 |
 |
Figure 14-4. Scene graph for HelloUniverse
|
The righthand branch below Locale is the view branch graph,
which specifies the users' position, orientation, and perspective as
they look into the virtual world from the physical world (e.g., from in
front of a monitor). The ViewPlatform node stores the viewer's position in the virtual world; the View node states how to turn what the viewer sees into a physical world image (e.g., a 2D picture on the monitor). The Canvas3D node is a Java GUI component that allows the 2D image to be placed inside a Java application or applet.
The VirtualUniverse, Locale,
and view branch graph often have the same structure across different
applications since most programs use a single Locale and view the
virtual world as a 2D image on a monitor. For these applications, the
relevant nodes can be created with Java 3D's SimpleUniverse utility class, relieving the programmer much graph construction work.