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
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 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
ParamSpeceditor now, and a corresponding
ParamUGen. I have created a new tutorial for this which is currently being uploaded.
Exprbut you write an immutable graph like you do for patterns or procs. On top, a new abstraction
Widgetwhich 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.
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.
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)
Ex-DSL. The old low-level API action is now called ActionRaw (obsolete). There are tentative new binaries that bundle OpenJDK 11 on Linux and Windows: https://archive.org/details/Mellite