Notice that ALL is always the default for parts so it isn't necessary when you want to render the entire shape. This example creates a cylinder about four meters high and one meter in diameter (see fig. 24.5). Probably perfect for the columns outside of a virtual house. At the same time, a cylinder like the following might be correctly sized and rendered for an eight-ounce drinking glass:

Figure 24.5 : A sample cylinder.

Cylinder {
   height .15
   radius .04
   }

Notice that spacing isn't important, but when you have more than one or two properties, it's probably best to space them out for the sake of clarity.

The cone primitive requires a radius for its base, and a height. Since the radius of a cone changes consistently from bottom to top, you use the property bottomRadius:

Cone { height 15 bottomRadius 10 }

This one might make a good approximation of a pine tree outside of your virtual mountain cabin (see fig. 24.6).

Figure 24.6 : A sample cone.

On the other hand, you might use the following:

Cone {
   parts SIDES
   height .10
   bottomRadius .02
   }

This could easily represent an ice cream cone (albeit upside down for now). The parts property for cones accepts the values SIDES, BOTTOM, or ALL.

The Cube

Perhaps more appropriately called the "cuboid," the cube primitive can have unequal sides, making it more or less a 3D rectangular shape. It's also probably the most useful shape, if for no other reason than the fact that you'll generally want to use it as the floor in your virtual world.

Actually, a cube is useful for representing many different things, from appliances and furniture to buildings and ceilings. Since you can stretch the cube in 3D, you have limitless possibilities-as long as you don't mind jagged edges.

The basic format for a cube is the following:

Cube {
  width size
  height size
  depth size
}

When initially rendered, the width is in the X axis, the height is in the Y axis, and depth is in the Z access. An example might be the following:

Cube {
   width 1
   height 1
   depth 1
   }

This one actually is a cube, a meter on each side. It might be good to represent a nice-sized shipping box.

An example that meets the challenge of being a virtual room's "floor" would be the following:

Cube {
   width 20
   height .01
   depth 25
     }

This is just about the right size for a reasonably dimensioned den or family room-maybe even a master suite. You can see it extending out into the distance in figure 24.7.

Figure 24.7 : A virtual box.

AsciiText

The final primitive accepts a string value of ASCII text and writes it to the screen-AsciiText. You can choose values for the spacing, justification (alignment), and width of the string, if you want to confine it to a particular size. The basic format is the following:

AsciiText {
   string "Text"
   spacing number
   justification DIRECTION
   width size
   }

You enter the text you want to use between the quotation marks. spacing is used to determine the distance between lines when you include more than one string statement.

The justification property takes the values LEFT, CENTER, and RIGHT, and aligns the text relative to the point where X=0 (the center of the screen). LEFT, for instance, causes the string to end at X=0; RIGHT causes the text to begin at X=0.

The width property is often set to zero (which is also the default), but can be used to cause your text to conform to a certain width. The following is an example of AsciiText:

AsciiText {
   string "A long, long time ago,"
   spacing 2
   justification CENTER
   }

Figure 24.8 shows how this text looks in a VRML browser.

Figure 24.8 : Ascii Text in your virtual world.

Example: Occupying the Same Space

With what you know now about primitives, you can create some fairly interesting shapes-but you can't do much about where they appear in your virtual world. You'll look into that next. For now, let's see what it's like when you put two shapes in the same world.

Enter Listing 24.2 in a new VRML document.

Listing 24.2  twoshape.wrl  Two Shapes in the Same Space

#VRML V1.0 ascii
#
#Two shapes in
#one space
#
Sphere { radius 2.5}

Cube {
   width 20
   height .02
   depth 20
   }

(Don't forget to save the file with a .wrl extension.) When you load this file into your VRML browser, you should notice that the two have the same point of origin, and are trying to occupy the same space. Things are a bit difficult to puzzle out, since both are the same color, but if you pan up or down slightly, you should be able to see how the two shapes seem fused (see fig. 24.9). From certain perspectives, the sphere is a bump on the road-or perhaps a lone mountain!

Figure 24.9 : Are two shapes better than one?

Moving Your Primitives Around

Here, you'll move on to using nodes that move your primitives around in the VRML world. You're using a node called Transform, which is designed to affect the location, rotation, and scale of the objects that come after it.

The basic format is:

Transform {
   translation X-distance Y-distance Z-distance
   rotation X-axis Y-axis Z-axis Angle
   scaleFactor X-factor Y-factor Z-factor
   }
Primitive to move/rotate/scale

Just to keep this from seeming too intimidating, let's quickly look at an example:

Transform {
   translation 2 2 0
   rotation 0 1 0 3.14
   scaleFactor 1 1 1
   }

translation

The translation property is responsible for actually moving the object in VRML space, and it uses a basic 3D vector to do that. This vector can be seen as a 3D description of how the object should be moved from the point of origin. Consider this part of the last example:

translation 2 2 0

Whatever shape comes after this Transform node will be moved two meters to the right (+2 in the X axis), two meters up (+2 in the Y axis), and will stay at the same distance near/far (0 in the Z axis).

Since this is the most common use of the Transform node, it's perfectly reasonable to have a node like this:

Transform {translation -2 0 -5}

rotation

The rotation property allows you to choose which axis you would like to rotate the shape around, and then lets you enter an angle (in radians) for that rotation. Look at the following example:

Transform {rotation 0 1 0 1.57}

I've chosen to rotate the shape 90 degrees around its Y axis. This would be akin to "spinning" the shape, since the Y axis can be seen as a line from the top of the screen to the bottom of it. Here's another example:

Transform {rotation 1 0 0 3.14}

This rotates any associated shapes 180 degrees around the X axis. This would be "flipping" the shape. The X axis runs from left to right across the screen, so rotating a shape around the X axis 180 degrees would turn the shape "upside-down."

scaleFactor

The scaleFactor property very simply allows you to choose a factor by which a shape can be sized in each access, as in the following example:

Transform {scaleFactor 1 4 -2}

This would keep any subsequent shapes the same size in the X axis, make the shape larger by a factor of four in the Y axis, and make it smaller by a factor of two in the Z axis.

The Separator Node

Of course, the Transform node does nothing on its own. But it will now affect any primitives that occur after it until it is separated from the rest of the document with a separator node.

The separator node is very simple. An example would be as follows:

Separator {
   Transform {
      translation 2 2 0
      rotation 0 1 0 3.14
      scaleFactor 1 1 1
   }
   Cylinder{}
}
Cube{}

Using the Separator node in this way, the Transform node will affect only the default cylinder you've created. The cube, which is defined outside of the separator, will not be affected by the Transform node. Instead of moving, the cube will appear centered in the screen, like the primitives you created earlier in the chapter.

Example: Moving and Flipping

Using everything you've learned up until now, let's create a scoop of ice cream and an ice cream cone-except that they'll be appropriate for someone with the same sized neck as, say, King Kong.

You'll use the sphere and cone primitives to create the basic shapes and the Transform node to move those shapes around. On top of that, you'll need Separator nodes to transform the shapes individually. Let's also make the shapes a little larger than life so they're easier to see.

Create a new VRML document and enter Listing 24.3.

Listing 24.3  moving.wrl  Moving and Flipping Primitives in the VRML World

#VRML V1.0 ascii
#
# Moving and flipping
# VRML primitives
#
Separator {
   Transform {
     translation -1 0 0
     rotation 1 0 0 3.14
   }
   Cone {
     height .75
     bottomRadius .12
   }
}
Separator {
   Transform {
     translation 0 0 -1
   }
   Sphere {radius .5}
}

Each of the shapes has an associated Transform node that is enclosed with it in a Separator node. In the first Separator node, you're creating a Transform node that moves the shape two meters to the left and "flips" it 180 degrees. You then create the cone primitive, which is 1/2 of a meter in height and about .24 meters in diameter at its bottom. (Of course, flipping it makes the bottom the top, at least insofar as this is supposed to represent an ice cream cone.)

The second Separator node uses Transform to move the primitive two meters to the right and two meters behind the center point of the screen. Then it creates a sphere with a diameter of .4 meters, which hopefully will make it about the right size for Kong's ice cream appetite (see fig. 24.10).

Figure 24.10 : A helluva lot of virtual calories

Summary

VRML is more of a cousin to HTML than part of the specification. In some ways it is similar-it's text-based and can be used to navigate the Web. In many ways, it is very different, including the fact that it is basically graphical and 3D. New standards are emerging that may eventually make it difficult for non-programmers to create VRML worlds without special applications.

For now, though, you can create documents that are properly formatted for VRML, and then enter the correct nodes to create various primitive shapes. On their own, primitives appear at the 0,0,0 point in your browser, and will overlap one another when rendered together.

To get past this, you use another node, Transform, to move objects around in the virtual world. Transform is designed to affect every object that comes after it though, so you run into similar overlapping problems unless you use the Separator node.

The Separator node allows you to "nest" nodes within it, thus separating those nodes from the rest of the VRML description. So, a Transform node can be made to affect only the primitive that is in the same Separator.

Review Questions

1. What is the most likely reason for the VRML 2.0 specification to require special programs for creating aspect of your VRML world?
2. What is the MIME type and file extension for VRML worlds?
3. Why is it advisable to create a new template for VRML documents?
4. What is 180 degrees expressed in radians? 90 degrees?
5. You've seen that sphere {} will create a shape, in spite of the fact that it has no properties. Will cube {} create a shape in a VRML browser?
6. Which primitive is the only one to use the bottomRadius property?
7. True or false. Justifying an AsciiText string to the RIGHT will cause the string to end at X=0.
8. Which property for Transform can be used to change the size of a given primitive?
9. How will the following cylinder appear in a VRML browser?
   
   Transform {rotation 0 1 0 3.14}
   cylinder {}
   
10. True or false. You can nest Separator nodes within one another.

Review Exercises

1. Create a sphere with a radius of five and one with a radius of ten. Without using the Transform node, see if it's possible to view both in your browser.
2. Create a sphere and a cylinder that, when viewed from certain angles in a VRML browser, approximates a planet with rings (like Saturn).
3. Use the Cone, Cylinder, and Transform nodes to create a shape that approximates a pine tree, completely with a trunk.
4. Move the "ice cream scoop" in Listing 24.3 so that it's on top of the "ice cream cone" you created.