|
Both
Available for both Mac and Windows. You will receive the version you specify in the check-out process.
|
In use for over twenty years by performers, composers, artists, scientists, teachers, and students, Max is the way to make your computer do things that reflect your individual ideas and dreams. Version 5 is a dramatic transformation of Max that begins the latest chapter in the program's history.
Max users are people who want to do things that go beyond the limitations of normal software. Max is a visual programming language -- you connect objects together with patch cords to design what you want. While people have used Max to create a wide variety of applications, it's primarily designed to handle the basic elements of media: time, interactivity, and control.
Time
Working with time is easier in Max than traditional programming because you use objects to create visual "timing machines" whose behavior you can see, hear, and modify as they operate.
In Max, the basic unit of time is milliseconds, but you can also use metrical time (for example, bars and beats). In Max, everything you create runs at the same time, something that is very hard to do in a traditional language. In addition to the metro object shown above, Max features timing objects that delay, quantize, measure time intervals, and perform time-based filtering. Max's unified notion of control based on numbers and events permits you to work with time in an intuitive and consistent way.
Interactivity
Working with interactivity is easier in Max because you can design interfaces visually, and the interfaces are then part of the program itself. For example, controls the timing and transport of the timing example above.
Max contains a rich set of user interface tools, including dials, buttons, menus, and text editors. At a deeper level, it's possible to control the entire user experience with cross-platform support for full-screen interfaces, HI devices, Quicktime video, and an embedded web browser. You can even script Max to construct interfaces dynamically.
Control
In Max everything can be connected to everything, because everything speaks numbers. Another way to say this is that modularity is a core design principle of everything in the software.
Max can control MIDI devices, serial devices, send data over a network, and handle user input devices. Any source of control is easily connected to anything you want to control. Most commonly, however, Max's powerful control features are applied to audio via MSP and visual media with Jitter. And MSP and Jitter offer their own control possibilities, from audio signal analyzers to video tracking and device support.
Extensibility
Max is powerful, but it might not do precisely what you want right out of the box. That hasn't stopped Max users from extending the environment in every possible direction. As a by-product of their work with the software, passionate Max users have contributed thousands of objects written in C, Java, or Javascript back to the user community.
Educational Resources
Even with an environment as interactive as Max, learning programming doesn't necessarily happen instantly. Cycling '74 is committed to making learning their software as rewarding as possible, and they have recently put an enormous amount of effort into integrating their documentation into the software. You'll learn Max, MSP and Jitter using over a hundred step-by-step tutorials, plus a variety of other resources including interactive help files, examples, and reference materials you can access directly within the software.
Patching and Workflow
The Max 5 patcher is completely reworked, but it won't be unfamiliar. It now supports multiple undo, the ability to zoom in and out, and a grid -- features many users requested. You'll immediately notice the redesigned objects supporting compositing and more typographic options. Something that will quickly become one of your favorite features of Max is the ability to create objects using the keyboard. Type n and get an object box at the current cursor position, m for message box, and so on.
Once you make an object box, type the first letter of the object you want to make, and an auto-completion window appears. Type a space to accept the auto-completed object name and you're ready to type in the arguments (if any).
Creating new objects is just a small part of the total time spent making a patcher. A lot of time is spent cleaning up your work and making a presentable user interface. Unfortunately, some of the same features of Max that made it easy to patch things together often get in the way during the user interface refinement process.
While Max 5's grid can help keep things neat, the "spaghetti" of patch cords is still a burden. The solution to this problem was to create a Presentation Mode of patching in which patch cords disappear completely. Presentation Mode is simple: objects can belong to the presentation if you want to see them in the user interface of your patch. If an object is in the presentation, it can have a different presentation-mode-specific size and location in the patcher window. This way, you don't need to deal with spaghetti to create a user interface, and you don't need to rearrange your patch to fit your screen layout.
Presentation mode works hand-in-hand with the Max 5's ability to open multiple views of the same patcher. You can have one view of a patcher in the traditional patching mode, and a second view showing the presentation. Selecting objects in one view will show you where they are in the other view. Multiple views are also useful in conjunction with a feature called Modify Read-Only that permits you to edit abstractions and bpatchers "in place." Users often prefer to use embedded subpatchers over subpatcher files (abstractions) or bpatchers because the embedded subpatchers can be edited. However, because they are embedded in a parent patch, they are not easily reused. Modify Read-Only makes it possible to edit an abstraction directly as if it were an embedded subpatch, so you don't need to guess how it will work. With bpatchers, you can edit the original patch directly in second view, while previewing the appearance of the bpatcher in the first view.
In order to give you a clean work surface, the object palette has been removed from the patcher window. The object palette is now a translucent resizable window that pops up when you need it.
A toolbar at the bottom of the patcher window gives you easy access to common tasks such as locking and unlocking a patcher, adding objects, switching in and out of presentation mode, and zooming.
Debugging
Even experienced Max users can spend a lot of time trying to figure out what their patches are doing. Usually, you add objects to print out some data in various locations in a patch. However, this doesn't work so well for complex data such as audio signals and Jitter matrices. Max 5 has a slew of debugging features:
- signal and matrix probes that display audio and matrix data as you move the mouse over a patch cord
- monitor watchpoints that display and capture data flowing through a patch cord
- error messages that are tied to specific objects. When you click on an error message in the Max window, the object that generated it is highlighted, even if it is somewhere within a subpatcher.
- break watchpoints for stepping through a patcher that are visible on patch cords and can be saved in files
- a debug window that shows the execution stack as you step through a patch -- any object in the stack can be inspected to show its current state
Integrated Documentation
Over the past decade, Cycling '74 has worked to keep the Max documentation up to date, but while the content was current, the means of presenting it was a hassle for people trying to learn the software. Since the manual was in a PDF document, you had to switch back and forth between Max and a PDF reader if you wanted to work through a tutorial. Similarly, reference information describing what objects do was never available when you needed it.
For Max 5, there’s an integrated system created for documentation to let you better exploit the time spent describing the software. For new users, all of the Max tutorials have been rewritten from scratch to remove the original 1990s MIDI orientation that no longer applies to the entire Max user community. You'll read the tutorials in a browser window within Max, and click on links to open the accompanying tutorial patchers.
Moreover, all the documentation that comes with Max is now online (minus the part that controls Max) and you can take a look at it here.
For experienced users, the information that used to be in articles called "topics" have been reorganized into short task-oriented pages called vignettes. Vignettes are full of links to other related vignettes, as well as related tutorials and object reference pages.
Perhaps the coolest application of the documentation technology concerns the object reference pages. The object reference documentation isn't just a page of text anymore. In conjunction with an interactive documentation resource called the clue window, the object reference information is presented dynamically as you work. For example, when you type the name of an object into an object box, a clue appears telling you about the arguments to the object, so if you don't remember them, you don't need to consult the reference page or open a help file.
When you click on the left inlet of an object, you see the Quick Reference menu, listing all of the messages and attributes an object uses. As you move the mouse over a message or attribute, the Clue window describes what the messages or attribute does. Clues appear for every menu item, every preference in the preferences window, every toolbar icon, and every attribute you edit in an object inspector.
Object reference pages themselves are now as easy to access as a help file. They're even accessible from within help files.
Searching and Finding
Here's another scenario that’s been changed. You're looking for a movie file to play in a jit.qt.movie or imovie object. You create a new message box, type read into it, connect the message box to the object, lock the patch, click the message box, try to remember the name of the folder where the movie was stored in the tedious open file dialog, click OK, and finally, the movie is loaded.
This process was made a little easier. A File Browser was added to Max 5 that uses a database to keep track of every file you use. The File Browser lets you create and save "queries" describing files you're interested in accessing (for example, all audio files created within the last two weeks that begin with "t"). Once you find the file you're after, you can preview it directly inside the file browser window, then drag the file right into your patcher. Files can even be dragged onto objects. For example, you can drag a movie file onto imovie or jit.qt.movie, the movie will be loaded into the object.
The database also indexes the documentation. Use the documentation window to search for anything related to "counter" for example, and you will see a familiar-looking results page with links to all relevant documents.
Finally, an interface was created, inspired by the web browser for finding objects in a patcher. The "find bar" lets you type in some text and iterate through all of the objects that match. Find will even tell you if your match was found inside any subpatchers, then opens them so you can see matches there too.
Timing
While most of the changes in Max 5 concern the programming environment, there was one area of the program where Cycling ‘74 wanted to extend and enhance what you can do with Max: in short, they wanted you to be able to specify time in terms of bars and beats as well as milliseconds. Almost all timing objects in Max 5 will now permit you to use what’s called metrical time. For example, a metro object with argument 4n outputs a bang every quarter note. Audio objects such as phasor~ and line~ know about metrical time too, and the vst~ object uses this system to provide host synchronization to plug-ins. Keep in mind, this way of talking about time is optional -- traditional Max millisecond timing works as it always has, and both systems can be used simultaneously.
All objects whose time is specified in terms of bars, beats, or notevalues are synchronized to a clock controlled by the transport object. In addition to time intervals, time locations can be specified in metrical units. The timepoint object is both simple and powerful. It merely sends out a bang at a specified time. While timepoint can be used to trigger events, it can also be used to control the timing system itself. For example, if you want a four bar loop, have a timepoint 5 1 0 object reset the time of a transport object to the beginning (1 1 0, or just 0). And unlike a mere sequencer, you can have as many transports running simultaneously as you want.
The timing features permit you to think about time in a very general, computational way, just as MSP does with signal data or Jitter does with matrix data. For example, using the translate object, you can convert between milliseconds and metrical time values.
No questions available - feel free to add yours below!
Have a question? Our tech specialists are here to help you and
usually respond on the same business day!
Want answers now? Try our on-line chat, or
call 1-800-510-4385.
Already own this product?
Get tech support.
|
PC
|
Mac
|
|
- Windows XP/Vista
- 500 Mhz P3 or better processor
- 1 GB RAM
- Full installation of Quicktime for Windows is required for MP3 import, movie playback, and use of image files other than PICT
- ASIO-compatible sound card is recommended for optimum audio performance.
- Quicktime 7.1 or later
- OpenGL-compatible graphics card
- OpenGL 1.4 or later
|
- OS X 10.4 or later
- PPC or Intel machine
- 1 GB RAM
- Quicktime 7.1 or later
- OpenGL-compatible graphics card
- OpenGL 1.4 or later
|
