Sony has done a significant amount of work with VRML but it is more likely that you will target either Internet Explorer or Netscape with your Java applet/VRML world. Sony has a Web site devoted to its Community Place VRML effort at http://vs.spiw.com/vs/

One further note: Aside from the nature of plug-ins, there are several other inconsistencies over platforms - the quality of Java Virtual Machines as well as the feature sets of each browser. There are many variables at work here. All of the work for this article was done in Netscape Communicator 4 with the SGI Cosmo Player 1.0 Plug-in on Windows95/NT4.0. Do not install NT4.0 service pack 3 or the sample applet/scene will not work. The current reality of VRML/Java development is that you now must develop not only for a particular platform, but a particular browser and plug-in combination as well. This is counter to the promise of the "write-once, run-anywhere" promise of Java, but it has just as much to do with the young nature of VRML 2.0 as the uneven quality of VMs across platforms.

Intervista is run by Tony Parisi, one of the creators of the initial VRML specification. Intervista markets its own plug-in for Windows95/NT and Macintosh, WorldView, for Netscape and Internet Explorer. It is a very good implementation of the VRML 2.0 spec and renders graphics exceedingly fast, relying on Microsoft's DirectX technology to do this. Microsoft licenses a significant amount of VRML technology from Intervista, which may explain why Microsoft's VRML plug-in looks very much like Intervista's.

DimensionX was among the first to license Java from Sun Microsystems. They have two products - Liquid Motion Pro and Liquid Reality. Liquid Motion Pro is an impressive Java-based multimedia tool. Liquid Reality is a Java-based implementation of a VRML browser and the Java development environment for VRML. Dimension X was up to their 18th beta version of Liquid Reality when they were bought by Microsoft. You can now get Liquid Reality with some editions of Visual J++. As a Java solution, LR was edging towards platform independence, although the latest versions are requiring Microsoft's DirectX API. It is an approach that seems especially ambitious, but after 18 betas, one fears that a solution is not within reach.

Silicon Graphics Open Inventor ASCII File Format is the file format on which the VRML 2.0 specification is based. They have a very good implementation of a VRML plug-in, Cosmo Player. Cosmo Player has just been formally released as a product and is free with Netscape Communicator 4.0. VRML on a Silicon Graphics 02 , you can imagine, is as close to real-time VRML as you're going to (currently) get. It's fast and smooth, and probably a bit expensive for the average developer. vrml.sgi.com continues to be a mainstay of the VRML community, where you can find the latest advances in VRML and implementations of experimental technologies. It is also the site where SGI actively promotes VRML. SGI has a suite of tools which is among the best available and you can read about them there.

How VRML Works with Java - Two Approaches
As we've mentioned before, VRML is inherently programmable and extensible. The current languages to use with VRML are VRMLScript, JavaScript and Java. When programming in Java, it is possible to access the class file from within the scene itself or from outside the scene. The first method, included in the VRML 2.0 specification, is colloquially known as the "Java Scripting Interface" (JSI). The second method, which is a proposed "Annex" to the VRML 2.0 is known as the External Authoring Interface.

VRMLScript is supported by a Script Node in VRML. VRMLscript is a subset of JavaScript which focuses, appropriately enough, on the activities which are most commonly done in VRML; for example, animation. If you want a bird in a VRML scene to change into an eagle when you touch it, this may be done entirely within VRML using the Script node.

It is also possible to use JavaScript to script events. This is helpful when you need the special features of a particular language. JavaScript is supported by both major VRML browsers and is a relatively safe bet for that reason. However, if your VRML browser supports Perl there is no reason theoretically why you couldn't use it, according to the VRML 2.0 specification. At this point, however, VRMLscript, JavaScript and Java are the only languages supported by the majority of VRML plug-ins. A Script node is constructed such that if a plug-in does not support a language, it can default to another laguage (and a third) if necessary. For example, Intervista's plug-in supports VBScript and it can be configured to default to JavaScript.

In VRML, you can change the fields in a node and monitor the change of values in a node if those fields you wish to monitor or change are exposed fields. If they are exposed, it means that they have a "get" and a "set" value, much like many other classes in Java. In order to set a value, you must specify the appropriate "set" method in either the EventIn or EventOut object. This will be thoroughly explained in the example. (In VRML, the actual syntax is "set_fieldname" and "fieldname_changed", respectively, for exposed fields).

Using Java in a Script Node
In order to use Java in VRML Script node, the VRML Script node must basically look like this:

Script
{
url["DoSomeThingCool.class"]
}

The Script Node contacts a class file by means of a URL. This example doesn't do anything, but it gives the overall idea. The Java class must import the following packages:

vrml.*
vrml.field.*
vrml.node.*

The API of these packages has been specified in the VRML 2.0 specification. It's certainly too big to get into here. The final spec for the API can be found at www.vrml.org/Specifications/vrml2.0/FINAL/spec/part1/java.html.

The Java Classes included with the VRML plug-ins must follow this API specification. There may be better documentation out on the market in the future, but this is all that currently exists.

These packages let you control and respond to changes in fields in individual nodes, as well as interact with the browser in critical ways. The Java package defines both a read-only (Const) class and a read/write class for each VRML field type; both kinds of classes define a getValue() method and the read/write classes define a setValue() method as well. Also, classes, depending on their function, provide "get" and "set" methods. For example, MFInt32 provides an addValue() method to add an SFInt32 value to a list. Classes have methods which handle Exceptions (from which you can descend).

To reference a field in a Script node, you must declare each field of the Script Node (using getField()) and each outgoing event (using getEventOut()) in the initialize() method.

When a Script receives a set of incoming events, it passes them to a Java method named processEvents(). processEvents()'s default behavior is to pass each event individually to your defined event handler, which much be called processEvent(). The processEvent() method receives a single object of the class Event.

A word of advice: if you need static data available from one use of a script to the next, don't count on the browser "knowing" the static values that were set the last time you referenced that class file unless you assign those static values to fields in that VRML node.

The External Authoring Interface
The External Authoring Interface was created because developers will need to communicate with a VRML scene from outside of that scene. Doing this has many advantages: the VRML scene is no longer at the center of the architecture, but is more of a resource upon which the primary program can act and to which it can respond. We have used the EAI extensively in our work. The EAI is not formally part of VRML, but a proposal for an "Informative Annex." vrml.sgi.com/moving-worlds/sec/ExternalInterface.html. To quote Chris Regan from the EAI FAQ (www.tomco.net/~raf/faqs/eaifaq.html):

"The choice between them is largely down to the taste of the programmer though many follow a fish bowl metaphor, using the script node for behaviours purely within the world and the external interface for behaviours linking outside. Within a WWW browser the EAI provides simple access from an applet on the same page as the VRML browser, currently using Live Connect."

The EAI is now fully implemented in Cosmo Player 1.0 and in Intervista's WorldView plug in.

The EAI is a large topic within itself to cover. We advise anyone interested in it to see the EAI proposal at vrml.sgi.com. In our example, we access the VRML scene through the EAI and change a few fields within the VRML file through a Java Applet. Again, this is a narrow example of the power of the External Authoring Interface. If you check out the specification, it quickly will become apparent that you can do a lot more than this.

The Anatomy of an Example
Note: The entire source code for this example is located at www.avi.com/jdj. There is not enough space to include the entire source code for this example here. Instead, we will discuss the basic parts of the applet's construction.

Let's first look at the VRML file, shown in Listing 1. This entire VRML scene consists of seven nodes. In order for Java to be able to manipulate VRML using the EAI, the easiest approach is to define the node using the keyword DEF. Main is a Transform node, which is a type of a grouping node: if you expect that a node and the nodes beneath it will have to be positionally manipulated according to the same behavior, you will want to group them within the same Transform node. A Transform node defines "a coordinate system for its children that is relative to the coordinate systems of its parents." ("The VRML 2.0 Handbook", Jed Hartman & Josie Wernecke, silicon Graphics, Inc. Addison Wesley, ©1996) Also, note that we have defined the TouchSensor node in this example to be TOUCH. We will change the scale of the cube and the position of the cube in this example by allowing the Java Applet to change the values of the scale and rotation fields in the "Main" Transform node. Now take a break. It only gets more complex from here.

In order to create an applet which has access to these nodes, you must import the following packages:

import vrml.external.Node;import vrml.external.Browser;import vrml.external.exception.*;

Note that these are not the standard vrml.* packages, but EAI packages. These classes are included with both Netscape Communicator/Cosmo Player 1.0 and Intervista.

The following package is necessary because our example uses Netscape. You should set your classpath so that it can access the java40.jar file.

import netscape.javascript.JSObject;

EventIns and EventOuts in VRML are objects which handle specific events for a particular node. If a node generates a particular action, an EventOut is used. If you wish to effect a particular node, you must manipulate its EventIn object.

The following package handles the means of getting a handle to an EventOut.

import vrml.external.field.EventOut;

The following packages control the EventIn and EventOut states of the Rotation fields, the Time fields, the objects which define 3D Vectors (SFVec3f). The classes which control 3D vectors can be used to interact with many nodes which are defined in terms of a 3D vector. We use it here to change the scale of our cube.

import vrml.external.field.EventOutSFRotation;
import vrml.external.field.EventInSFRotation;
import vrml.external.field.EventInSFVec3f;
import vrml.external.field.EventOutSFVec3f;
import vrml.external.field.EventOutSFTime;

To receive notification when an eventOut is generated from the scene, the applet must first subclass the EventOutObserver class, implementing the callback() method. Next, the advise() method of EventOut is passed the EventOutObserver. Whenever an event is generated for that eventOut, the callback() method is executed and passed the value and timestamp of the event. The advise() method is also passed a user-defined object. This value is passed to the callback() method and can be used by the applet to pass user-defined data to the callback. It allows a single EventOutObserver subclass to handle events from multiple sources and is a subclass of the standard Object class so it can be used to hold any data.

import vrml.external.field.EventOutObserver;

The Setup
In addition to the packages outlined above, you'll want to import java.applet.* and java.awt.*. In Listing 2, we instantiate our objects for their first use. The EventOutObserver interface is implemented in order to set the stage to ensure that it follows the correct protocol in order to communicate with the browser.

The init Method
A Java applet communicates with a VRML world by first obtaining an instance of the Browser class. This class is the Java encapsulation of the VRML world. It contains the entire Browser Script Interface as well as the getNode() method, which returns a Node when given a DEF name string (now is it apparent why we defined the nodes in the VRML file?). Only DEF names in the base file are accessible. Since VRML files can have multiple occurrences of the same DEF name, only the node with the last occurrence of a given name is accessible.

Once a Node instance is obtained from the getNode() method of the Browser class, its EventIns and EventOuts can be accessed.

Next, the advise() method of EventOut is passed the EventOutObserver. Then, whenever an event is generated for that eventOut, the callback() method is executed and passed the value and timestamp of the event. When this happens, you can see the value appear in the TextArea at the bottom of the Applet. The advise() method is also passed a user-defined object. This value is passed to the callback() method and can be used by the applet to pass user defined data to the callback (see Listing 3).

The applet's interface is created (Simple AWT stuff) in Listing 4.

The netscape.javascript.JSObject allows Java to manipulate objects that are defined in JavaScript. The JSObject.getWindow returns the window in which the plugin (in this case, Cosmo Player) is embedded. getMember() retrieves a named member of a JavaScript object. embeds.getSlot() retrieves the member indexed at [0] of the JSObject, which is, in this case, our VRML scene.

JSObject win = JSObject.getWindow(this);
JSObject doc = (JSObject) win.getMember("document");
JSObject embeds = (JSObject) doc.getMember("embeds");
browser = (Browser) embeds.getSlot(0);

Get the node in the VRML scene you wish to engage. Create an object of the type that will create the interactivity you wish; for example, we use rotation so we create an object of EventInSFRotation. We set the field in the Main node by using Main.getEventIn("set_rotation"). Also, note that in order to demonstrate to the viewer that an event is taking place, we're accessing the TOUCH node and getting the time that an event took place (see Listing 5).

The Callback
The callback gets the time at which the sensor node was tripped. It is displayed in the TextArea (see Listing 6).

The handleEvent() method
The most significant thing to note in this method is that ScaleIn is an object of type EventInSFVec3f, consisting of three values (an array of three floats). These values are set and the scale changes when this call is made (see Listing 7).

Once the possibility exists that you can program a VRML world from outside that world, it presents an entirely new way of looking at VRML. It offers programmers a bit more flexibility in some areas and, depending upon their application, it may be an option that you want to use. The EAI hopefully will become part of the VRML 2.0 specification.

Java and VRML together offer the promise of functionality on the Web that is truly interactive and a magnitude more useable than the current Web. The technology that bridges VRML and Java is still quite erratic, but with the advances in Java technology, and the general agreement among all parties on the VRML 2.0 specification, it is possible that in a few years VRML, not HTML, may be the mainstay of the Web. Much work remains to be done, but we can remain hopeful that with the current investments many corporations are making in bandwidth technologies, a VRML-based Web - enhanced by Java - isn't that far away.

Other Sites to Check
www.intervista.com - Intervista's site
www.microsoft.com/dimensionx - DimensionX's site
cosmo.sgi.com - Cosmos creates VRML worlds and development environments
www.microsoft.com/vrml - Microsoft's VRML effort