Type Members

1.  sealed trait AddAction extends AnyRef

   Add-actions are used by the server to determine where to place a node with respect to other nodes.

   Add-actions are used by the server to determine where to place a node with respect to other nodes. They form an enumeration of integers which are represented by case objects being subclasses of this abstract class.

   The following actions are known:

   • 0 - addToHead
   • 1 - addToTail
   • 2 - addBefore
   • 3 - addAfter
   • 4 - addReplace
2.  final case class AllocatorExhausted(reason: String) extends RuntimeException with Product with Serializable
3.  final case class AudioBus(server: Server, index: Int, numChannels: Int) extends Bus with Product with Serializable
4.  trait AudioRated extends AnyRef

   Utility trait that defines a rate method returning audio.

5.  final case class Buffer(server: Server, id: Int) extends ModelImpl[BufferInfo] with Product with Serializable
6.  final class BufferManager extends ModelImpl[BufferInfo]
7.  sealed trait Bus extends AnyRef
8.  final case class Completion[-A](message: Option[(A) ⇒ Packet], action: Option[(A) ⇒ Unit]) extends Product with Serializable
9.  sealed trait ControlABusMap extends AnyRef

   A mapping from an audio bus to a synth control.

   A mapping from an audio bus to a synth control.

   Note that a mapped control acts similar to an InFeedback UGen in that it does not matter whether the audio bus was written before the execution of the synth whose control is mapped or not. If it was written before, no delay is introduced, otherwise a delay of one control block is introduced.

   See also

   de.sciss.synth.ugen.InFeedback

10.  final case class ControlBus(server: Server, index: Int, numChannels: Int) extends Bus with Product with Serializable
11.  final case class ControlFillRange extends Product with Serializable
12.  sealed trait ControlKBusMap extends AnyRef

    A mapping from a control-rate bus to a synth control.

13.  trait ControlRated extends AnyRef

    Utility trait that defines a rate method returning control.

14.  sealed trait ControlSet extends AnyRef
15.  sealed trait Curve extends AnyRef
16.  trait DemandRated extends AnyRef

    Utility trait that defines a rate method returning demand.

17.  sealed trait DoneAction extends Product

    An enumeration of special codes used by some UGens to issue a related action when they they are "done".

    An enumeration of special codes used by some UGens to issue a related action when they they are "done". For example, a PlayBuf can be instructed to free its enclosing synth when the buffer has been played to the end, using the freeSelf done-action.

    The following actions are known:

    • 0 - doNothing
    • 1 - pauseSelf
    • 2 - freeSelf
    • 3 - freeSelfPred
    • 4 - freeSelfSucc
    • 5 - freeSelfPredAll
    • 6 - freeSelfSuccAll
    • 7 - freeSelfToHead
    • 8 - freeSelfToTail
    • 9 - freeSelfPausePred
    • 10 - freeSelfPauseSucc
    • 11 - freeSelfPredDeep
    • 12 - freeSelfSuccDeep
    • 13 - freeAllInGroup
    • 14 - freeGroup
18.  final case class FillRange(index: Int, num: Int, value: Float) extends Product with Serializable

    A fill range for control buses or buffers.

    A fill range for control buses or buffers.

    index

    sample offset into the buffer or channel offset into the bus. for multi channel buffers, multiply the frame offset by the number of channels

    num

    the number of samples to fill. for multi channel buffers, multiple the number of frames by the number of channels

    value

    the value to write to the bus or buffer in the given range

19.  final case class FillValue(index: Int, value: Float) extends Product with Serializable

    A tuple consisting of an index and value for that index.

    A tuple consisting of an index and value for that index.

    index

    sample offset into the buffer or channel offset into the bus. for multi channel buffers, multiply the frame offset by the number of channels

    value

    the value to write to the bus or buffer in the given range

20.  trait GE extends Product

    The main trait used in synthesis graph, a graph element, abbreviated as GE.

    The main trait used in synthesis graph, a graph element, abbreviated as GE.

    Graph elements are characterized by having a calculation rate (possibly unknown), and they embody future UGens, which are created by invoking the expand method. For each ugen in SuperCollider, there is a corresponding graph element defined in the ugen package, and these elements take again graph elements as arguments. Multi-channel expansion is thus deferred to the transition from SynthGraph to UGenGraph.

    Currently, also a lot of unary and binary operations are directly defined on the GE trait, although they might go into a separate GEOps implicit class in future versions.

    See also

    de.sciss.synth.SynthGraph

21.  final class GEOps extends AnyVal

    GEOps are operations for graph elements (GE).

    GEOps are operations for graph elements (GE). Instead of having these operations directly defined in each UGen, which is a huge list, they appear here as extension methods. Therefore, you can write SinOsc.ar.linLin ... as if linLin was defined for GE or SinOsc.

    Many of these operations are defined for constant numbers, as well, for example you can write 0.5.linLin .... These operations are defined separately.

    See also

    GE

22.  final class GraphFunction[A] extends AnyRef
23.  final case class Group(server: Server, id: Int) extends Node with Product with Serializable
24.  trait HasDoneFlag extends AnyRef

    Marks a ugen which sets a special done flag that can be read by ugens such as Done.

25.  trait HasSideEffect extends AnyRef

    Marks a ugen which has side effects such as writing to a bus or buffer, communicating back to the client, etc.

    Marks a ugen which has side effects such as writing to a bus or buffer, communicating back to the client, etc. Only side-effect ugens are valid roots of the ugen graph, that way other orphaned non-side-effect ugens are automatically removed from the graph.

26.  trait IsIndividual extends AnyRef

    Marks a ugen which is individual, that is two instances of that ugen are different even if all inputs are the same.

    Marks a ugen which is individual, that is two instances of that ugen are different even if all inputs are the same. This is the case for example for all ugens that depend on the random seed (as indicated by the sub-type HasRandSeed) or which mix onto buses or buffers (e.g. RecordBuf).

    Note that for example BufWr could be considered not individual as two identically parametrized BufWr instances produce exactly the same behaviour as one of them. However, they are in certain spots of the UGen graph in which they could be behave differently, for example if the computation order is BufWr -> BufRd -> BufRd. We thus defensively mark every ugen as individual which writes to a Buffer or Bus.

27.  trait Lazy extends Product

    Elements implementing the Lazy trait may participate in the building of a SynthGraph body.

    Elements implementing the Lazy trait may participate in the building of a SynthGraph body. They can be added to the current graph by calling SynthGraph.builder.addLazy. Then, when the graph is expanded, the force method is called on those registered elements, allowing them to either spawn new graph elements or actually expand to UGens which can be added to the ugen graph builder argument.

    In most cases, lazy elements will expanded to ugens, and thus the subtype Lazy.Expander is the most convenient way to implement this trait, as it already does most of the logic, and provides for GEs expand method.

    See also

    de.sciss.synth.Lazy.Expander

28.  sealed abstract class MaybeRate extends Product

    This trait denotes an optional server calculation rate.

    This trait denotes an optional server calculation rate. Either the rate is explicit, Rate, or it is undefined, UndefinedRate. In the latter case, a rate is implicitly derived from the input arguments of a UGen.

29.  abstract class Node extends ModelImpl[NodeChange]
30.  final class NodeIdAllocator extends AnyRef
31.  final class NodeManager extends ModelImpl[Update]
32.  sealed abstract class Rate extends MaybeRate with Ordered[Rate]

    The server calculation rate of a UGen or a UGen output.

    The server calculation rate of a UGen or a UGen output.

    The following rates are known:

    • scalar (only calculated once when a Synth is initialized.
    • control (one value per block)
    • audio (full audio sample rate)
    • demand (calculation specially triggered on demand)
33.  trait RawUGen extends AnyRef

    The raw UGen information as it is found in a final UGenGraph.

34.  final class RichDouble extends AnyVal with NAryGEOps
35.  final class RichFloat extends AnyVal with NAryGEOps
36.  final class RichInt extends AnyVal with NAryGEOps
37.  trait ScalarRated extends AnyRef

    Utility trait that defines a rate method returning scalar.

38.  trait Server extends ServerLike with Model[Update]
39.  trait ServerConnection extends ServerLike with Model[Condition]
40.  sealed trait ServerLike extends AnyRef
41.  final case class Synth(server: Server, id: Int) extends Node with Product with Serializable
42.  final case class SynthDef(name: String, graph: UGenGraph) extends Product with Serializable
43.  final case class SynthGraph(sources: IndexedSeq[Lazy], controlProxies: Set[ControlProxyLike]) extends Product with Serializable
44.  sealed trait UGen extends RawUGen with Product

    A UGen during graph building process is a more rich thing than RawUGen: it implements equality based on isIndividual status and may be omitted from the final graph based on hasSideEffect status.

45.  final case class UGenGraph(constants: IndexedSeq[Float], controlValues: IndexedSeq[Float], controlNames: IndexedSeq[(String, Int)], ugens: IndexedSeq[IndexedUGen]) extends Product with Serializable
46.  sealed trait UGenIn extends UGenInLike

    An element that can be used as an input to a UGen.

    An element that can be used as an input to a UGen. This is after multi-channel-expansion, hence implementing classes are SingleOutUGen, UGenOutProxy, ControlOutProxy, and Constant.

47.  sealed trait UGenInLike extends GE

    A super-trait that contains UGenIn and UGenInGroup.

48.  sealed abstract class UGenSource[U] extends Expander[U]
49.  final case class UGenSpec(name: String, attr: Set[Attribute], rates: Rates, args: IndexedSeq[Argument], inputs: IndexedSeq[Input], outputs: IndexedSeq[Output], doc: Option[Doc], elemOption: Option[String]) extends Product with Serializable

    Specification of a Unit Generator.

    Specification of a Unit Generator.

    name

    the name of the unit generator, as seen by the server

    attr

    a set of attributes which characterize the UGen, such as resource usage or uniqueness

    rates

    at which calculation rates the UGen runs, and whether the rate is implied

    args

    the constructor arguments of the UGen representation. This is the interface for the client-side instantiation and may include types other than GE, for example integers for fixed number of channels, etc., as well as definitions for default values.

    inputs

    the inputs as passed to the underlying UGen (server-side object). Inputs are things which expand to UGenInLike elements. Typically they correspond to client-side args arguments. The order of this sequence must be correctly reflecting the UGen plugin interface, whereas the order of the args sequence may diverge for an improved user interface.

    outputs

    a list of output specifications

    doc

    optional text documentation

    elemOption

    diverging name of the graph element, as seen by the client

50.  trait UsesRandSeed extends IsIndividual
51.  trait WritesBuffer extends HasSideEffect with IsIndividual
52.  trait WritesBus extends HasSideEffect with IsIndividual
53.  trait WritesFFT extends HasSideEffect with IsIndividual
54.  implicit final class rangeOps extends AnyVal