synth
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 - addToHead1 - addToTail2 - addBefore3 - addAfter4 - addReplace
Utility trait that defines a rate method returning audio.
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.
A mapping from a control-rate bus to a synth control.
Utility trait that defines a rate method returning control.
Utility trait that defines a rate method returning demand.
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 - doNothing1 - pauseSelf2 - freeSelf3 - freeSelfPred4 - freeSelfSucc5 - freeSelfPredAll6 - freeSelfSuccAll7 - freeSelfToHead8 - freeSelfToTail9 - freeSelfPausePred10 - freeSelfPauseSucc11 - freeSelfPredDeep12 - freeSelfSuccDeep13 - freeAllInGroup14 - freeGroup
A fill range for control buses or buffers.
A fill range for control buses or buffers.
sample offset into the buffer or channel offset into the bus. for multi channel buffers, multiply the frame offset by the number of channels
the number of samples to fill. for multi channel buffers, multiple the number of frames by the number of channels
the value to write to the bus or buffer in the given range
A tuple consisting of an index and value for that index.
A tuple consisting of an index and value for that 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
the value to write to the bus or buffer in the given range
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.
Marks a ugen which sets a special done
flag that can be read by ugens such
as Done.
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.
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.
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.
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.
The server calculation rate of a UGen or a UGen output.
The raw UGen information as it is found in a final UGenGraph.
Utility trait that defines a rate method returning scalar.
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.
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.
Specification of a Unit Generator.
Specification of a Unit Generator.
the name of the unit generator, as seen by the server
a set of attributes which characterize the UGen, such as resource usage or uniqueness
at which calculation rates the UGen runs, and whether the rate is implied
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.
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.
a list of output specifications
optional text documentation
This object was generated by sbt-buildinfo.
The UGen graph is constructed from interconnecting graph elements (GE).
The UGen graph is constructed from interconnecting graph elements (GE). Graph elements can be decomposed into a sequence of UGenIn objects. Graph elements are ordinary UGens, UGen proxies, Control proxies, Constants, and collections of UGen inputs which result from multichannel expansion (UGenInSeq).
A representation for a node on the server's tree.
A representation for a node on the server's tree. A Node is either a Synth or a Group.
Note that if the node is a group, all messages send to the node which are not specific to a
Synth or Group, i.e. all messages found in this class, will affect all child nodes of the group.
For example, if release() is called on a Group, the underlying setMsg is propagated to all
Synths in the tree whose root is this group.
Importing the contents of this object adds imperative (side-effect) functions to resources such as synths, buses, buffers.
Importing the contents of this object adds imperative (side-effect) functions to resources such as
synths, buses, buffers. In general these reflect the OSC messages defined for each object, and send
them straight to the server. For example, a Synth has function newMsg which returns an OSC message
to instantiate the synth of the server. After importing Ops, you will be able to directly launch
a synth using SynthDef.play or Synth.play. You will be able to directly allocate and read buffers,
and so forth.
The reason why these functions are separated from the rest of the API is to allow other frameworks such as SoundProcesses to avoid side-effects which they handle differently (e.g., using STM).
An undefined rate signifies that a rate is either unknown or will be implicitly resolved.
An AddAction with id 3, indicating that a node should be added to the same
group as the target node, right after it.
An AddAction with id 2, indicating that a node should be added to the same
group as the target node, right before it.
An AddAction with id 4, indicating that a node should replace an existing
node, that is take the target node's exact position in the tree.
An AddAction with id 0, indicating that a node should be add to the head of
of a target group.
An AddAction with id 1, indicating that a node should be add to the tail of
of a target group.
Audio rated calculation (id 1) means that values are calculated at the audio sampling rate.
Audio rated calculation (id 1) means that values are calculated at the audio sampling rate. For example,
if the server and sound hardware run at 44.1 kHz, then 44100 samples are calculated per second. On the server,
audio rate calculation is performed in chunks, depending on the block size setting.
Control rated calculation (id 1) means that one value is calculated per block.
Control rated calculation (id 1) means that one value is calculated per block. With a default block size
of 64, for every 64 audio samples one control value is calculated. Thus, if the sampling rate is 44.1 kHz,
the control rate would be 44100/64 = approx. 689 per second.
Demand rated calculation (id 1) means that the UGen is queried by trigger through a special UGen such as
Demand.
A DoneAction with id 0, signifying that nothing should be done in particular when the UGen is finished.
A DoneAction with id 13, freeing the enclosing synth along with all other nodes
in the group when the UGen is finished (i.e.
A DoneAction with id 13, freeing the enclosing synth along with all other nodes
in the group when the UGen is finished (i.e. does
a freeAll on the group)
A DoneAction with id 14, freeing the enclosing group when the UGen is finished,
and hence also frees this synth along with all other
nodes in the group.
A DoneAction with id 2, freeing the enclosing synth when the UGen is finished.
A DoneAction with id 9, freeing the enclosing synth and pauses the predecessor node
when the UGen is finished.
A DoneAction with id 10, freeing the enclosing synth and pauses the successor node
when the UGen is finished.
A DoneAction with id 3, freeing the enclosing synth as well as the predecessor node
when the UGen is finished.
A DoneAction with id 5, freeing the enclosing synth when the UGen is finished.
A DoneAction with id 5, freeing the enclosing synth when the UGen is finished.
If the predecessor node is a group, calls freeAll on
that group. If the predecssor node is a synth,
frees that synth.
A DoneAction with id 11, freeing the enclosing synth when the UGen is finished.
A DoneAction with id 11, freeing the enclosing synth when the UGen is finished.
If the predecessor node is a group, calls deepFree on
that group. If the predecessor node is a synth,
frees that synth.
A DoneAction with id 4, freeing the enclosing synth as well as the successor node
when the UGen is finished.
A DoneAction with id 6, freeing the enclosing synth when the UGen is finished.
A DoneAction with id 6, freeing the enclosing synth when the UGen is finished.
If the successor node is a group, calls freeAll on
that group. If the successor node is a synth,
frees that synth.
A DoneAction with id 12, freeing the enclosing synth when the UGen is finished.
A DoneAction with id 12, freeing the enclosing synth when the UGen is finished.
If the successor node is a group, calls deepFree on
that group. If the successor node is a synth,
frees that synth.
A DoneAction with id 7, freeing the enclosing synth and all preceding nodes
in its group when the UGen is finished.
A DoneAction with id 8, freeing the enclosing synth and all succeeding nodes
in its group when the UGen is finished.
Provides operators for graph elements, such as .abs, .linlin or .poll.
Positive Float infinity.
Positive Float infinity. Useful for sequence based demand UGens.
-inf gives you negative infinity.
A DoneAction with id 1, pausing the enclosing synth when the UGen is finished.
Scalar rated calculation (id 0) means that a value is only calculated once when a Synth is initialized.
The
synthpackage provides some extension methods. In particular converting numbers to constant graph elements, operators on graph elements and allowing succinct creation of named controls. Furthermore, it contains theplayfunction to quickly test graph functions.