CHAPTER 2
Basic MAX Concepts

FEATURING

•  Understanding MAX’s Object Concepts

•  Understanding MAX’s Concepts of Space

•  Understanding MAX’s Concepts of Time

•  Understanding MAX’s Rendering Options

This chapter describes the basic concepts of creating, manipulating, animating, and rendering objects in 3D space. Understanding these concepts will improve your ability to work in the 3D Studio MAX environment and help you solve problems faster.

Understanding MAX’s Object Concepts

Everything that you create in MAX is an object. As soon as you create an object, it is given a shape, size, color, name, pivot, bounding box, parameters, and other properties (see Figure 2.1).

FIGURE 2.1  An object is given certain attributes, such as the bounding box seen here, as soon as you create it.

After you create an object, you can model, animate, render, or delete it. But in order to do anything to an object, you must first select it. This is because MAX is written in an object-oriented programming language called C++.

In object-oriented programming languages, objects are matched up with commands. This means that when you select an object, you also select the types of commands that can be applied. The definition of an object also determines how an object will behave under different commands.

Object-orientation has its plusses and minuses. On the plus side, you don’t have to worry about giving an impossible command. In MAX, commands that are inappropriate for a selected object are simply grayed out (see Figure 2.2). On the minus side, if you like to hack around as a way to learn software, it can be difficult to figure out how to use all of the tools because they’re not all available at all times.

FIGURE 2.2  The Extrude and Lathe modifiers cannot be applied to a sphere.

Following the Object Dataflow

When you apply multiple commands to an object, they are evaluated, or calculated and executed, in a certain order according to the type of command given. This order of evaluation is called the object dataflow. You will also hear it referred to as the geometry pipeline.

In MAX, object dataflow begins with a master object. After evaluating the master object, the program evaluates modifiers, transforms, space warps, and object properties, in that order.

FIGURE 2.3  The object dataflow is the order in which MAX evaluates different types of commands.

Object dataflow is not necessarily the same as the order of application. For example, if you apply a series of transform commands, and then apply a modifier, the modifier will always be evaluated before the transforms. This can sometimes lead to unwanted results, but if you know about object dataflow, you can correct the problem.

	NOTE Chapter 4 includes a step-by-step description of how the dataflow affects modeling.

The Master Object

Object dataflow begins with the master object. A master object is like DNA: it defines the potential of an object before it actually has been created. Once you create an object by entering specific values for length, width, height, position, and so on, it is no longer a master object, but rather an explicitly defined object based on the potential of the master.

Master objects use the following attributes for creating objects:

Object Type Defines the nature of the object that is to be created. When you select an object type in the Create panel, you select not only its potential appearance, but what commands it will respond to, and how it will behave. Object types include mesh primitives, splines, patches, NURBS, lights, cameras, particles, space warps, helpers, and various compound object types such as Booleans.

Pivot Defines the position and orientation of an object in world space. It also serves as the point of origin for the axes of the object’s local coordinate system. This local system of reference defines an object space for locating sub-object components and for modeling the created object.

Object Creation Parameters Define the possible ways in which a type of object can be created by the program. Common object creation parameters include length, width, height, radius, segments, and slice. Other creation parameters define how an object may be created interactively.

Modifiers

The next stop in the geometry pipeline is the modifiers. After the initial attributes of the master object have been established, MAX evaluates any modifiers that have been applied. Modifiers are commands that affect objects in relation to their object space. They appear in the object’s modifier stack in the order in which you place them. Modifiers are always evaluated in order, from the bottom of the stack to the top. The object type of the master object is listed at the base of the stack to indicate that it is evaluated before the modifiers in the object dataflow (see Figure 2.4).

FIGURE 2.4  The modifier stack is an ordered list of commands.

Changing the order of the modifier stack commands can change the resulting appearance of the object they modify. For example, if you bend a box and then twist it, you will get different results than if you twist the box and then bend it (see Figure 2.5).

FIGURE 2.5  The box on the left was bent and then twisted. Compare it to the box on the right, which was twisted and then bent.

One of the most powerful features of modifier stacks is that they allow you to go back into the history of an object and change its creation and command parameters. This includes being able to go back and change the order of modifiers, duplicating and deleting them using the Edit Stack commands (see Figure 2.6). If you want to modify another object in a similar fashion, the edit commands allow you to copy the modifier stack from one object to another, as we’ve done in Figure 2.7.

FIGURE 2.6  Copying and pasting modifiers from a box to a cylinder.

FIGURE 2.7  As a result of changing the modifiers, the cylinder (right) tapers and bends like the box.

The modifier stack is also the vehicle for editing objects at the sub-object level. There are three ways to access the sub-object components of an object: apply a select modifier, apply an edit modifier, or convert the modified object to an editable object. Select and edit modifiers have the advantage of flexibility because they preserve the structure of the modifier stack. Editable objects have the advantage of speed, because the process of conversion eliminates the current list of modifiers so that the program no longer needs to evaluate them. The result of collapsing the stack (shown in Figure 2.8) is an explicitly defined object that is the sum of all previously applied commands.

FIGURE 2.8  Clicking Collapse All collapses the modifier stack.

Transforms

MAX next evaluates transforms. Transforms are related to modifiers in that they are sometimes used for modeling objects. Unlike modifiers, transforms are calculated in relation to the world coordinate system, or world space, rather than the object’s local position or orientation. In addition, transforms are evaluated in a constantly updating matrix, which overwrites their data history. This means that you cannot go back and change a previously applied transform command, unless you use the Undo command or call up an earlier version of your scene. Transforms can easily be reversed by applying an opposite transform command, something we cannot do to modifiers.

Because MAX always evaluates modifiers before it evaluates transforms, you may get unexpected—and unwanted—results when using non-uniform scale and squash transforms with geometric modifiers. An XForm modifier circumvents this problem; applying an XForm modifier places a transform in the modifier stack to be evaluated there in the order of application, rather than after the whole stack has been evaluated. Look at the example in Figure 2.9. The object on the left is the result of applying a Squash transform to a cube and then bending it 90º. On the right, an XForm modifier was used to apply the Squash transform before bending it, providing a very different result.

FIGURE 2.9  On the left, squash then bend; on the right, bend then squash!

You can also use transforms in the modifier stack to edit and animate objects at the sub-object level (see Figure 2.10). Edit modifiers and editable objects both contain sub-object transform commands. If you use a select modifier to create a sub-object selection, you apply transforms to the selection using an XForm modifier.

FIGURE 2.10  Moving and scaling a sub-object selection

© 2000, Frol (selection, edition, publication)