Darwin Grosse

Use the deviate and spread messages with wrapped MC objects

Use the plot~ object to visualize generated MC results

In the last two recipes, we targeted individual instances of MC objects to affect their actions. "Wrapped" MC object - MSP objects that are enclosed in an MC wrapper - respond to a number of messages that generate instance-specific behavior. The deviate and spread messages are two examples.

In some cases, it can be difficult to understand exactly what is happening with these objects. To provide more insight, we create a scaling system that can produce a visualization of the generated results.

mc.sig~ : An MC-wrapped static signal generator

deviate and spread messages : Messages that generate value variations

mc.snapshot~ : Creates messages from individual MC channels

mc.makelist : Assembles a list from multiple channel sources

The deviate message produces values around a centerpoint with a defined deviation. In this case, the slider produces values between 0. and 1., and are sent to a message box which will cause a deviation of that value, centered around 1.0. This will cause the mc.sig~ to generate values from 0.0 to 2.0.

An alternative generation message is the spread message, which will create an even range of values between a low and high value. In this part of the patch, we make simple calculations to create a spread evenly spaced around 1.0.

The mc.plotscaler abstraction (included in the download) sets up a plot~ object, sets the number of points to the number of channels, and creates a display list from incoming MC signal values. The arguments sent to the abstraction defines the low and high end of the display range.

You can change the number of channels that are calculated, but the actual number of channels flowing through the MC patchcords will not be altered until you turn the DSP off and on again. Use the attrui object to change the number of channels while DSP is running, then cycle the DSP switch to see the change in the patch.

Option-click (right-click on Windows) on a wrapped MC object to see the available options available for those objects. Among the details displayed in the help files, you will find a number of additional messages that can generate interesting value ranges.

Learn More: See all the articles in this series 

Recipe-0201.png

Use MC Recipe 2 to create a scaling system that can produce a visualization of the generated results.

mc-recipe-02-deviation-and-spread

MC Recipe 02: SettingPlotter

Use introspection for channel-specific processing

In the last recipe, we used MC objects to target specific instances of an mc.reson~ filter. The mc.gen~ object also creates a gen~ instance for each channel, but two new Gen operators have been added that  allow each instance to learn about its place in the MC environment. The Gen objects mc_channel and mc_channelcount allow for basic introspection - where a patch can interrogate itself. 

We use these objects to create a variation on a patch that was seen in the Max 8 promotional video: one that creates unique tones and delays for each processing channel.

mc.gen~ : an MC-capable version of the gen~ object

mc.channel : a gen object that outputs the channel number of the current instance

mc.channelcount : a gen object that outputs the total number of channels

jit.cellblock : display the contents of a multichannel signal

Pressing the space bar will produce a short 'blip'  and send it into the mc.gen~ object. The output is sent to a meter~ (which auto-adjusts to the number of channels), and to an mc.gain~/mc.dac combination.

The mc.gen~ object creates one instance of the gen~ object for each of the channels. The littleblips.gendsp patch has two additional outputs which allow us to display the calculated delay times for each of the channels

mc_channel is used inside the gendsp patch to retrieve the channel for each instance. We use this to create a channel-specific pitch (for the cycle object) and delay times for the upward moving delays. Note that we subtract one from the channel number because we want to start with no delay.

In order to get the downward moving delays, we subtract the current channel from the total number of channels.  We then add the delay time for all channels (which is when the upward delays are playing).

Change the number of channels in the mc.gen~ to see (and hear) the Gen patch adapt to its changed environment. Note, however, that when you change the number of channels, you may need to restart the DSP to implement the change. 

01.GenTargets.png

 The Gen objects mc_channel and mc_channelcount allow for basic introspection - where a patch can interrogate itself.  Follow this recipe to learn how.

mc-recipe-01-gentargets

MC Recipe 01: GenTargets

Using mc.mixdown~ to perform complex mix/routing

Implementing a secondary mc.mixdown~ to provide LFE extraction

The mc.mixdown~ object can find many uses within a single patch. In this recipe, we use this object to generate panning for incoming audio across five channels, and to create a single-channel mix that can be filtered for LFE (Low Frequency Effects) separation. We also perform a little MC manipulation to conform the output into the standard output configuration of a 5.1 surround output.

mc.mixdown~ : an object that mixes MC input to multiple output channels based on MC location signals. 

mc.resize~ : a tool for resizing and rearranging MC signals. 

mc.combine~ : an object for creating a combined-channel MC signal.

The dial UI object is set to circular mode (in the Inspector) and outputs values between 0. and 1. - the panning range that mc.mixdown~ understands when used in panning mode 0 (the default).

For this case - panning a single file in 5-channel space - we use a standard audio signal input for both audio and panning information. Once the audio is panned into position, we use mc.resize~ (and its select attribute) to move the channels into L-C-R-Ls-Rs positioning.

In order to generate an LFE (.1) signal, we mix all of the channels into a single output signal, and run that through a cascade~ object managed by a filterdesign object.

In order to create the 5.1 output, mc.combine~ is used to glue the sixth channel to the five full-frequency channels.

ClassicSurroundImage.png

This week's recipes come from Manuel Poletti. In this one, he shows how to use the mc.mixdown~ object for surround panning and control

mc-recipe-04-classicsurround

MC Recipe 04: ClassicSurround

Using the deviate message is fast becoming "the sound of MC". In this recipe, we use deviate to generate two different audio functions: deviation of the playback rate of the instances of an mc.groove~ object, and automated pan movement of each voice.

The mc.mixdown~ object offers signal-based panning location based on the pancontrolmode in use. You can learn more about mc.mixdown~ options, including this attribute, in the Mixing and Panning in MC documentation guide.

mc.groove~ : an MC-wrapped version of the groove~ object for looped playback.

mc.mixdown~ : an object that mixes MC input to multiple output channels based on MC location signals.

The deviate message can be used to generate different values for the playback rate of the each voice in an mc.groove~ object. This produces a cloud of sound from the simplest of sounds.

Each time that mc.sig~ receives the deviate message, a new set of values will be created. By banging the deviate message with a metro, we get a new set of pan values every second.

Using mc.slide~ with up- and down-values equal to the sample rate, it will take one second to move from the current values to a new set of values. This matches the one second interval of the metro object. We send the values to mc.mixdown~ using pancontrolmode 1, which places the stereo outputs at values of 0.0 and 1.0. This allows us to easily visualize the pan values using a multislider.

With MC Recipe 3, use the deviate message to generate two different audio functions: deviation of the playback rate of the instances of an mc.groove~ object, and automated pan movement of each voice.

mc-recipe-03-motion-panning

MC Recipe 03: MultiPan

Produce polyrhythmic pulses whose rates are controlled by a multichannel breakpoint function.

Use each pulse to activate a resonator, with tuning controlled by the same function as the pulse rate.

The mc.evolve~ object can be viewed as a multichannel signal generator that synchronizes activity across output channels. In this recipe, we use breakpoint functions to control the rate of a set of pulse trains and the central frequency of resonant filters by scaling the mc.evolve~ output.

Note that mc.evolve~ creates four simultaneous outputs on four channels; each controls the rate and pitch of a unique mc.train~/mc.reson~ pairing.

mc.evolve~ : A multichannel breakpoint function generator

multirange : Used for creating the function values output by mc.evolve~

mc.scale~ : An MC-wrapped version of the scale~ object, used to properly format the mc.evolve~ output into useful values for the rate of mc.train~ and frequency of mc.reson~

The Scroll~ subpatcher contains a phasor~ object whose output is used as a sync signal for mc.evolve~. This signal tells mc.evolve~ to output the function values for a given index position within the range of 0.0 - 1.0. By adding a few controls (duration, scrolling on/off and manual positioning), you can easily create your own playback transport.

The multirange object was designed to provide a UI for multichannel objects like mc.evolve~. Each time the object is edited, a dump message tells the object to output a multichannel breakpoint function (in a list) to be used by mc.evolve~. You can edit the multirange content by click-dragging points, click to add breakpoints, and shift-clicking to delete ranges. (Note: in this patch, a mostly-transparent slider, with click disabled, is placed over the multirange to mimic a transport cursor.)

When mc.evolve~ receives a list message, it calculates a set of functions for the number of channels it must output. When it receives a signal, it uses that as the X index (horizontal location), and outputs the Y values (vertical location) for each of the channels. Notice the four values displayed in the scope~, which shows the spread of values across the space displayed in the multirange UI object.

The four values generated by mc.evolve~ are used to generate four pulse trains using the mc.train~ object. The output values (from 0.0 to 1.0) are scaled to the rate values for each channel, and the pulse trains are displayed on the small individual scope~ objects.

Each of the four resonators contained in the mc.reson~ object receives one channel of the pulsed trains. In order to set a separate pitch for each train/resonator, we've reused the function output of mc.evolve~, but scaled it to the frequency range we want to use. In this way, the pitch is mapped to the rate of the pulse, with faster pulses featuring higher pitches.

EvlovingTrain.png

Another patch by Manuel Poletti, this recipe digs into the time-saving mc.evolve~ object to create a team of pinging filters.

mc-recipe-05-evolvingtrain

MC Recipe 05: EvolvingTrain

In the spirit of the Jitter Recipes, we have produced a series of MC Recipes. They include brief commentaries on a single patch that is meant to illuminate some part of the MC system. (Requires Max 8 or later.)

Targeting individual instances of an MC-wrapped filter.

One of the hallmarks of the MC system is the ability to have many instances of an object that are accessed as a single object. However, for interesting sonic manipulation, you may choose to make specific adjustments to each of the individual instances - and to do it with a ‘playable’ interface. In this recipe, we use a virtual keyboard to control six channels of filtering to create a vocoder-like effect from ringing filters.

mc.dup~ : duplicate a signal across many channels

mc.reson~ : an MC-wrapped lowpass resonant filter

mc.targetlist~ : format messages based on the inlet number

cycle : rotate the outlet of incoming messages

The key sonic element of the patch is the six-channel resonant filter (mc.reson~). We use a standard playlist~ object as an audio player, but create a six-channel audio stream using mc.dup~. The audio playback stream runs through the filter, an mc.mixdown~ object and the output mc.dac~ object.

The mc.reson~ object is preloaded with a high gain (50) and very high resonance (333.) setting, which will create a ringing filter sound. But no cutoff frequency is given, effectively shutting off the throughput of the sound. 

The keyboard is used to set cutoff frequencies of the filter. The output is changed to a frequency, then put through a cycle object, which takes received messages and rotates them through the available outlets. mc.targetlist~ transforms the incoming message into a message of the form setvalue n v, where n is the inlet number and v is the received value. This will set cutoff frequencies for the individual instances of the filter and allow us to set the generated ringing tone of each of the six filters. As a result, you can create an interesting rhythmic chordal tone from the noise-like output of the brushes.

00.FilterTargets.png

In the spirit of the Jitter Recipes, we have produced a series of MC Recipes. They include brief commentaries on a single patch that is meant to illuminate some part of the MC system.

Search Results