NANOSCOPICS IN DIGITAL AUDIO - Part 3: Resonant_Rain.amxd with sv1

NANOSCOPICS IN DIGITAL AUDIO

Part 3: Resonant_Rain.amxd with sv1

In this Lux Cache tutorial series, our residential sound design master sv1 dives into the tinkering of microscopic textures to create his rich, nuanced and infinitely detailed compositions. In this part of Nanoscopics in Digital Audio, we unpack the design and development of sv1’s new device ‘Resonant_Rain.amxd’, a one-of-a-kind hybrid of his resonator, chorus and lossy audio sim modules - releasing the early-access of the device exclusively tof Lux Cache Premium Subscribers.

This tutorial is available as both a Patreon text post and a preferred .pdf document format. We ask you kindly to not share Lux Cache content outside of the Patreon, our contributors rely on your donations. All audio examples can be previewed/downloaded in this Google Drive folder or this SoundCloud playlist.

• An exclusive early access release for ‘sv1.Resonant_Raind.amxd’, a new M4L device built by sv1, is available for Premium Subscribers on the Lux Cache Patreon Page.

~

CONTENTS

1. INTRODUCTION

2. EFFECT OVERVIEW

1. RESONATOR
2. LOSSY
3. CHORUS

3. THE FINAL HYBRID

4. CONCLUSION

INTRODUCTION

Last summer, I built several devices using various arrangements of filters and delay lines. This summer, I had planned on revisiting and cleaning up those devices, but I ended up taking a bit of a detour on this tool here. Part of me wanted to combine a lot of devices I’m often combining and another part of me was trying to recreate Absynth’s Cloud Filter, albeit I’m certain I totally missed it. The result sure is cool though. That is the fun part about guessing and experimentation isn’t it? What we’ll go over below is a result of a lot of tinkering and guesswork, from low-level filter design to top-level submodule configurations.

EFFECT OVERVIEW

(Top Level of the Resonant Rain Effect)

RESONATOR

The first module we’ll construct is the resonator. This effect is used to add a metallic quality to our sound, and other delay-line-associated textures.  This module is where I started first with this whole project. My original goal was to reconstruct a device I had made around July 2021 that’s included with one of my sample packs called ‘resonance sculptor’. I built it very haphazardly and without knowing a lot about what I was doing, and I was hoping to clean it up. However, I got a bit carried away and took this detour we’re on now. The resonator we’ll be making includes the same layout as the resonance sculptor, but with a few more fixed parameters. Below is a block diagram describing what we’ll need to create to build the resonator.

You’ll notice that we’ll be needing a few biquad filters. I selected these because they allow for easy swapping between filter types. This is handy because it allows us to tinker with the chain instead of having to move around objects. Very convenient for experimentation. This is where the hard part comes in, or what would’ve been the hard part. Filter design is tough, or at least has been for me. Thankfully there is a handy tutorial by Gregory Taylor on how to build these in gen. Once we’ve built one of these, we can simply copy and paste it over twice more. We will need to calculate their respective parameters, but I’ll get into that later. If we’re also interested in experimenting more, having an abstraction for one gen biquad filter will allow us to add as many as we want and go further than the prescribed diagram above. We’ll also need a delay line with feedback enabled. We need to set up the parameters for our gen patch now too.

Allpass Parameters a1, a2, b0, b1, & b2 - These are the coefficients required to tell our biquad instance that it is an Allpass filter, as well as its cutoff, gain, and resonance.

Lowpass Parameters a1, a2, b0, b1, & b2 - The same as above, but for our Lowpass Biquad instance.

Delay Length (ms) - I’ve set this to a min of 1ms and a max of 1000ms, however, these values are arbitrary and should be experimented with.

Feedback (%) - This is just the amount of feedback we will be introducing to our loop.

Below is what our gen patcher should look like once it’s done. You’ll notice that there are a few objects not mentioned previously. Slide allows us to smooth transitions of incoming parameters. DC block will block out any output DC signal. There is a subpatcher titled ‘biquad_coeff_smooth’. Within this is just a set of slide objects intended to smooth incoming filter parameters.

(Resonator Gen Patcher)

Outside of our gen patcher, we will need to calculate our biquad coefficients. We can do this using the filtercoeff~ object with the argument of the filter type we would like to calculate. This can be done in gen, however, at the time of writing this I have not set aside the time to learn and implement this. I’ve defaulted our gain to 0.98 and resonance to 0.7, however, these values can be experimented with. Below is what our resonator should look like in the context of our main patch. I’ve added a simple one-pole highpass filter on the end of this chain to filter out low frequencies as they tend to get pretty unruly when working with feedback, and I am often cutting them anyway. I’ve also included an abstraction of this module as a standalone max device.

(Resonator in Context)

(Resonator Standalone Module)

Here is the dry loop we’ll be using as an example to test all of these effects.

🔊 NIDA3_loop_dry_126.54.wav

These short delay lengths with high feedback create a tube-like metallic effect. At these settings we can hear the effect of tuning the allpass cutoff.

🔊 NIDA3_loop_resonator_short_126.54.wav

This next example features high feedback, and medium length delay, however, what it’s demonstrating is the damping effect from turning down the lowpass cutoff.

🔊 NIDA3_loop_resonator_damped_126.54.wav

LOSSY

Next, we’ll be creating a lossy effect. This will be used to give the main effect a digital and water-like quality. Admittedly I had made this module while watching a tutorial on how to use ~pfft when I first started learning max, so instead of transcribing this tutorial, I will just link you to it. I strongly encourage you to check out more of Sam Tarakajian / Dude837’s tutorials because they are super informative and digestible. They really helped me get my foot in the door of learning max.

Delicious Max/MSP Tutorial 12: Pfft~ is your friend

With this one, I’ve essentially just added a m4l UI to the patch made here, with the addition of a gain parameter. I noticed that when you crank up the lossy and smooth values, the output gets quieter, so I added the gain knob in to compensate for that. I have also included a standalone version of this effect too.

(Lossy Patch in Context)

(Lossy Standalone Module)

If we set the smooth parameter to a lower value we’ll observe a more digital and gritty type effect best known from the lossy effect.

🔊 NIDA3_loop_lossy_lowsmooth_126.54.wav

🔊 NIDA3_loop_lossy_lowlosssmooth_126.54.wav

At high lossy and high smooth values, we’ll encounter a water-like effect.

🔊 NIDA3_loop_lossy_highlosssmooth_126.54.wav

CHORUS

Finally, we’ll construct a chorus effect. I had never made a chorus effect before this, so I had to do a lot of guesswork. I had made a Haas effect style stereoizer a while back, but lately, I’ve been really enjoying the sound of the deprecated Ableton Live 10 chorus, especially with its init preset (see above image). I’ve always thought it gave a really pretty stereo effect that adds just enough detail. All of the legacy Ableton devices are pretty simple, and I knew this chorus had been around since at least Live 4, so I figured it wouldn’t be too much hassle to recreate. Ableton does have information listed both on their website and in the device info text, but whenever I was working on this, I was just trying my best to eyeball it, so I’ll go through my thought process behind it. A big point that I want to make is that what ended up being made is not a carbon copy of the above chorus effect, but it’s just close enough that it works for what I needed it to do.

(Live 10 Chorus)

Right off the bat, we can see that there are two delay lines, a highpass filter, two numboxes that control a modulation source, a polarity parameter, and a feedback knob. Also before we start construction, we should gather a bit more information by just listening to the effect, especially by cranking up the parameter values, and seeing how it behaves at the extremes. Once that’s done we can draft up some pseudo code for this in the form of a block diagram. This is not necessary, but for the sake of visualization, I’ve included it.

Since we’ll be doing this in gen, we’ll need to set up our inputs and outputs, as well as the parameters that we’ll be sending it.

3X INPUTS - Left in, Right in, Modulation

2X OUTPUTS - Left out, Right out

PARAMETERS - Left Delay, Right Delay, Feedback, Polarity, Modulation Amount, & Delay Smoothing

For each of these parameters, I’ll be taking the min and maxes from the live 10 chorus, but I would encourage you to adjust them and experiment.

Smoothing (float) will be a static parameter. This is used to implement a single sample smoothing filter that is added to our feedback path. For the sake of brevity, check out the built-in tutorial titled ‘gen~.karplus_strong.

Left Delay (ms) and Right Delay (ms) are straightforward, however, we will be modulating the right delay. These will feed into a ‘slide’ object to smooth delay length transitions, and then into ‘mstosamps’ to convert delay length

Modulation Amount (ms) controls how much we will be modulating the right delay. We can modulate this delay time by multiplying the incoming modulation source by the modulation amount, and then adding it to the right delay length. For instance, we could set the right delay to a length of 7ms, but if we modulate by 6ms, the right delay will modulate between 1ms and 13ms.

Feedback (%) and Polarity (+/-)  - Feedback is straightforward; it just controls the % of feedback we introduce to our loop. Polarity is a parameter we multiply our feedback percentage by that subtly changes the sound of the chorus.

Finally, at the end of the chorus, we’ll add a mixing matrix to even out the perceptual weighting. When parallel delay lines are different lengths, we may perceive the resultant signal as heavy in a certain ear depending on how short or how long a delay line is. There are probably more sophisticated methods to do this, but for our purposes what I’ve implemented below will do the trick.

(Mixing Matrix)

Here is what our final chorus gen module will look like:

(Chorus Gen Module)

Below I’ve included a screenshot of how this gen module fits within the context of our main effect. You may notice that I’ve not included the parameters in the UI of the effect, but instead just an on/off switch. The decision for this was to limit the number of options the user had, however, I’ve included a standalone version of this effect that includes all of the parameters. As I mentioned before I like how the live 10 chorus init preset sounds, so I just wanted a toggle for this since I’m not usually tinkering with the effect once I’ve called for it. This was also just a quick way to add stereo information in the event of a mono input.

(Chorus Module in Context)

(Chorus Module Standalone)

Here is an example of what our effect sounds like with the live 10 chorus init settings:

🔊 NIDA3_loop_chorus_init_126.54.wav

Below is an example featuring high feedback with the polarity set to negative. This provides a wider sound, but with a more metallic quality instead of something more transparent like the above example.

🔊NIDA3_loop_chorus_negative_126.54.wav

Now that all of our sub-modules are done, we can string them together and complete the main device. Below is what our top-level view should look like. I’ve added in enables for each of the submodules as well as highpass filters between each of them just to help tame the signal as it passes through.

(Resonant Rain Top Level)

(Resonant Rain M4L Final)

Here are some examples of the device in action:

🔊 NIDA3_loop_resonantrain_126.54.wav

This next example is using the individual modules we created but now in a different arrangement. With the original arrangement of the signal path, the goal was to create a water-like effect with digital/metallic textures below the surface. However, rearranging our configuration is where this set of effects really shines because the effect starts sounding less obvious, and provides the most unique sounds.

🔊 NIDA3_loop_rearranged_126.54.wav

CONCLUSION

Surely there is a lot more we can do with this now that the groundwork has been laid out. I would strongly encourage you to tinker with this device on your own and/or take parts of this to your other patches. That is the cool part about max and these types of environments; it’s very easy and effective to copy and paste things into preexisting patches or duplicate them in the current patch for added experimentation. Thanks for taking the time to read this, I hope it was a worthwhile one!

• An exclusive early access release for ‘sv1_Resonant_Raind.amxd’, a new M4L device built by sv1, is available for Premium Subscribers on the Lux Cache Patreon Page.
• 
  

~

sv1 is a Texas-based musician and sound artist, his recent album with DJH, 'voids', is available to purchase on Bandcamp

You can follow him on Twitter @sv1___ and Instagram @sv1.earth

2022 © Whiston Digital / Lux Media  |  luxcache.com