Channel for all things SoundProcesses/Wolkenpumpe/Mellite. A comprehensive computer music framework. Noobies welcome. You need to create an account with GitLab, GitHub or Twitter to join the conversation.
I'm currently working on full timeline integration of Wolkenpumpe into Mellite. The work is all happening in the branch no-scans, as it corresponds to a rethinking of the former proc.Scan structure. There is some consolidation happening in SoundProcesses now, with v3.4.1 being pretty stable. For Proc we do not have dedicated inputs any longer, instead we solely rely on the obj.attr map. To connect two Proc instances, one would put an Output of the source to the attribute map of the sink. Timeline support is given through Timeline and Grapheme instances that can also be used as attribute inputs. Grapheme now is a simple wrapper around BiPin assuming that elements are as generic as Obj (and thus similar to timeline).
Wolkenpumpe now supports 'performance-time-ephemeral' mode (as before) plus newly timeline based mode. The new abstraction is Nuages.Surface which is a sum type of these two modes. Switching forward and backward between the two is currently not yet implemented. In Mellite test-sources we have a simple class that converts a pure Nuages database to a full Mellite workspace, which is useful for testing if you don't want to go all the way to creating a Nuages object inside Mellite.
Mellite support is currently half-complete, mainly with the former proc-linking GUI not yet migrated (and thus disabled) and with grapheme views still being empty. But you can already replay a Nuages session from its timeline with random access.
[ and ] and toggle loop with /, more to come), and then I included a cleaned-up version of Wolkenpumpe along with an improved editor; the object is Composition > Wolkenpumpe. Several settings are still hidden behind attribute key conventions (e.g. specifying microphone and line inputs), but they are already functional, and one of the next versions will see them better exposed in the GUI. Otherwise, it should be possible now to completely build up one's repertoire of processes from within Mellite; for example, there is a ParamSpec editor now, and a corresponding Param UGen. I have created a new tutorial for this which is currently being uploaded.
Expr but you write an immutable graph like you do for patterns or procs. On top, a new abstraction Widget which allows you to build tiny user interfaces within a workspace. This will become especially useful in relation to FScape. A tutorial to be added soon—in the meantime, download and try the ImageSynth workspace.
ctrl-alt-D. A tutorial on this is to follow.
If Then Else; this caused a lot of changes to the Akka Stream layer, so expect this to have some bugs not found yet), as well as some improvements to building GUIs using the Widget object. This is an "intermediate" release, because I'm going to work more on FScape and Widget in the next two weeks, and another release is likely. We want to be able to transport many of FScape v1's modules to the new system now, so that's where the API additions and changes come in.
Widget type: https://peertube.social/videos/watch/e10b8a0c-7d26-4bcc-a611-1175faa6287c
val freq0 = Seq(1.0, 1.01).map(_ * 0.0054205526)
val freq1 = Seq(1.0, 1.01).map(_ * 0.44575435)
val freq2 = Seq(1.0, 1.01).map(_ * 15.73315)
val freq3 = Seq(1.0, 1.01).map(_ * 0.44575435 * 1.0) // fundamental
RandSeed.ir
val linCongC = LinCongC.ar(freq = Nyquist(), a = freq0,
c = 1.0951394, m = 0.0054205526, xi = 1.0951394)
val in_0 = Clip.ar(linCongC, lo = 0.0, hi = 30.0)
val freq_0 = 1.0951394 min linCongC
val henonL = HenonL.ar(freq = freq_0, a = freq3, b = 1.0951394, x0 = linCongC,
x1 = 0.0054205526)
val in_1 = LeakDC.ar(henonL, coeff = 0.995)
val time = Clip.ar(in_0, lo = 0.0, hi = 30.0)
val lag = Lag.ar(in_1, time = time)
val min_0 = linCongC min lag
val in_2 = StandardN.ar(freq = Nyquist(), k = freq1,
xi = henonL, yi = 0.0)
val in_3 = 0.0054205526 ring4 in_2
val in_4 = LeakDC.ar(in_3, coeff = 0.995)
val freq_1 = LPZ2.ar(in_4)
val latoocarfianC = LatoocarfianC.ar(freq = freq_1, a = 0.0, b = 0.5, c = 0.5, d = 0.0054205526,
xi = 0.0019336962, yi = 0.0054205526)
val b_0 = min_0 min 0.0
val atan2 = b_0 atan2 0.0
val quadN = QuadN.ar(freq = freq2, a = 0.0, b = b_0, c = 0.0, xi = atan2)
val excess = 0.0 excess min_0
val in_5 = LeakDC.ar(in_2, coeff = 0.995)
val pitchShift = PitchShift.ar(in_5, winSize = 0.44575435, pitchRatio = freq3,
pitchDispersion = 0.0, timeDispersion = 0.44575435)
val freq_2 = pitchShift min excess
val in_6 = LFDClipNoise.ar(freq_2)
val in_7 = LeakDC.ar(in_6, coeff = 0.995)
val in_8 = Clip.ar(atan2, lo = -1.0, hi = 1.0)
val coeff_0 = Clip.ar(in_8, lo = -1.0, hi = 1.0)
val oneZero = OneZero.ar(in_7, coeff = coeff_0)
val min_1 = latoocarfianC min oneZero
val min_2 = henonL min freq_2
val impulse = Impulse.ar(freq = 0.1, phase = 0.0)
val dC = DC.ar(-0.5128193)
val mix = Mix(Seq[GE](quadN, min_1, min_2, impulse, dC))
val sig = LeakDC.ar(mix.clip2(1.0)) * 0.49 * "amp".kr(1.0)
Out.ar(0, sig)