DMU/SYCoM
3+2&2+2 Program

* Schedule:

10:00 - 12:00 Morning Session
12:00 - 13:00 Lunch
13:00 - 16:00 Afternoon Session (with 15 minute break)
16:30 - 18:00 Private Lesson

Day 1 - Foundations of Max

AIM: developing confidence in using Max/MSP

- opening presentation
- inspirational projects: commercial and non-commercial
- course introduction: day by day
- DEMO: introduction to the Max environment
- TASK: reverse engineer a patch
- DEMO: introduction to core Max objects
- TASK: the 'three object challenge': build sound-making patches with a small number of objects

FOUNDATIONS:
- message order
- messages types (integer, float, symbol, list)
- Max and MSP: key differences
- combining signals in MSP

* Schedule

AM:
- The Big Picture

- Recap of Techniques from Yesterday
- objects and messages
- message order
- Max vs MSP~
- scaling dial
- hot and cold inlets
- working with math objects
- basic sequencing with 'counter' and 'sel'

- BEGINNER GROUP:
- three object challenge
- combining patches
- drum synthesis techniques

- ADVANCED GROUP: design a collaborative sequencer

PM:
- BEGINNER GROUP:
- working with sound files
- live sampling
- introduction to graphical objects
- controlling Max from a smart phone

- ADVANCED GROUP: sequencer testing

- recap of techniques, goals for tomorrow

* The Big Picture

1. BEGINNERS: Build a Trigger-able Performance Instrument

a. basic requirements

- INPUT: a trigger input, and three 'continuous control' inputs
- OUTPUT: stereo audio
- GUI: graphical user interface

b. advanced possibilities

- live microphone input
- effects
- make the patch controllable from smart phone

c. individuality

- each instrument should sound different
- you can use synthesis or sampling

STAGES:

- no GUI, no graphical objects
- add graphical objects, create presentation mode GUI
- add external control (keyboard and mouse)
- add external control (smart phone)

2. ADVANCED USERS: Design and Build a Collaborative Sequencer

a. DESIGN STAGE:

Discuss and produce a specification for the design:

- What will the basic form of the sequencer be? What features do we want to have?
- Who will be able to control it? One person at a time? Or all at once?
- What will each player see on screen? Everyone's actions, or just their own actions?
- How can we store and recall patterns across the whole group?
- API: How will communicate over the network?

b. BUILD STAGE:

- build a prototype on a single machine, reflect on the basic design
- test with two machines using mxj net.maxhole

* Three Object Challenge

1. Build a sound-making patch using three main objects and ~ezdac

Examples:
Amplitude Envelope message line~ noise~
Pitch Modulator (Vibrato) flonum cycle~ cycle~

Real world:
Amplitude Modulator (Tremelo) flonum rect~ saw~
Repeating Trigger toggle metro click~
Simple Sequencer count sel click~
Simple Filter flonum noise~ onepole~
Simple Delay bang click~ delay~
Pitch Envelope message curve~ cycle~

2. Share and extend

- share each of your patches and try to combine them
- FOUNDATIONS: combining signals
- FOUNDATIONS: working with sub patchers and abstractions

* Schedule

AM:

BEGINNER GROUP:

- complete your instruments!

INSTRUMENTS to do:
- patch initialisation
- four parameters - trigger, ?, ?, volume
- must be scaled from zero to 1
- add volume

- graphical objects and presentation mode
- encapsulation

ADVANCED GROUP:

-
- make it phasor driven?
- higher level organisation of pattern?
- color-coded players

PM:

- samples

* simple MASTER/SLAVE sequencer test

- give each player a number

Networked Sequencer

Student's Patcher (Player)

SmartPhone-Control

Plug-in for Max (OSC Objects)

Extensions and Viewpoints

- developing individual projects
- working with larger projects: modularity and reusability in Max
- extending Max: Gen / Max For Live / Jitter
- an alternative view: networked musical systems in SuperCollider

Max Basics Quiz

01. Message Order (click for download patch)
Part 1:Using a button and three separate message objects, print the messages '1', then '2', then '3' to the Max window

Part 2:Copy and repeat the above, but this time use the trigger object to ensure the message order will stay the same, no matter how the objects appear on screen.

02. Hot and Cold Inlets (click for download patch)
By default, only the left inlet of the + object triggers output (it is 'hot'). The right inlet does not trigger output (it is 'cold').

Task: Make a patch which allows both inlets of the + object to trigger output. Provide two different solutions

03. Combining Signals (click for download patch)
Part 1: Mix a saw~ and ~cycle oscillator together, providing independent volume controls for each

Part 2:Using the slider object, make a crossfader which smoothly fades between the saw~ and the cycle~ oscillator

04. Envelopes (click for download patch)

Create a simple decay envelope using line~ and use it to control a cycle~ object

Show the result of the envelope in the scope

Smooth the envelope to avoid clicks
EXTRA: replace line~ with adsr~ to create a more complex envelope

05. Setting Controls (click for download patch)
Connect a dial and an number box, such that each one can set the other (without producing an infinite loop)

06. Mapping and Scaling (click for download patch)
Create a standard dial object, then try to achieve the following:

a. Scale the output of the dial so that it can adjust the amplitude of a noise~ object (using *~)

b. Convert the output of the dial to produce a tone in Hz that can cover the full frequency spectrum

07. Routing (click for download patch)
In the patch provided, create a routing structure for the following messages that will create a chord by generating a single note on each player's instrument...

08. Controlling Message Flow (click for download patch)
In the patch provided, add a gate object to allow the random input to the dial to be switched off, so that it can be controlled by hand.

--In order to be successful in the final assignment, you will need to be able to:
build self-contained modules
test them individually
understand how they might work as part of a larger whole

--To do this we will use subpatches, abstractions and bpatchers.
subpatch: an encapsulated part of a larger patch (not saved separately)
abstraction: a saved patch which can be used as an object in another patch by typing its filename
bpatcher: a saved patch which appears as a window in other patchers, displaying only those visual elements which are desired

--In addition, flexible signal routing is possible using matrix~ and matrixctrl

We will look at all these elements in the following task...