Search icon CANCEL
Subscription
0
Cart icon
Your Cart (0 item)
Close icon
You have no products in your basket yet
Save more on your purchases! discount-offer-chevron-icon
Savings automatically calculated. No voucher code required.
Arrow left icon
Explore Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Newsletter Hub
Free Learning
Arrow right icon
timer SALE ENDS IN
0 Days
:
00 Hours
:
00 Minutes
:
00 Seconds
Multimedia Programming Using Max/MSP and TouchDesigner
Multimedia Programming Using Max/MSP and TouchDesigner

Multimedia Programming Using Max/MSP and TouchDesigner: Design, build, and refine immersive audio-visual apps and performance environments

eBook
$28.99 $32.99
Paperback
$54.99
Subscription
Free Trial
Renews at $19.99p/m

What do you get with Print?

Product feature icon Instant access to your digital copy whilst your Print order is Shipped
Product feature icon Paperback book shipped to your preferred address
Product feature icon Redeem a companion digital copy on all Print orders
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
OR
Modal Close icon
Payment Processing...
tick Completed

Shipping Address

Billing Address

Shipping Methods
Table of content icon View table of contents Preview book icon Preview Book

Multimedia Programming Using Max/MSP and TouchDesigner

Chapter 1. Getting Started with Max

In this chapter, we will explore the fundamentals of Max. We will see what it is, how to use it, what we can use it for, and what Max is not capable of, or for which tasks it would be cumbersome to use it. You'll understand when it's appropriate to use Max and when it could lead to frustration. Max is quite different in comparison to other (text-oriented) programming languages. It has the strength of being very intuitive as you will see; it can do a lot in real time, so we can get very direct feedback to what we do. In this chapter, we will try to get a feeling of what Max is and what comes with it, and start looking at the general workflow. We will cover the following topics:

  • Understanding Max and how it works
  • MSP (audio and signal processing in Max)
  • Jitter (video and matrix processing in Max)

Understanding the basic concepts of Max

Cycling'74, the company that produces the software, defines it as a toolkit for audiovisual/multimedia expressions that don't demand much knowledge about programming. In fact, Max is a graphical programming language that lets us avoid the traditionally steep learning curve of text-oriented programming languages to some extent. We simply put boxes into an empty canvas, called a patcher or a patch, and connect them, patching them together.

Tip

Downloading the example code

You can download the example code files for all Packt books you have purchased from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you. In case of Max examples, all examples (except for the first two chapters) are provided as so called Max projects. For each chapter, just open the corresponding *.maxproj file.

Let's compare graphical programming with other representations of code for a minute. Look at this patcher:

Understanding the basic concepts of Max

Don't bother about the vocabulary, that is the object names, too much. This is a special patcher. It is also called a gen~ patcher, and we use it here since it allows us to see the code generated under the hood. However, this gen~ patcher is using a somewhat different vocabulary (object names). So, don't try to implement this right away; we'll have a slightly theoretical start for now. Can you already see what's happening? Imagine a number, say 0, coming into our patcher at [in 1]. You can see that first, we add 1 to our incoming number, resulting in 1. Then, we multiply it with 0.5 (or divide it by 2), resulting in 0.5. Afterwards, we subtract 0.2 and get 0.3, which will be sent to the output of our little patcher. The program we see here doesn't do anything very useful, but it will hopefully illustrate differences in representing mathematical operations. By now, you have seen two representations of what's happening; the last few sentences describe what's happening in the patcher and the patcher itself. In essence, these sentences are like a recipe for cooking. Let's add another equation for reference:

Understanding the basic concepts of Max

Don't be afraid of the notation. For simplicity, you can simply ignore the n subscriptions, but this is a common notation that you will encounter very often. The x parameter usually denotes an incoming value, and it corresponds to our [in 1] in our patcher; y corresponds to the output, [out 1]. The n parameter stands for a running index. Since we are usually dealing with a sequence of incoming numbers, we have to be able to address this fact. In some cases, we would, for example, like to combine the input with the previous input in some way. To give an example for this case, let's think of an expression that outputs the input plus the previous number's input:

Understanding the basic concepts of Max

You don't have to understand what this is actually doing right now; this is just to make you familiar with another way of representing our code. We will later see how to create an n-1 term in max (a one-sample delay), but now, let's concentrate on another form of representing our first patcher:

add_1 = in1 + 1;
mul_2 = add_1 * 0.5;
sub_3 = mul_2 - 0.2;
out1 = sub_3;

This might look a bit overcomplicated for such a simple operation. It is the code that Max automatically generated for us when we created our patch. You can see that we are constantly assigning values to variables, for example the variable sub_3 is assigned the value mul_2 – 0.2, which is referring to the variable mul_2 and so on, until we reach in1. One can certainly write this program in a more elegant way, but let's stick to this version for now.

Think about the differences in these four representations of a system:

  • Mathematical (the previous equation)
  • Code (C++, as in the previous code)
  • Data flow (Max patch) / block diagram (as in our patcher depicted previously)
  • Text (a recipe that explains what to do in natural human language)

Each one of them has its strengths and weaknesses. A mathematical expression is concise and precise. On the other hand, mathematical expressions that describe a system can be declarative (meaning not giving us a recipe to get from the input to output but only describing a relation as it's the case for differential equations). Code, Max patches, and written recipes, on the other hand, are always imperative. They tell us what to do with the input so as to get the output. A Max patch has the advantage that the flow of data is always obvious. We always go from the outlets of an object to the input of another, typically using a line, going from top to bottom. A traditionally coded program doesn't need to be that way. This, for example, looks much like our mathematical representation and does not provide us with an impression of the order of operations as quickly as a Max patch does:

out1 = (in1+1)*0.5-0.2

It is yet another valid version of our code, a bit tidier than the automatically generated code of course.

So, we can see that one major advantage of Max patching is that we can quickly see the order of operations, just like when we connect the guitar stomp boxes' input to the output, as shown in the following figure:

Understanding the basic concepts of Max

I leave it to you to reflect on the differences of these representations in our text recipe.

Modular basis for expressions

We saw that Max can create code for us that looks very much like C++. There are some special cases, namely the gen domain, which we will see in Chapter 6, Low-level Patching in Gen, in which we can actually see and also export the code that Max is creating from our visual programming. You can think of Max as a high-level programming language in which we put together code we don't quite know. The details of this are both an advantage and a disadvantage of Max, but often, we won't care about the code itself.

We lose some control over what's actually happening, but there are lots of things we don't want to see and don't want to care about in typical multimedia programming. We usually don't want to deal with memory allocation when our aim is to quickly build a synthesizer, for example. A good tool for a certain task allows us to control all parameters that are of any interest for a certain task, not less and not more. For multimedia programming, Max is very close to this objective.

The real power of Max is in its modularity. Think of it like a basis, an infrastructure where you can not only patch but also embed text-oriented programming very easily. Numerous programming languages such as JavaScript, Java, Python, and others can be used within Max if we believe that a task requires these or is simply achieved quicker or better with a different approach than patching. Many people learned, for example, JavaScript simply because they wanted to improve their Max patching, so Max can serve you as a starting point to get into programming in general if you like, but only if you like. Of course, in general, it can be considered a good thing to be able to achieve a result in various ways by using different programming languages because you can always choose, and also because you have the opportunity to get many perspectives on programming methodology, problem solving, and problems themselves.

When to use Max

If you think of our previous different representations, you might notice that the last version might be the one that could be created in the fastest fashion. It's simply faster to type the following than it is to put objects in a Max patch, hopefully in a tidy way, and connect them:

out1 = (in1+1)*0.5-0.2

If we know exactly what we want to achieve and how to achieve it, meaning we have a picture in our minds of all operations needed to accomplish a calculation, we will typically be faster in a text-programming language than in a graphical one. However, as soon as there is some doubt about how we want to do things, or what our objective really is, a graphical programming language that also doesn't need to compile each time we want to test the result will be more inspiring and faster. We can just try out things a lot quicker, which might inspire us. If you think about experimental music for example, the word suggests it's all about trying things out, doing experiments. With Max, we get our results really fast.

A word of caution should be said though. If we are working in Max, the target is often an aesthetic one, be it music, video art, or dancing robots. If we do so, there is often a fair amount of technical interest or necessity that drives us; otherwise, we could have done the job in a higher-level application. A very common danger is to lose the target of creating beautiful things while programming the tools for them night and day. In this regard, Max is also more dangerous than a Digital Audio Workstation (DAW) but a lot less than traditional programming languages.

It's hard to find general rules when the Max/MSP/Jitter package is the best tool for a problem, mainly because it is highly individualistic. If you just started Max and are a Java professional, it does not make sense to recommend using Max for everything it can do. Mostly, we use Max when it's the most efficient solution, meaning we can get the task at hand done in the fastest way and with the most satisfying overall result within Max. However, there are problems that have a structure that is very close to a Max way of thinking and others that don't. Real-time signal-processing certainly is one of the strengths of Max since it generally follows a block diagram form and is optimized for real-time processing. Don't forget that Max is designed to do signal-processing particularly well. Also, the ease with which we can often design an appealing GUI is an advantage. Problems that are easily solved in other programming languages (but partly can be done in Max) include recursive algorithms, problems that ask for object-oriented programming, database management, optimization problems, large-scale logical systems, and web-related problems. Some of these can of course be solved with a different language and can be embedded within Max.

Max – the message domain

Max is only one part of what you get when you purchase it. The full package actually consists of Max, MSP, Jitter, and Gen (optional). Max was the first building block and will usually serve as our infrastructure and control surface. It will handle data flying through our patches and sequence events, control the others (MSP, Jitter, and Gen), handle user input, handle the GUI, and so to speak the desk on which everything else is lying around. We'll now go through a simple Max patch, and later, a similar MSP and Jitter one, and we'll see what these are good at. For everything else in general, it's a good idea to use plain Max within the Max/MS/Jitter universe. Let's consider our first Max-only patch:

Max – the message domain

You could say that this patch is made up of the following three elements:

  • Input (a button we can click on)
  • Processing
  • Output (the float number box, [flonum], at the bottom that lets us see the result)

So [counter] counts how many times we clicked on the button; then, we do some calculations on that number (you might see that it's the same calculation we looked at before) and output the result to the screen.

Note

Notice that this patch isn't doing anything unless we click the button. This is an important concept and a major difference between the Max realm and the MSP and Gen~ domains.

We call the message that comes out of the button a bang. It is nothing more than an event. You could say it is how one Max object (one of the boxes) shouts to another: now! and the receiving object knows what to do if we patched everything together correctly. In the example given along with the counter, the bang message that comes from the button object simply tells the counter to increase the number output by one. You will meet this event-based concept everywhere in Max and it will be worthwhile to understand it thoroughly and have it in the back of your head while programming, but we will come to this again later in Chapter 2, Max Setup and Basics and in Chapter 3, Advanced Programming Techniques in Max.

Max Signal Processing

Without further investigation, we'll dive into analogies for the example we just looked at in all the other worlds; first, let's look at Max Signal Processing (MSP):

Max Signal Processing

As you can see, we are still doing the same small calculation. MSP is the audio part of Max, and so all the operations that we are applying are suited for audio signals but can be used for all sorts of things, such as doing this calculation. You can recognize an MSP object by its little tilde (~) at the end of its name. The tilde isn't used a lot in many languages, which results in partly strange locations on computer keyboards. Please refer to the English Wikipedia entry on the tilde to find a key combination to create a tilde on your keyboard.

This time, our input is an [adc~ 1] object. The adc term stands for analog to digital conversion; it's just our audio input. Beware, this is a tricky patcher; I've hidden many things for didactical reasons, but if you wish, go ahead and look at the patcher itself (by double-clicking on p counter). Instead of monitoring whether a button has been pushed, we are checking whether the audio input level is high. Essentially, you can clap your hands instead of pushing a button (this is a very primitive clap detector though). Again, we count how often we clapped, process that count, and output a number.

The important difference to the Max version is that we are always dealing with streams of numbers in MSP, namely we are getting sample rate number of values every second, even if nothing is happening, for example, adding two constants. Refer to the following screenshot:

Max Signal Processing

Here, we are adding 0 and 0 and as a result, we get 0 of course. Seems like an inexpensive process regarding CPU right? Well it is, but bear in mind that we are calculating 0 + 0 = 0 44,100 times per second in my case of a 44.1 kHz sample rate. So, the takeaway message here really is that in MSP, if we have a static input, it doesn't mean that we are not processing, so it doesn't mean we are not crunching numbers all the time. We will learn how to deal with this problem using the [poly~] object in a later chapter.

This difference in the Max world is one reason why this simple patch became complicated (the things I have hidden in the screenshot). To really stick to the analogy instead of outputting a number, we can have an output sound, for example, a sine wave with the resulting number as audible sound, but let's keep things simple here for now.

To sum it up, we can say that we use MSP when we want to process audio (there are exceptions, though). However, there are other situations in which we would want to use MSP due to the way in which it treats data. MSP processes floating-point numbers with a 64-bit resolution called double precision, whereas Max represents floats with 32-bits (the MSP [buffer~] object also stores its values only with 32-bits). So we essentially have more precision and can represent both bigger and smaller numbers in MSP than in Max. Also, and this is maybe even more important, we not only have a bigger resolution of our values but in time as well. The default scheduler interval of Max runs at 1 ms, so at 1000 Hz it is able to represent signals with a maximum frequency of 500 Hz, in theory. Without going into that theory too deep (Sampling theory and the Nyquist rate), you can imagine that if we process 1,000 values per second, we can't work with signals at higher frequencies. However, that's the job of MSP, and we tend to use MSP for all time-critical processes such as drum sequencers and everything where timing should be really tight. We'll use MSP simply for all high frequency (≥ 100 Hz might be a good border here) data that we manage to create in or get into our software.

Jitter, Matrix, and video processing

Let's take a look at the Jitter version:

Jitter, Matrix, and video processing

Don't be afraid! I know it looks complicated and we won't go over every detail since it's needless to understand everything at this point. The difficulty here is only that if we still follow our analogy, we have to analyze incoming video as the input of our system. It actually still is our senseless small calculation, but since Jitter is made for matrix calculation and especially for video material, we do everything in matrices here. Our clap detector becomes a flash light detector, and doing the actual counting in Jitter is also not a task you should start with when learning Jitter. However, if you look closely, you can see that at the very bottom, there are three [jit.op] objects that are doing the actual processing. Everything else is just to get a trigger signal out of our video input and to also count these triggers within this video context. This is a highly complicated way to achieve our initial goal, but it should show you that we can also calculate anything with matrices. Many things are hidden in there, which you can take a look at later.

Jitter processes are somewhat similar to Max processes. It runs at the scheduler rate (see Chapter 2, Max Setup and Basics and Chapter 3, Advanced Programming Techniques in Max) that Max does, in contrast to MSP that runs at audio rate. Also, nothing is processing if the input is static or if we trigger calculations. Usually, if we are really working with video signals, we want to achieve frame rates between 25 and 60 fps; therefore, it's also similar to how things work in MSP: a stream of data. The difference in MSP is that we are in more direct control of the rate; we have to drive the system with a [metro] object that is sending out bangs at a given rate. In the Jitter context, we will typically use a [qmetro] object. It's the same as the [metro] object with the difference that it waits for other processes (like drawing the last frame) to get completed. Refer to Chapter 2, Max Setup and Basics for the scheduler and priority. In this case, it's our [qmetro] object that is sending out a bang (resulting in the computation of the next frame), each of which is 30 milliseconds; therefore, we are running our computations at ~33 fps (1/interval in seconds = fps or also Hz).

Jitter data format

Jitter matrices are divided into planes. Planes are similar to what one often calls a channel (for example, an alpha channel, a red channel, and so on) in video technique. Let's consider the format of a standard video signal in Jitter; we have an alpha plane, a red plane, a green, and a blue one for video. Each of these planes is a two-dimensional matrix in itself; it has, for example, 1,080 columns and 720 rows, so one cell per pixel. Or you could think of it this way; each cell or pixel, in the case of a video signal, needs to store four values; therefore, we represent each pixel with 4 cells each on an individual plane. This leads us to an imagination that is depicted later; take it with a grain of salt.

The plane count is something different than the dimensions of a matrix. As soon as we have a plane count greater than 1, we can think of it as adding one dimension, independent of what the plane count might be. For a detailed explanation on Jitter matrices, refer to http://cycling74.com/docs/max5/tutorials/jit-tut/jitterwhatisamatrix.html.

The following diagram shows a two-dimensional Jitter matrix with 4 planes illustrated in three dimensions. If our plane count is greater than one, then we can imagine our matrix to have one additional dimension:

Jitter data format

Now, since you have an idea of how Jitter handles data, you can imagine that as soon as we are confronted with multidimensional data, it's a good idea to do processing with Jitter (or even with a shader). We have tools to process arrays or lists in Max and MSP, but as soon as data gets two or more dimensions, we'll tend to use Jitter. We can have up to 32 planes and use up to 32 dimensions. Obviously, this data can grow quite quickly; therefore, we have the advantage of having great control over the bit depth, but we'll take a look at this in more detail in Chapter 7, Video in Max/Jitter of this book.

Summary

We have seen that Max is inspired by block diagrams and an I connect one device to another workflow that is reinforcing experimentation and visual thinking. Being familiar with Max helps us sometimes to choose between Max/MSP/Jitter for a certain task or use something different. I didn't outline differences between Max and other visual programming languages, concentrating on multimedia expressions like Max's brother environment Pd, Reaktor, vvvv, Usine, Bidule, SynthMaker, TouchDesigner Audulus, and others. There are simply way too many out there. However, we made some progress on understanding the different territories within Max and what their advantages and disadvantages are. In short, we learned that high frequency or very high-timing accuracy leads us to MSP and multidimensional (>2) data that tends to ask for the use of Jitter. The Max domain itself is here for everything else and often it's used to build bridges between the other environments as well.

In the next chapters, we will dive right into Max, and we'll see how to configure it to our needs and customize it, and get some small projects going. We'll get to know Max a lot more and soon, we will build a simple synthesizer, getting ready for more audio processing.

Exercises

  1. Try to think of your projects, ideas, and reasons why you actually want to learn Max and why you bought this book. Take the project apart in your head or think of some bits of code necessary to achieve the whole idea if you put them together the right way. In what environments (Max, MSP, Jitter, or something else) would these be written? Try to think of cases where it's not as clear as in a simple synthesizer.
  2. Think about a project that incorporates audio and video. What processes are done in which environment? Draw a simple flowchart and think about where it's best to go from Jitter to MSP or the other way around.
  3. Open our MSP counter/processing patch from the beginning of this chapter. Go inside [p counter] (a subpatcher, we'll learn about this shortly) by double-clicking on it. Try to think about what's happening in there and why it's necessary.
Left arrow icon Right arrow icon

Description

Max 6 and TouchDesigner are both high-level visual programming languages based on the metaphor of connecting computational objects with patch cords. This guide will teach you how to design and build high-quality audio-visual systems in Max 6 and TouchDesigner, giving you competence in both designing and using these real-time systems. In the first few chapters, you will learn the basics of designing tools to generate audio-visual experiences through easy-to-follow instructions aimed at beginners and intermediate. Then, we combine tools such as Gen, Jitter, and TouchDesigner to work along with Max 6 to create 2D and 3D visualizations, this book provides you with tutorials based on creating generative art synchronized to audio. By the end of the book, you will be able to design and structure highly interactive, real-time systems.

Who is this book for?

If you want to learn how to use Max 6 and/or TouchDesigner, or work in audio-visual real-time processing, this is the book for you. It is intended for intermediate users of both programs and can be helpful for artists, designers, musicians, VJs, and researchers. A basic understanding of audio principles is advantageous.

What you will learn

  • Build well-structured systems for multimedia
  • Build audio synthesis tool using Max/MSP
  • Create versatile sampling programs
  • Design tools to generate visuals from scratch with TouchDesigner
  • Generate audio-visual systems using tools such as Gen and Jitter
  • Apply a procedural approach to both audio and video
  • Get to grips with both rapid prototyping and beginner s examples as professional design principles
  • Expand your tools and generate custom tool sets for future projects
Estimated delivery fee Deliver to United States

Economy delivery 10 - 13 business days

Free $6.95

Premium delivery 6 - 9 business days

$21.95
(Includes tracking information)

Product Details

Country selected
Publication date, Length, Edition, Language, ISBN-13
Publication date : Nov 26, 2014
Length: 404 pages
Edition : 1st
Language : English
ISBN-13 : 9781849699716
Concepts :

What do you get with Print?

Product feature icon Instant access to your digital copy whilst your Print order is Shipped
Product feature icon Paperback book shipped to your preferred address
Product feature icon Redeem a companion digital copy on all Print orders
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
OR
Modal Close icon
Payment Processing...
tick Completed

Shipping Address

Billing Address

Shipping Methods
Estimated delivery fee Deliver to United States

Economy delivery 10 - 13 business days

Free $6.95

Premium delivery 6 - 9 business days

$21.95
(Includes tracking information)

Product Details

Publication date : Nov 26, 2014
Length: 404 pages
Edition : 1st
Language : English
ISBN-13 : 9781849699716
Concepts :

Packt Subscriptions

See our plans and pricing
Modal Close icon
$19.99 billed monthly
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Simple pricing, no contract
$199.99 billed annually
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just $5 each
Feature tick icon Exclusive print discounts
$279.99 billed in 18 months
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just $5 each
Feature tick icon Exclusive print discounts

Frequently bought together


Stars icon
Total $ 142.97
Multimedia Programming Using Max/MSP and TouchDesigner
$54.99
GLSL Essentials
$38.99
Multimedia Programming with Pure Data
$48.99
Total $ 142.97 Stars icon

Table of Contents

13 Chapters
1. Getting Started with Max Chevron down icon Chevron up icon
2. Max Setup and Basics Chevron down icon Chevron up icon
3. Advanced Programming Techniques in Max Chevron down icon Chevron up icon
4. Basic Audio in Max/MSP Chevron down icon Chevron up icon
5. Advanced Audio in Max/MSP Chevron down icon Chevron up icon
6. Low-level Patching in Gen Chevron down icon Chevron up icon
7. Video in Max/Jitter Chevron down icon Chevron up icon
8. Max for Live Chevron down icon Chevron up icon
9. Basic Visualization Using TouchDesigner Chevron down icon Chevron up icon
10. Advanced Visualization Using TouchDesigner Chevron down icon Chevron up icon
11. 3D Rendering and Examples Chevron down icon Chevron up icon
12. Connecting Our Software to the World Chevron down icon Chevron up icon
Index Chevron down icon Chevron up icon

Customer reviews

Top Reviews
Rating distribution
Full star icon Full star icon Full star icon Full star icon Half star icon 4.9
(8 Ratings)
5 star 87.5%
4 star 12.5%
3 star 0%
2 star 0%
1 star 0%
Filter icon Filter
Top Reviews

Filter reviews by




Nicholas Johnson Jan 07, 2015
Full star icon Full star icon Full star icon Full star icon Full star icon 5
The book does a great job of covering a wide range of topics while managing to explain some of the in-depth functionality of Max/MSP and TouchDesigner. The book thoroughly covers audio processing and includes an explanation of Max modules using the underlying math formulas and includes snapshots of patches to help follow along. Jitter and Max for Live are also covered though only briefly as more emphasis is placed on the TouchDesigner. The book also includes a section about connecting sensors and microcontrollers including basic Arduino integration. The book provides a start-to-finish approach to understanding the in and outs of programming interactivity and I would recommend it to anyone wanting to get started exploring interactive media.
Amazon Verified review Amazon
kakinokimasato Feb 09, 2015
Full star icon Full star icon Full star icon Full star icon Full star icon 5
The preface of the book explains what it is about, and who benefit from it amazingly well.----This book is about the creation of multimedia content with a strong emphasison real-time generation of content. The two software packages, Max/MSP and TouchDesigner, are chosen as specialized tools to make the generation of audioand video material as flexible and intuitive as possible.[...]Both software packages, Max/MSP and TouchDesigner, are well documented. Trying to replace this documentation of two fast-changing pieces of software would be inappropriate.This book relies on you to consult this documentation, and therefore, the content of this book will go a lot further. While the initial chapters will address people who have never worked with the software, at the end of this book, very advanced topics will be covered. The idea is to not only provide a very profound basis to start with multimedia programming, but also to rely on the documentation and integrated help systems of the software packages, thereby covering as much material as possible.----If you end up reading this review on my website, you might be one of the people who did their best to learn Max/MSP/Jitter by reading all through (or most of) its built-in tutorials and realised they do not explain all. I’m just like that. If you’re like me, this book is existing definitely for you.When I read the ‘What this book covers’ description of ‘Chapter 1, Getting Started with Max’, I thought I could skip that chapter. But after reading the first 3 pages of the chapter, I understood I was wrong.The owner of the book can download Max patcher examples, the coloured images of the book and from Packtpub website (the publishing platform).The author is extremely helpful. In the beginning of ‘Max Setup and Basics’ chapter, he explains where the reader can help herself when stuck. He doesn’t finish that just by saying ‘Max has an good built-in help system’, but he mentions about ‘examples’ folder as ‘a slightly hidden help’, and even provide a tip and a manner for posting a question on Cycling ’74 forums. He even designates some other resources which can be useful to learn. The list includes Curtis Roads’ ‘Computer Music Tutorial’, and I guess some of you can make your mind to trust the author by that fact.Thanks to the book, I could get to know MaxToolBox, which is one of the most useful tools available for Max. The tool saves your time tremendously when patching. You can connect all the selected objects with the [shift + c] shortcut for example.https://github.com/natcl/maxtoolboxI’m now on page 71, and the book contains 383 pages (including such as index). This is quite a lot, but there’s no unnecessary verbose sentence. Most of them are prices and easy to understand.[Updated 08/02/15] OK, now I skipped some part and sneaked into the Gen chapter and the Jitter chapter. This is my first book which explains about the mysterious stuff around jit.gl.shader to a complete beginner. I’ve been seeking for such an explanation for a long time. Thanks to the book, I finally understand why we have to even care about that ‘shader’ stuff.[Updated 08/02/15] Now I finished the Max for Live chapter. That was very concise in a ideal way. The author designates where the reader can get useful information provided by Cycling ’74 (the developer of Max), and he covers the aspect where Cycling ’74 doesn’t explain sufficiently. Well done! And I even peeped the TouchDesigner chapter as well although I didn’t have any thought to start using TouchDesigner (because the book is so well written!). And actually, now I am interested in the software quite seriously by the following part of the chapter.----However, why don’t we just stick with Jitter?Jitter is great for many things, and certainly everything we see in the TD-related chapters can somehow also be done in Max/Jitter. However, some things would require us to write a good amount of OpenGL Shading Language (GLSL) code while working solely inside Jitter and trying to achieve these same things. Max came from algorithmic composition and moved towards audio processing. TD, in contrast, genuinely comes from graphics. Naturally, it has some advantages over Max’s Jitter, which I won’t list here since software is an ever-changing development. Even still, there are other languages such as vvvv and Processing. Let’s just say I personally think TD is the most intuitive one, without being less powerful; on the contrary, itis very powerful. Also, besides its bare capabilities, TD encourages experimenting, artistic expression, and technical development in a nearly optimal balance.----Well, I’ll start playing with Processing hard while waiting for TouchDesigner for Mac.[Some points where it could be improved]If you are a Mac user, some information like one about useful software, or about shortcuts can be slightly confusing, as the information tends to be designed for Windows users. Perhaps the author could add a disclaimer.I found some typos but they responded quickly to my reports and the errors would be fixed soon hopefully. [Updated] Actually there are quite a few minor mistakes (e.g. shortcuts). They are not crucial, but it’s becoming tough to report everything.Maybe the TouchDesigner part could be separated as a different book for a marketing reason. I think I would not buy the book if I just see the title and no other information, as I would Google and find out that TouchDesiner is not for me because it doesn’t work on Mac.[Updated 08/02/15] OK, it’s not actually something to be ‘improved’, but I think it’s fair for Jitter enthusiasists to mention that author says the following in Gen chapter. ‘Since this book proposes to use Max/MSP for audio and TouchDesigner for video generation, we will emphasize on the audio side of Gen here.’ Still there is a whole chapter about Jitter, but not deep into the use of Gen with Jitter.[Updated 08/02/15] Some of the naming of the example folders which you can download as compliment, are obscure to guess their content.[Conclusion]Even though the title says about TouchDesigner, this is also a very good book for complete beginners who are looking for a good starting book for Max (as it covers every aspect of Max), for beginners/improvers who found the official Max tutorials not informative enough, and for improvers who want to use Max more efficiently.
Amazon Verified review Amazon
Ricardo Thomasi Feb 14, 2015
Full star icon Full star icon Full star icon Full star icon Full star icon 5
Very good!!!
Amazon Verified review Amazon
interrupt Jan 12, 2015
Full star icon Full star icon Full star icon Full star icon Full star icon 5
There is so much value in this book, I will try to highlight a lot of what I felt shined through for me. This review is more about the audio and synthesis side of this book.The book seems to be aimed at readers with a level of knowledge that stretches from an advanced beginner through intermediate skill levels. Going through Max example patches and the related reference docs has always been the best thing to do as a beginner. The documentation is great and has gotten better over the years. Even so, once one has put the time in with the docs, it is very helpful to have someone who is an experienced patcher to show some of the often unfamiliar visual programming patterns. This book fills that role very well. Though there is a lot of dense technical information, the author clearly elucidates how it all works together. Each chapter brings the reader step by step into the labyrinths of knowledge that is visual programming in Max.The early chapters present an indispensable discussion of foundational information for anyone who needs to get up and running with visual patching paradigms in Max. The author's techniques are not only useful in general, but also inspire the kind of thinking that visual programming really requires. Throughout the rest of the book, the subpatches / abstractions in his examples teach a lot on their own. For a motivated learner, there is a lot of time to be spent learning and understanding these. There is so much detail presented in patcher form alone, I recommend one keeps the chapter projects' windows open in Max as you move through the author's instruction. I know I will be digging through and experimenting with these for some time.There is an in-depth debugging discussion, which rounds out the practical programming methodologies presented for the individual topics. If one comes from a non-visual software background, some software paradigms are related to the patching environment. For instance an MVC approach is covered in the section for designing and scripting interface elements.The sections that deal with audio describe all the parts of a synthesizer and sampler that one might be interested in creating. There is an overview of the essential synthesis foundational information. The author shows everything from feedback, FM, filter theory, polyphony, sample accuracy, loading audio into buffers, and creating advanced samplers.If you are into effects, you don't go home empty handed, the author also shows some mixing and effects creation like tape delays. The techniques shown in the examples for the more advanced and non-user-facing aspects of building instruments are holistic best practices that can simply be used to solve problems without having to get too down and dirty. Along with all the components themselves, the way that they feed into and mix together is shown. This all makes for a concise and refreshingly complete learning path for the budding synthesist. I will now highly recommend this book because of these sections alone.The author speaks about his topics with an emphasis on clarity, but keeps the high level perspective in view throughout. He utilizes the max environment to create a well illustrated and in depth discussion of the various synthesis and sampling techniques.There is also a totally amazing section about reverbs and impulse responses and convolution, does it get any better?! yeah because then advanced fft effects are discussed. I learned a lot here and feel like I have somewhere to go from in order to get into all kinds of audio processing. I think the later parts of the book are where it is really up to the reader to be following along and studying the project patches as they read. This is laborious work, cause the urge to get creative isThere is a high level overview of gen, jitter matrices, and Max for Live. There are some cool examples of how to do things like implement karplus-strong synthesis and creation of filters in Gen. The author moves into some advanced physical modeling and further more advanced acoustics discussions ensue. I see this as part of the great mix of topics that define different levels of challenge for intermediate-level programmers.Some of the information, like the max for live section and the initial intro to jitter, are simply more wordy overviews of what the docs cover. These simpler sections are good for the unfamiliar though fewer compared to the depth of awesome presented everywhere else. The book provides a steady, deep dive into the subject matter with the author's great experience and smooth writing as a guide.
Amazon Verified review Amazon
eyad tachwali Jan 02, 2015
Full star icon Full star icon Full star icon Full star icon Full star icon 5
It is a very good book to start learning Max/MSP and TouchDesigner, with examples that help you a lot.I strongly recommend it.
Amazon Verified review Amazon
Get free access to Packt library with over 7500+ books and video courses for 7 days!
Start Free Trial

FAQs

What is the digital copy I get with my Print order? Chevron down icon Chevron up icon

When you buy any Print edition of our Books, you can redeem (for free) the eBook edition of the Print Book you’ve purchased. This gives you instant access to your book when you make an order via PDF, EPUB or our online Reader experience.

What is the delivery time and cost of print book? Chevron down icon Chevron up icon

Shipping Details

USA:

'

Economy: Delivery to most addresses in the US within 10-15 business days

Premium: Trackable Delivery to most addresses in the US within 3-8 business days

UK:

Economy: Delivery to most addresses in the U.K. within 7-9 business days.
Shipments are not trackable

Premium: Trackable delivery to most addresses in the U.K. within 3-4 business days!
Add one extra business day for deliveries to Northern Ireland and Scottish Highlands and islands

EU:

Premium: Trackable delivery to most EU destinations within 4-9 business days.

Australia:

Economy: Can deliver to P. O. Boxes and private residences.
Trackable service with delivery to addresses in Australia only.
Delivery time ranges from 7-9 business days for VIC and 8-10 business days for Interstate metro
Delivery time is up to 15 business days for remote areas of WA, NT & QLD.

Premium: Delivery to addresses in Australia only
Trackable delivery to most P. O. Boxes and private residences in Australia within 4-5 days based on the distance to a destination following dispatch.

India:

Premium: Delivery to most Indian addresses within 5-6 business days

Rest of the World:

Premium: Countries in the American continent: Trackable delivery to most countries within 4-7 business days

Asia:

Premium: Delivery to most Asian addresses within 5-9 business days

Disclaimer:
All orders received before 5 PM U.K time would start printing from the next business day. So the estimated delivery times start from the next day as well. Orders received after 5 PM U.K time (in our internal systems) on a business day or anytime on the weekend will begin printing the second to next business day. For example, an order placed at 11 AM today will begin printing tomorrow, whereas an order placed at 9 PM tonight will begin printing the day after tomorrow.


Unfortunately, due to several restrictions, we are unable to ship to the following countries:

  1. Afghanistan
  2. American Samoa
  3. Belarus
  4. Brunei Darussalam
  5. Central African Republic
  6. The Democratic Republic of Congo
  7. Eritrea
  8. Guinea-bissau
  9. Iran
  10. Lebanon
  11. Libiya Arab Jamahriya
  12. Somalia
  13. Sudan
  14. Russian Federation
  15. Syrian Arab Republic
  16. Ukraine
  17. Venezuela
What is custom duty/charge? Chevron down icon Chevron up icon

Customs duty are charges levied on goods when they cross international borders. It is a tax that is imposed on imported goods. These duties are charged by special authorities and bodies created by local governments and are meant to protect local industries, economies, and businesses.

Do I have to pay customs charges for the print book order? Chevron down icon Chevron up icon

The orders shipped to the countries that are listed under EU27 will not bear custom charges. They are paid by Packt as part of the order.

List of EU27 countries: www.gov.uk/eu-eea:

A custom duty or localized taxes may be applicable on the shipment and would be charged by the recipient country outside of the EU27 which should be paid by the customer and these duties are not included in the shipping charges been charged on the order.

How do I know my custom duty charges? Chevron down icon Chevron up icon

The amount of duty payable varies greatly depending on the imported goods, the country of origin and several other factors like the total invoice amount or dimensions like weight, and other such criteria applicable in your country.

For example:

  • If you live in Mexico, and the declared value of your ordered items is over $ 50, for you to receive a package, you will have to pay additional import tax of 19% which will be $ 9.50 to the courier service.
  • Whereas if you live in Turkey, and the declared value of your ordered items is over € 22, for you to receive a package, you will have to pay additional import tax of 18% which will be € 3.96 to the courier service.
How can I cancel my order? Chevron down icon Chevron up icon

Cancellation Policy for Published Printed Books:

You can cancel any order within 1 hour of placing the order. Simply contact customercare@packt.com with your order details or payment transaction id. If your order has already started the shipment process, we will do our best to stop it. However, if it is already on the way to you then when you receive it, you can contact us at customercare@packt.com using the returns and refund process.

Please understand that Packt Publishing cannot provide refunds or cancel any order except for the cases described in our Return Policy (i.e. Packt Publishing agrees to replace your printed book because it arrives damaged or material defect in book), Packt Publishing will not accept returns.

What is your returns and refunds policy? Chevron down icon Chevron up icon

Return Policy:

We want you to be happy with your purchase from Packtpub.com. We will not hassle you with returning print books to us. If the print book you receive from us is incorrect, damaged, doesn't work or is unacceptably late, please contact Customer Relations Team on customercare@packt.com with the order number and issue details as explained below:

  1. If you ordered (eBook, Video or Print Book) incorrectly or accidentally, please contact Customer Relations Team on customercare@packt.com within one hour of placing the order and we will replace/refund you the item cost.
  2. Sadly, if your eBook or Video file is faulty or a fault occurs during the eBook or Video being made available to you, i.e. during download then you should contact Customer Relations Team within 14 days of purchase on customercare@packt.com who will be able to resolve this issue for you.
  3. You will have a choice of replacement or refund of the problem items.(damaged, defective or incorrect)
  4. Once Customer Care Team confirms that you will be refunded, you should receive the refund within 10 to 12 working days.
  5. If you are only requesting a refund of one book from a multiple order, then we will refund you the appropriate single item.
  6. Where the items were shipped under a free shipping offer, there will be no shipping costs to refund.

On the off chance your printed book arrives damaged, with book material defect, contact our Customer Relation Team on customercare@packt.com within 14 days of receipt of the book with appropriate evidence of damage and we will work with you to secure a replacement copy, if necessary. Please note that each printed book you order from us is individually made by Packt's professional book-printing partner which is on a print-on-demand basis.

What tax is charged? Chevron down icon Chevron up icon

Currently, no tax is charged on the purchase of any print book (subject to change based on the laws and regulations). A localized VAT fee is charged only to our European and UK customers on eBooks, Video and subscriptions that they buy. GST is charged to Indian customers for eBooks and video purchases.

What payment methods can I use? Chevron down icon Chevron up icon

You can pay with the following card types:

  1. Visa Debit
  2. Visa Credit
  3. MasterCard
  4. PayPal
What is the delivery time and cost of print books? Chevron down icon Chevron up icon

Shipping Details

USA:

'

Economy: Delivery to most addresses in the US within 10-15 business days

Premium: Trackable Delivery to most addresses in the US within 3-8 business days

UK:

Economy: Delivery to most addresses in the U.K. within 7-9 business days.
Shipments are not trackable

Premium: Trackable delivery to most addresses in the U.K. within 3-4 business days!
Add one extra business day for deliveries to Northern Ireland and Scottish Highlands and islands

EU:

Premium: Trackable delivery to most EU destinations within 4-9 business days.

Australia:

Economy: Can deliver to P. O. Boxes and private residences.
Trackable service with delivery to addresses in Australia only.
Delivery time ranges from 7-9 business days for VIC and 8-10 business days for Interstate metro
Delivery time is up to 15 business days for remote areas of WA, NT & QLD.

Premium: Delivery to addresses in Australia only
Trackable delivery to most P. O. Boxes and private residences in Australia within 4-5 days based on the distance to a destination following dispatch.

India:

Premium: Delivery to most Indian addresses within 5-6 business days

Rest of the World:

Premium: Countries in the American continent: Trackable delivery to most countries within 4-7 business days

Asia:

Premium: Delivery to most Asian addresses within 5-9 business days

Disclaimer:
All orders received before 5 PM U.K time would start printing from the next business day. So the estimated delivery times start from the next day as well. Orders received after 5 PM U.K time (in our internal systems) on a business day or anytime on the weekend will begin printing the second to next business day. For example, an order placed at 11 AM today will begin printing tomorrow, whereas an order placed at 9 PM tonight will begin printing the day after tomorrow.


Unfortunately, due to several restrictions, we are unable to ship to the following countries:

  1. Afghanistan
  2. American Samoa
  3. Belarus
  4. Brunei Darussalam
  5. Central African Republic
  6. The Democratic Republic of Congo
  7. Eritrea
  8. Guinea-bissau
  9. Iran
  10. Lebanon
  11. Libiya Arab Jamahriya
  12. Somalia
  13. Sudan
  14. Russian Federation
  15. Syrian Arab Republic
  16. Ukraine
  17. Venezuela