Re-org and commit new stuff.

New stuff:

- {Software} Structure.
- Various examples from 3rd-party libraries.
- kazimuth's examples, 'cause I haven't anywhere else to keep them.
- A few example from the Processing Handbook.

Author: tildebyte

MSAFluid/MSAFluid.pyde renamed to Contributed Libraries in Python/MSAFluid/MSAFluid.pyde

@@ -0,0 +1,65 @@
+from ddf.minim.ugens import Frequency, Line, Oscil
+from ddf.minim.ugens import Instrument, Waves, Pan
+
+
+class FlutterSaw(Instrument):
+    def __init__(self, freq, panning, patchTo):
+        self.saw = Oscil(freq, 1.0, Waves.SAW)
+        self.ampMod = Oscil(2.0, 0.5, Waves.SINE)
+        self.pan = Pan(panning)
+        self.out = patchTo
+
+    def noteOn(self, dur):
+        ampModFreqLine = Line(dur * 0.9, 0.5, Frequency.ofPitch("C3").asHz())
+        ampModFreqLine.patch(self.ampMod.frequency).patch(self.saw.amplitude)
+        ampModFreqLine.activate()
+        self.saw.patch(self.pan).patch(self.out)
+
+    def noteOff(self):
+        self.pan.unpatch(self.out)
+
+
+class FilterFrequency(Instrument):
+    def __init__(self, begin, end, moog):
+        self.filterFreqLine = Line()
+        self.begin = begin
+        self.end = end
+        self.moog = moog
+
+    def noteOn(self, dur):
+        self.filterFreqLine = Line(dur, self.begin, self.end)
+        self.filterFreqLine.activate()
+        self.filterFreqLine.patch(self.moog.frequency)
+
+    def noteOff(self):
+        self.filterFreqLine.unpatch(self.moog)
+
+
+class FilterResonance(Instrument):
+    def __init__(self, begin, end, moog):
+        self.filterRezLine = Line()
+        self.begin = begin
+        self.end = end
+        self.moog = moog
+
+    def noteOn(self, dur):
+        self.filterRezLine = Line(dur, self.begin, self.end)
+        self.filterRezLine.activate()
+        self.filterRezLine.patch(self.moog.resonance)
+
+    def noteOff(self):
+        self.filterRezLine.unpatch(self.moog)
+
+
+def PlayFlutterSaw(audiooutput, time, dur, pitch, pan, patchTo):
+    audiooutput.playNote(time, dur,
+                         FlutterSaw(Frequency.ofPitch(pitch).asHz(),
+                                    pan, patchTo))
+
+
+def PlayFrequencySweep(audiooutput, time, dur, begin, end, moog):
+    audiooutput.playNote(time, dur, FilterFrequency(begin, end, moog))
+
+
+def PlayResonanceSweep(audiooutput, time, dur, begin, end, moog):
+    audiooutput.playNote(time, dur, FilterResonance(begin, end, moog))

MSAFluid/particle.py renamed to Contributed Libraries in Python/MSAFluid/particle.py

@@ -0,0 +1,96 @@
+from ddf.minim import Minim
+from ddf.minim.ugens import Summer, MoogFilter, Frequency
+from Instruments import PlayFlutterSaw, PlayFrequencySweep, PlayResonanceSweep
+
+minim = Minim(this)
+mainOut = minim.getLineOut(Minim.STEREO, 256)
+sawSummer = Summer()
+moog = MoogFilter(3000.0, 0.2)
+waveSize = 100.0
+notes = ['C2', 'G3', 'E5', 'D6', 'D6', 'C8']
+tempo = 130.0
+PAN_CENTER = 0.0
+PAN_LEFT = -1.0
+PAN_RIGHT = 1.0
+PAN_L_HALF = -0.5
+PAN_R_HALF = 0.5
+
+# Gain in (presumably) dBFS
+mainOut.setGain(0)
+
+
+def setup():
+    size(800, 400)
+    colorMode(HSB, 360, 1, 1)
+
+    sawSummer.patch(moog).patch(mainOut)
+    mainOut.pauseNotes()
+    mainOut.setTempo(tempo)
+
+    # PlayFlutterSaw(audiooutput, time, dur, pitch, pan, patchTo)
+    PlayFlutterSaw(mainOut, 0.0, 200.0, notes[0], PAN_CENTER, sawSummer)
+    PlayFlutterSaw(mainOut, 8.0, 192.0, notes[1], PAN_LEFT, sawSummer)
+    PlayFlutterSaw(mainOut, 16.0, 184.0, notes[2], PAN_RIGHT, sawSummer)
+    PlayFlutterSaw(mainOut, 32.0, 168.0, notes[3], PAN_R_HALF, sawSummer)
+    PlayFlutterSaw(mainOut, 32.01, 167.99, notes[3], PAN_L_HALF, sawSummer)
+
+    # PlayFrequencySweep(audiooutput, time, dur, begin, end, moog)
+    PlayFrequencySweep(mainOut, 32.0, 8.0, 3000.0, 10000.0, moog)
+    PlayFrequencySweep(mainOut, 44.0, 4.0, 10000.0, 8000.0, moog)
+    PlayFrequencySweep(mainOut, 48.0, 8.0, 8000.0, 200.0, moog)
+    PlayFrequencySweep(mainOut, 62.0, 4.0, 200.0, 2000.0, moog)
+    PlayFrequencySweep(mainOut, 74.0, 12.0, 2000.0, 400.0, moog)
+
+    # PlayResonanceSweep(audiooutput, time, dur, begin, end, moog)
+    PlayResonanceSweep(mainOut, 66.0, 4.0, 0.2, 0.8, moog)
+    PlayResonanceSweep(mainOut, 74.0, 12.0, 0.8, 0.0, moog)
+    PlayResonanceSweep(mainOut, 86.0, 2.0, 0.0, 0.2, moog)
+    PlayResonanceSweep(mainOut, 88.0, 2.0, 0.2, 0.0, moog)
+    PlayResonanceSweep(mainOut, 90.0, 2.0, 0.0, 0.3, moog)
+    PlayResonanceSweep(mainOut, 92.0, 2.0, 0.3, 0.01, moog)
+    PlayResonanceSweep(mainOut, 94.0, 3.0, 0.01, 0.9, moog)
+    PlayResonanceSweep(mainOut, 122.0, 24.0, 0.9, 0.05, moog)
+
+    PlayFrequencySweep(mainOut, 98.0, 24.0, 400.0, 1000.0, moog)
+    PlayFrequencySweep(mainOut, 122.0, 12.0, 1000.0,
+                       Frequency.ofPitch(notes[4]).asHz(), moog)
+
+    mainOut.resumeNotes()
+#
+#
+# DRAWING DOWN HERE
+#
+
+
+def hueForSample(sample):
+    return map(abs(sample), 0, 1, 120, 450)
+
+
+def draw():
+    # erase the window to black
+    lastRez = moog.resonance.getLastValue()
+    lastFreq = moog.frequency.getLastValue() / 22100.0
+    background(lastFreq * 360.0, 0.5, lastRez)
+    # draw using a white stroke
+    stroke(255)
+    # draw the waveforms
+    left = mainOut.left.toArray()
+    right = mainOut.right.toArray()
+    for i in range(mainOut.bufferSize() - 1):
+        # find the x position of each buffer value
+        x1 = map(i, 0, mainOut.bufferSize(), 0, width)
+        x2 = map(i + 1, 0, mainOut.bufferSize(), 0, width)
+        # draw a line from one buffer position to the next for both channels
+        stroke(hueForSample(left[i]), 1, 1)
+        line(x1, height / 2 - waveSize + left[i] * waveSize,
+             x2, height / 2 - waveSize + left[i + 1] * waveSize)
+        stroke(hueForSample(right[i]), 1, 1)
+        line(x1, height / 2 + waveSize + right[i] * waveSize,
+             x2, height / 2 + waveSize + right[i + 1] * waveSize)
+
+
+def keyPressed():
+    # close the AudioOutput
+    mainOut.close()
+    # stop the minim object
+    minim.stop()

MSAFluid/particle_system.py renamed to Contributed Libraries in Python/MSAFluid/particle_system.py

@@ -0,0 +1,58 @@
+add_library('minim')
+
+from ddf.minim import Minim
+from ddf.minim.ugens import Waves, Oscil
+
+minim = Minim(this)
+out = minim.getLineOut()
+wave = Oscil(440, 0.5, Waves.SINE)
+wave.patch(out)
+waveDrawMult = None
+
+
+def setup():
+    size(512, 200, P3D)
+    waveDrawMult = height / 2 - height * 0.49
+
+
+def draw():
+    background(0)
+    stroke(255)
+    strokeWeight(1)
+
+    # draw the waveform of the output
+    for i in range(out.bufferSize() - 1):
+        line(i, 50 - out.left.get(i) * 50,
+            i + 1, 50 - out.left.get(i + 1) * 50)
+        line(
+            i, 150 - out.right.get(i) * 50,
+            i + 1, 150 - out.right.get(i + 1) * 50)
+
+    # draw the waveform we are using in the oscillator
+    stroke(128, 0, 0)
+    strokeWeight(4)
+    for i in range(width - 1):
+        point(i, waveDrawMult * wave.getWaveform().value(float(i) / width))
+
+
+def mouseMoved():
+    amp = map(mouseY, 0, height, 1, 0)
+    wave.setAmplitude(amp)
+
+    freq = map(mouseX, 0, width, 110, 880)
+    wave.setFrequency(freq)
+
+
+def keyPressed():
+    if key == '1':
+        wave.setWaveform(Waves.SINE)
+    elif key == '2':
+        wave.setWaveform(Waves.TRIANGLE)
+    elif key == '3':
+        wave.setWaveform(Waves.SAW)
+    elif key == '4':
+        wave.setWaveform(Waves.SQUARE)
+    elif key == '5':
+        wave.setWaveform(Waves.QUARTERPULSE)
+    else:
+        pass

Contributed Libraries in Python/Minim/Advanced/filtered Tuning/Instruments.pyde

@@ -0,0 +1,65 @@
+# The BrapInstrument is intended to give a chopped up mixture of tone and noise.
+
+# Every instrument must implement the Instrument interface so
+# playNote() can call the instrument's methods.
+class BrapInstrument implements Instrument
+
+    # create all variables that must be used throughout the class
+    Oscil toneOsc, fmOsc
+    ADSR    adsr
+    Noise pinkNoise
+    Constant fmConstant
+    Summer sum, fmSummer
+    GranulateSteady chopper
+    AudioOutput out
+
+    # the constructor for this instrument specifies the amplitude of the output,
+    # the frequency of the tone, and the on and off time of the granulating gate
+    BrapInstrument(amp, toneFreq, onTime, offTime, AudioOutput output)
+    
+        # equate class variables to constructor variables as necessary
+        out = output
+
+        # create instances of any UGen objects as necessary
+        toneOsc = Oscil(toneFreq, amp, Waves.TRIANGLE)
+        # a little frequency modulation for added harmonics never hurt anyone, right?
+        fmOsc = Oscil(toneFreq / 2.0, toneFreq / 2.0, Waves.SAW)
+        fmConstant = Constant(toneFreq)
+        fmSummer = Summer()
+
+        pinkNoise = Noise(amp / 3.0, Noise.Tint.PINK)
+        adsr = ADSR(1.0, 0.003, 0.003, 1.0, 0.003)
+        chopper = GranulateSteady(onTime, offTime, 0.0025)
+        sum = Summer()
+
+        # patch everything together up to the output
+        # put some freq modulation on the tone
+        fmOsc.patch(fmSummer)
+        fmConstant.patch(fmSummer)
+        fmSummer.patch(toneOsc.frequency)
+
+        # put both the tone and the noise into the summer
+        toneOsc.patch(sum)
+        pinkNoise.patch(sum)
+        # pass the summer through a granulating gate to the adsr
+        sum.patch(chopper).patch(adsr)
+
+
+    # every instrument must have a noteOn() method
+    def noteOn(dur):
+    
+        # patch the adsr all the way to the output
+        adsr.patch(out)
+        # and turn it on
+        adsr.noteOn()
+
+
+    # every instrument must have a noteOff() method
+    def noteOff():
+    
+        # turn off adsr, which cause the release to begin
+        adsr.noteOff()
+        # after the release is over, unpatch from the ou
+        adsr.unpatchAfterRelease(out)
+
+