Thinking Like Max
To use MAX to its fullest potential, you have to learn to think the way the program does. Once you've mastered its central concepts, these principles will open the doors to the full range of power and flexibility for which MAX is so famous.
Every program has its own personality. 3D Studio MAX has a style of workflow and organization that is both powerful and unique, and the more you work with it, the more comfortable you become with its seamlessly integrated toolset. More than any other 3D graphics application I know of, MAX is built on certain underlying concepts that must be understood in a general way if you want to work with the program. A mark of the serious MAX practitioner is in the mastery of these few subtle concepts on which the towering edifice is built. With these concepts in hand, you begin to think like MAX, and the overwhelming number of tools and options becomes manageable.
MAX requires you to strategize and think according to a plan that best exploits its toolset. If you can learn to think as MAX does, you'll see the same principles repeating themselves in every corner and at every level of the program. Not only will you be able to learn new features more quickly, but you will also understand their logical connections to the rest of the program. MAX, for all its complexity, is extremely well thought out.
In the famous story, three blind men examining an elephant with their hands come to completely different conclusions about the creature's shape. MAX is such a big and complex application that each user tends to see it from a different perspective. To get you started from the same vantage point I'm using, consider the concept of an "object" in MAX.
The "Object" In MAX
If you're a programmer, you're likely to have your own understanding of the term "object-oriented programming." This huge concept encompasses many things, and MAX is all of them. It is a masterpiece of object-oriented software design, maybe the best-written application I have ever seen (certainly for its size). But the 3D artist who is not a programmer must still understand at least the single most important aspect of MAX's object-oriented nature: There is no clear distinction between data and functions.
In traditional programming theory, data and functions are two distinct concepts. Data is simply information-a numerical value, a string of text characters, whatever. It is static.
A function (or procedure) is an action. A function acts on data, generally to create new data. Data is passed into a function, which processes it to produce output data. This is a bit of an oversimplification, but not much. Suppose that we write a function designed to add two numbers together. The two numbers are data that are input into the function. The sum is the output, which is also data. The function must contain "slots" into which the two numbers can be input, and these slots are the function's "parameters." This concept of parameters is, as you will soon see, one of the most basic concepts in 3D Studio MAX.
In most 3D applications (even though they are typically programmed using object-oriented tools), the distinction between data and functions remains clear to the user. When you create a primitive object (a sphere, for example), a function is called that produces the sphere data object. If you want to change the sphere in some way, another function is called that takes the current sphere data as input and processes it to produce new data. In pure object-
oriented theory, however, there is no clear distinction between data and functions. Instead, data and related functions are packaged together into units called objects. A MAX Sphere primitive (or indeed, any MAX primitive) is more easily thought of as a function used to draw a box, rather than the box itself. This concept applies throughout the program.
Let's take a closer look.
I've just introduced the idea of the "object" in MAX. To give this concept some practical meaning, go to the Create panel and click on the Box primitive to create a box. Look down the panel to the section named Parameters. If you haven't begun to draw the box yet, the screen should look like Figure 1.1.
Note: 3D objects that can be created directly by an application (without building from component parts) are called primitives in the language of computer graphics.
Think of this as a function. If you were a programmer writing a function that permitted a user to create a Box primitive, what input values would be necessary? What parameters would the function require to generate a valid output?
You would have to tell the function how tall, how wide, and how long the box should be. Because you are working with 3D polygonal models, you would also have to tell the function how many polygonal units there should be in each dimension. Leaving the issue of the mapping coordinates for later, notice that these are precisely the parameters (input values) that the box object is seeking. So by entering values into these slots, either by direct keyboard entry or by drawing interactively on the screen, the function gets the input values it needs to generate the output.
Compare the input parameters for a sphere, as seen in Figure 1.2. Once again, think of the information a function would need to create a polygonal sphere-it would need to know the radius (or diameter) and the amount of polygonal segmentation. MAX adds some more parameters because a MAX Sphere primitive is a bigger concept than a mere ball (it contains chopped spheres as well). This should be enough to give you the idea. The Sphere primitive is a function asking for input parameters.
So what? Doesn't every program do this? In every other program, there's a basic distinction between the function used to create the primitive and the primitive itself. The primitive is just data, the output of the function. Once the function has been used to create the data, it's gone until you call it again to create another object. MAX is completely different, however. The box or sphere that you create in MAX is not just data; it is the function and its input data together in the purest object-oriented style. The function persists, and if you change the input values (the parameters) at any later time, the primitive object is redrawn from scratch.