]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.
Mellite 3.5.0 is published, and can be installed now through an experimental launcher: https://github.com/Sciss/Mellite-launcher/releases/tag/v0.1.0 - this has a built in update mechanism, and thus will liberate me from having to build platform specific versions of every Mellite update, as well as liberating you from having to re-install Mellite again and again when an update is published.
Give it a spin, and let me know if there are any issues. Or if you need a build for a different architecture.
I will show this launcher and new features of Mellite 3.5.0 in a video blog soon.