Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
    Hanns Holger Rutz
    @Sciss

    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.

    Hanns Holger Rutz
    @Sciss
    Mellite 2.10.1 is published and ready for download now. This fixes a couple of issues that should make this version supersede the previous 1.x generation variant in terms of stability and feature completeness. I've also set up a dedicated site - https://sciss.github.io/Mellite - which contains tutorial links (currently there are two introductory tutorials).
    Hanns Holger Rutz
    @Sciss
    Mellite 2.14.0 is published now. I started implementing a few transport features from Eisenkraut in the Audio File view (cueing with [ 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.
    Hanns Holger Rutz
    @Sciss
    I published a first introductory tutorial to SoundProcesses: http://sciss.github.io/Mellite/tut_soundprocesses1.html - it doesn't introduce yet any of the objects defined by SoundProcesses, but gives a walk through until the point where the transactional variant of ScalaCollider is used to play sound. I'm planning to add more tutorials over the next weeks.
    toreller
    @toreller
    Guten Morgen Hanns Holger
    Hanns Holger Rutz
    @Sciss
    moin
    nachmittag
    ;)
    Hanns Holger Rutz
    @Sciss
    I added a second tutorial to SoundProcesses: http://sciss.github.io/Mellite/tut_soundprocesses2.html
    toreller
    @toreller
    :thumbsup:
    Hanns Holger Rutz
    @Sciss
    Mellite 2.18.0 is published now. It fixes a pixel smear bug on macOS and offers a new timeline action to clean up overlapping regions, as they would come out from a Wolkenpumpe session.
    Hanns Holger Rutz
    @Sciss
    Mellite 2.22.0 is published now. It has the first experimental version of the Patterns library included. See video tutorial on the updated website.
    Hanns Holger Rutz
    @Sciss
    Mellite 2.23.0 is published now. It incorporates the recent ScalaCollider updates with more unary/binary ops and camel-case operators (also in FScape and Patterns).
    Hanns Holger Rutz
    @Sciss
    Mellite 2.25.0 is published now. I incorporates two new interrelated systems: A DSL for expressions, similar to the existing 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.
    Hanns Holger Rutz
    @Sciss
    Mellite 2.27.0 is published now. Website has migrated to https://sciss.de/mellite - see also new preferred binary download location.
    Hanns Holger Rutz
    @Sciss
    Mellite 2.29.1 is published now (artifacts updated at https://archive.org/details/Mellite). Main additions are the ability of patterns to function as main playable objects (see new tutorial at https://peertube.social/videos/watch/46e65cde-b459-487a-9884-0f00725e1980), and you can auto-run objects when starting Mellite from the terminal.
    Hanns Holger Rutz
    @Sciss
    Mellite 2.30.0 is published now. Not many changes user-facing, but everything is Scala 2.13.x savvy now (which becomes available around Q1 of 2019).
    Hanns Holger Rutz
    @Sciss
    Mellite 2.31.0 is published now. It adds a new command line interface for creating objects in a folder or attribute map, and basic functionality for the grapheme (break-point function) editor. Several bug fixes. A new tutorial is online as well.
    Hanns Holger Rutz
    @Sciss
    Mellite 2.32.0 is published now. It integrates the new new mini-IDE Dotterweide I have been developing since January. The editor is still in alpha/beta stage, but I found it useful enough to replace the previous one. It gets you in-editor error highlighting, improved auto-completion, and class and method look up via ctrl-alt-D. A tutorial on this is to follow.
    Hanns Holger Rutz
    @Sciss
    Mellite 2.33.0 is published now. It contains various improvements to FScape (mostly the addition of 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.
    Hanns Holger Rutz
    @Sciss
    Mellite 2.34.0 is published now. I have been mainly working on Widget and FScape. There is a workspace now you can download separately (check "Download Options > Show All") providing preliminary versions of FScape 1 modules translated to Mellite. See https://archive.org/details/Mellite
    Hanns Holger Rutz
    @Sciss
    Mellite 2.36.0 is published now. I have mainly worked on the 'widget' object, making it possible to already substitute a lot of the low-level programming one would normally do in the 'action' object. I shall add a tutorial about the new features :-/ But first focus is now on the presentation at ScalaDays.
    Hanns Holger Rutz
    @Sciss
    Mellite 2.36.2 is published now. It is mainly bug fixes compared to 2.36.0. The binary is still using Scala 2.12, but you can compile the project now against 2.13 if desired. There is a new tutorial online, introducing the Widget type: https://peertube.social/videos/watch/e10b8a0c-7d26-4bcc-a611-1175faa6287c
    Hanns Holger Rutz
    @Sciss
    Mellite 2.37.0 is published now. It simply updates FScape which contains a few fixes, and new UGens such as Convolution.
    Hanns Holger Rutz
    @Sciss
    Currently reviving my 'Negatum' project of genetically breeding synth defs. Hopefully this will go into mainline Mellite soon. Here is a beautiful sound coming out of this:
    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)
    Hanns Holger Rutz
    @Sciss
    The genetic stuff is now released as part of Mellite 2.38.1, and accompanied by a new tutorial video: https://peertube.social/videos/watch/0ae57dac-5f7d-4f0b-87e8-7d49250bb1da
    Hanns Holger Rutz
    @Sciss
    Mellite 2.39.0 is published now. It introduces Action and Control objects based on the 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
    Hanns Holger Rutz
    @Sciss

    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 MkLong, 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

    Hanns Holger Rutz
    @Sciss

    passiving of parameters

    passing of parameters

    Hanns Holger Rutz
    @Sciss
    Mellite 2.41.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, support for closures has been added, allowing to map and flatMap options and sequences of expressions. Some elements changed, such as the Act type 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.
    Hanns Holger Rutz
    @Sciss
    There is a new bug in 2.41.0 related to the UI that prevents opening confluent workspaces; that's already fixed in 2.41.1-SNAPSHOT, so will become available soon. In the meantime stick to 2.40.0.