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
Mellite 2.40.0 is published now. It continues the work on the Action and Control objects, used to define algorithmic couplings ("glue") between various objects in Mellite. In this version, particularly the passiving of parameters from a control object into a runner using
runWith has been added, as well as a way to return values, e.g. from an FScape signal process, using
MkDouble etc. along with a
Var passed into
runWith from the invoking control object.
This version also contains the necessary functionality to represent the first version in the ongoing effort of reimplementing and reconfiguring the installation piece Writing Machine / _wr_t_ng m_ch_n__ ; the binary upload thus contains a workspace with first tests for the new piece Writing (simultan) : https://archive.org/download/Mellite ; for background on this piece see https://www.researchcatalogue.net/view/665526/665527
Controlobjects, used to define algorithmic couplings ("glue") between various objects in Mellite. In this version, support for closures has been added, allowing to
flatMapoptions and sequences of expressions. Some elements changed, such as the
Acttype in action and control programs, which means that programs that make use of it are not compatible with the way preliminary support had been in v2.40.0. A new tutorial will follow.
--headlessmode has been added recently to run installations without the UI coming up. There is a new video tutorial.
Calendar(useful to schedule actions at fixed dates), the ability to list directory contents (
Hi @sentinelweb . In general I guess you can use Scala from Kotlin (or Java), but many features such as implicit parameters will have no matching equivalent, so it is probably not the most pleasant experience. Note that Mellite is conceptually a standalone application that provides a sort of IDE for SoundProcesses (the framework) and SoundProcesses is a high-level API for ScalaCollider. So it sounds like you will want to use SoundProcesses or ScalaCollider. ScalaCollider has a very simple structure and rarely uses features such as implicit paramters, whereas they are pervasive in SoundProcesses as it is built on a transactional system (STM). My guess is thus, that using ScalaCollider to create SuperCollider synths from Kotlin might be viable. But I cannot say for sure, for example how are companion objects seen from Kotlin, say when you write
SinOsc.ar? Perhaps they look very ugly because from Java perspective companion objects are not straight forward to access.
I would recommend that you try a minimal case you need for your project, like booting a server and running a synth from a preexisting SynthDef. To see if that is feasible at all. I haven't tried it.