IntroductionSummary
of VRML 2.0 FeaturesChanges
from VRML 1.0
IntroductionThis overview provides a brief high-level summary of the VRML 2.0 specification. The purposes of the overview are to give you the general idea of the major features, and to provide a summary of the differences between VRML 1.0 and VRML 2.0. The overview consists of two sections:
This overview assumes that readers are at least vaguely familiar with VRML 1.0. If you're not, read the introduction to the official VRML 1.0 specification. Note that VRML 2.0 includes some changes to VRML 1.0 concepts and names, so although you should understand the basic idea of what VRML is about, you shouldn't hold on too strongly to details and definitions from 1.0 as you read the specification.
The VRML 2.0 specification is available at: http://vrml.sgi.com/moving-worlds/spec/.
Summary
of VRML 2.0 FeaturesVRML 1.0 provided a means of creating and viewing static 3D worlds; VRML 2.0 provides much more. The overarching goal of VRML 2.0 is to provide a richer, more exciting, more interactive user experience than is possible within the static boundaries of VRML 1.0. The secondary goal is to provide a solid foundation for future VRML expansion to grow from, and to keep things as simple and as fast as possible -- for everyone from browser developers to world designers to end users.
VRML 2.0 provides these extensions and enhancements to VRML 1.0:
Each section of this summary contains links to relevant portions of the official specification.
You can add realism to the static geometry of your world using new features of VRML 2.0:
New nodes allow you to create ground-and-sky backdrops to scenes, add distant mountains and clouds, and dim distant objects with fog. Another new node lets you easily create irregular terrain instead of using flat planes for ground surfaces.
VRML 2.0 provides 3D spatial sound-generating nodes to further enhance realism -- you can put crickets, breaking glass, ringing telephones, or any other sound into a scene.
If you're writing a browser, you'll be happy to see that optimizing and parsing files are easier than in VRML 1.0, thanks to a new simplified scene graph structure.
No more moving like a ghost through cold, dead worlds: now you can directly interact with objects and creatures you encounter. New sensor nodes set off events when you move in certain areas of a world and when you click certain objects. They even let you drag objects or controls from one place to another. Another kind of sensor keeps track of the passage of time, providing a basis for everything from alarm clocks to repetitive animations.
And no more walking through walls. Collision detection ensures that solid objects react like solid objects; you bounce off them (or simply stop moving) when you run into them. Terrain following allows you to travel up and down steps or ramps.
VRML2.0 includes a variety of animation objects called Interpolators. This allow you to create pre-defined animations of a many aspects of the world and then play it at some opportune time. With animation interpolators you can create moving objects such as flying birds, automatically opening doors, or walking robots, objects that change color as they move, such as the sun, objects that morph their geometry from one shape to another, and you can create guided tours that automatically move the user along a predefined path.
VRML 2.0 wouldn't be able to move without the new Script nodes. Using Scripts, you can not only animate creatures and objects in a world, but give them a semblance of intelligence. Animated dogs can fetch newspapers or frisbees; clock hands can move; birds can fly; robots can juggle.
These effects are achieved by means of events; a script takes input from sensors and generates events based on that input which can change other nodes in the world. Events are passed around among nodes by way of special statements called routes.
Have an idea for a new kind of geometry node that you want everyone to be able to use? Got a nifty script that you want to turn into part of the next version of VRML? In VRML 2.0, you can encapsulate a group of nodes together as a new node type, a prototype, and then make that node type available to anyone who wants to use it. You can then create instances of the new type, each with different field values -- for instance, you could create a Robot prototype with a robotColor field, and then create as many individual different-colored Robot nodes as you like.
So how does all this fit together? Here's a look at possibilities for
implementing a fully-interactive demo world called Gone Fishing. 
In Gone Fishing, you start out hanging in space near a floating
worldlet. If you wanted a more earthbound starting situation, you could
(for instance) make the worldlet an island in the sea, using a
Background node to show shaded water and sky meeting at the horizon as
well as distant unmoving geometry like mountains. 
You could also add a haze in
the distance using the fog parameters in a Fog node.
As you approach the little world, you can see two neon signs blinking
on and off to attract you to a building. Each of those signs consists
of two pieces of geometry under a Switch node. A 
TimeSensor generates time
events which a Script node picks up and processes; the Script then
sends other events to the Switch node telling it which of its children
should be active. All events are sent from node to node by way of ROUTE
statements.
As you approach the building -- a domed aquarium on a raised platform
-- you notice that the entry portals are closed. There appears to be no
way in, until you click the front portal; it immediately slides open
with a motion like a camera's iris. That portal is attached to a
TouchSensor that detects your click; 
the sensor tells a Script node that you've
clicked, and the Script animates the opening portal, moving the
geometry for each piece of the portal a certain amount at a time. The
script writer only had to specify certain key frames of the animation;
interpolator nodes generate intermediate values to provide smooth
animation between the key frames. The door, by the way, is set
up for collision detection using a Collision node, so that without
clicking to open it you'd never be able to get in.
You enter the aquarium and a light turns on. A ProximitySensor node inside the room noticed you coming in and sent an event to, yes, another Script node, which told the light to turn on. The sensor, script, and light can also easily be set up to darken the room when you leave.
Inside the aquarium, you can see and hear bubbles drifting up from the
floor. The bubbles are moved by another Script; the bubbling sound is
created by a PointSound node. 
As you move further into the building and
closer to the bubbles, the bubbling sound gets louder.
Besides the bubbles, which always move predictably upward, three fish swim through the space inside the building. The fish could all be based on a single Fish node type, defined in this file by a PROTO statement as a collection of geometry, appearance, and behavior; to create new kinds of fish, the world builder could just plug in new geometry or behavior.
Proximity sensors aren't just for turning lights on and off; they can be used by moving creatures as well. For example, the fish could be programmed (using a similar ProximitySensor/Script/ROUTE combination to the one described above) to avoid you by swimming away whenever you got too close. Even that behavior wouldn't save them from users who don't follow directions, though:
Despite (or maybe because of) the warning sign on the wall, most users
"touch" one or more of the swimming fish by clicking them. 
Each fish behaves differently
when touched; one of them swims for the door, one goes belly-up. These
behaviors are yet again controlled by Script nodes.
To further expand Gone Fishing, a world designer might allow users to "pick up" the fish and move them from place to place. This could be accomplished with a PlaneSensor node, which translates a user's click-and-drag motion into translations within the scene. Other additions -- sharks that eat fish, tunnels for the fish to swim through, a kitchen to cook fish dinners in, and so on -- are limited only by the designer's imagination.
Gone Fishing is just one example of the sort of rich, interactive world you can build with VRML 2.0. For details of the new nodes and file structure, see the "Concepts" section of the VRML 2.0 Specification.
Changes
from VRML 1.0This section provides a very brief list of the changes to the set of predefined node types for VRML 2.0. It briefly describes all the newly added nodes, summarizes the changes to VRML 1.0 nodes, and lists the VRML 1.0 nodes that have been deleted in VRML 2.0. (For fuller descriptions of each node type, click the type name to link to the relevant portion of the VRML 2.0 specification proposal.) Finally, this document briefly describes the new field types in VRML 2.0.
The new node types are listed by category:
In place of the old Info node type, VRML 2.0 provides several new node types to give specific information about the scene to the browser:
Almost all node types have been changed in one way or another -- if nothing else, most can now send and receive simple events. The most far-reaching changes, however, are in the new approaches to grouping nodes: in particular, Separators have been replaced by Transforms, which incorporate the fields of the now-defunct Transform node, and Groups no longer allow state to leak. The other extensive changes are in the structure of geometry-related nodes (which now occur only as fields in a Shape node). See the section of the spec titled "Structuring the Scene Graph" for details.
The following VRML 1.0 node types have been removed from VRML 2.0:
In addition to all of the other changes, VRML 2.0 introduces a couple of new field types:
Contact
rikk@best.com. cmarrin@sgi.com,
or gavin@acm.org with questions or
comments.