Safe Haskell	None
Language	Haskell98
Extensions	MonoLocalBinds BangPatterns TypeFamilies OverloadedStrings ViewPatterns DataKinds KindSignatures ExplicitNamespaces LambdaCase

Vivid.SynthDef

Contents

Synth actions
Synth Definition Construction
Built-in Unit Generator Operations
Orphan instances

Description

Synth Definitions in SuperCollider are how you define the way synths should sound -- you describe parameters and a graph of sound generators, add them to the server with defineSD, and then create instances of the Synth Definition (called "synths"), which each play separately. You can set parameters of the synth at any time while they're playing

Usually, you shouldn't be making SynthDefs explicitly -- there's a state monad SDBody which lets you construct synthdefs like so:

  test :: SynthDef
  test = sd (0 ::I "note") $ do
     s <- 0.1 ~* sinOsc (freq_ $ midiCPS (V::V "note"))
     out 0 [s, s]

You then optionally explicitly send the synth definition to the SC server with

>>> defineSD test

You then create a synth from the synthdef like:

>>> s <- synth test (45 ::I "note")

This returns a NodeId which is a reference to the synth, which you can use to e.g. change the params of the running synth with e.g.

>>> set s (38 ::I "note")

Then you can free it (stop its playing) with

>>> free s

(If you want interop with SClang, use "sdNamed" and "synthNamed")

Synopsis

Synth actions

Synth Definition Construction

data SynthDef args Source #

Internal representation of Synth Definitions. Usually, use sd instead of making these by hand.

This representation (especially _sdUGens) might change in the future.

Constructors

SynthDef
Fields _sdName :: SDName _sdParams :: [(ByteString, Float)] _sdUGens :: Map Int UGen

Instances

Show (SynthDef args) Source #
Methods showsPrec :: Int -> SynthDef args -> ShowS # show :: SynthDef args -> String # showList :: [SynthDef args] -> ShowS #
(~) [Symbol] a args => ToSig (SDBody' a Signal) args Source #
Methods toSig :: SDBody' a Signal -> SDBody' args Signal Source #

data UGen Source #

Representation of Unit Generators. You usually won't be creating these by hand, but instead using things from the library in UGens

Constructors

UGen
Fields _ugenName :: UGenName _ugenCalculationRate :: CalculationRate _ugenIns :: [Signal] _ugenNumOuts :: Int

Instances

Eq UGen Source #
Methods (==) :: UGen -> UGen -> Bool # (/=) :: UGen -> UGen -> Bool #
Show UGen Source #
Methods showsPrec :: Int -> UGen -> ShowS # show :: UGen -> String # showList :: [UGen] -> ShowS #

addUGen :: UGen -> SDBody' args Signal Source #

Alias for addMonoUGen

addMonoUGen :: UGen -> SDBody' args Signal Source #

Add a unit generator with one output

addPolyUGen :: UGen -> SDBody' args [Signal] Source #

Polyphonic -- returns a list of Signals. In the future this might be a tuple instead of a list

class ToSig s args where Source #

Don't define other instances of this! (Unless you know what you're doing) Instance resolution could get screwed up.

Minimal complete definition

toSig

Methods

toSig :: s -> SDBody' args Signal Source #

Instances

(Num n, Real n) => ToSig n args Source #	For `Constant` (Float) values
Methods toSig :: n -> SDBody' args Signal Source #
ToSig Signal args Source #
Methods toSig :: Signal -> SDBody' args Signal Source #
ToSig BufferId args Source #
Methods toSig :: BufferId -> SDBody' args Signal Source #
(KnownSymbol a, Subset ((:) Symbol a ([] Symbol)) args) => ToSig (Variable a) args Source #
Methods toSig :: Variable a -> SDBody' args Signal Source #
(~) [Symbol] a args => ToSig (SDBody' a Signal) args Source #
Methods toSig :: SDBody' a Signal -> SDBody' args Signal Source #

data Signal Source #

Constructors

Constant Float
Param ByteString
UGOut Int Int32

Instances

Eq Signal Source #
Methods (==) :: Signal -> Signal -> Bool # (/=) :: Signal -> Signal -> Bool #
Show Signal Source #
Methods showsPrec :: Int -> Signal -> ShowS # show :: Signal -> String # showList :: [Signal] -> ShowS #
ToSig Signal args Source #
Methods toSig :: Signal -> SDBody' args Signal Source #
(~) [Symbol] a args => ToSig (SDBody' a Signal) args Source #
Methods toSig :: SDBody' a Signal -> SDBody' args Signal Source #

encodeSD :: SynthDef a -> ByteString Source #

sd :: VarList argList => argList -> SDBody' (InnerVars argList) [Signal] -> SynthDef (InnerVars argList) Source #

Define a Synth Definition

sdNamed :: VarList argList => String -> argList -> SDBody' (InnerVars argList) [Signal] -> SynthDef (InnerVars argList) Source #

Define a Synth Definition and give it a name you can refer to from e.g. sclang

sdPretty :: SynthDef a -> String Source #

(?) :: SDBody' args Signal -> CalculationRate -> SDBody' args Signal Source #

Set the calculation rate of a UGen

e.g.

play $ do
   s0 <- 1 ~+ (lfSaw (freq_ 1) ? KR)
   s1 <- 0.1 ~* lfSaw (freq_ $ 220 ~* s0)
   out 0 [s1, s1]

Mnemonic: "?" is like thinking

In the future, the representation of calculation rates may change

data DoneAction Source #

Action to take with a UGen when it's finished

This representation will change in the future

Constructors

DoNothing
FreeEnclosing
DoneAction_AsNum Int

Instances

Eq DoneAction Source #
Methods (==) :: DoneAction -> DoneAction -> Bool # (/=) :: DoneAction -> DoneAction -> Bool #
Show DoneAction Source #
Methods showsPrec :: Int -> DoneAction -> ShowS # show :: DoneAction -> String # showList :: [DoneAction] -> ShowS #

doneActionNum :: DoneAction -> Float Source #

sdLitPretty :: LiteralSynthDef -> String Source #

sdToLiteral :: SynthDef a -> LiteralSynthDef Source #

execState #

Arguments

:: State s a	state-passing computation to execute
-> s	initial value
-> s	final state

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

```
execState m s = snd (runState m s)
```

getCalcRate :: Signal -> SDBody' args CalculationRate Source #

Built-in Unit Generator Operations

data UnaryOp Source #

Unary signal operations. Many of these have functions so you don't need to use this internal representation (e.g. Neg has neg, etc).

This type might not be exposed in the future.

Constructors

Neg
Not
IsNil
NotNil
BitNot	There's a bug in some SC versions where .bitNot isn't implemented correctly. Vivid backfills it with a fix, so you can use BitNot with any SC version
Abs
AsFloat
AsInt
Ciel
Floor
Frac
Sign
Squared
Cubed
Sqrt
Exp
Recip
MIDICPS
CPSMIDI
MIDIRatio
RatioMIDI
DbAmp
AmpDb
OctCPS
CPSOct
Log
Log2
Log10
Sin
Cos
Tan
ArcSin
ArcCos
ArcTan
SinH
CosH
TanH
Rand
Rand2
LinRand
BiLinRand
Sum3Rand
Distort
SoftClip
Coin
DigitValue
Silence
Thru
RectWindow
HanWindow
WelchWindow
TriWindow
Ramp
SCurve
NumUnarySelectors

Instances

Enum UnaryOp Source #
Methods succ :: UnaryOp -> UnaryOp # pred :: UnaryOp -> UnaryOp # toEnum :: Int -> UnaryOp # fromEnum :: UnaryOp -> Int # enumFrom :: UnaryOp -> [UnaryOp] # enumFromThen :: UnaryOp -> UnaryOp -> [UnaryOp] # enumFromTo :: UnaryOp -> UnaryOp -> [UnaryOp] # enumFromThenTo :: UnaryOp -> UnaryOp -> UnaryOp -> [UnaryOp] #
Eq UnaryOp Source #
Methods (==) :: UnaryOp -> UnaryOp -> Bool # (/=) :: UnaryOp -> UnaryOp -> Bool #
Ord UnaryOp Source #
Methods compare :: UnaryOp -> UnaryOp -> Ordering # (<) :: UnaryOp -> UnaryOp -> Bool # (<=) :: UnaryOp -> UnaryOp -> Bool # (>) :: UnaryOp -> UnaryOp -> Bool # (>=) :: UnaryOp -> UnaryOp -> Bool # max :: UnaryOp -> UnaryOp -> UnaryOp # min :: UnaryOp -> UnaryOp -> UnaryOp #
Show UnaryOp Source #
Methods showsPrec :: Int -> UnaryOp -> ShowS # show :: UnaryOp -> String # showList :: [UnaryOp] -> ShowS #

uOpToSpecialI :: UnaryOp -> Int16 Source #

specialIToUOp :: Int16 -> UnaryOp Source #

data BinaryOp Source #

Binary signal operations. For the simple ones (like Add, Mul, etc.), there are functions (like ~+, ~*, etc.) that wrap them up so you don't have to make a ugen for them yourself.

In the future these may not be exported -- we'll just have functions for all of them.

Constructors

Add
Sub
Mul
IDiv	Integer division
FDiv	Float division
Mod
Eq
Ne
Lt
Gt
Le
Ge
Min
Max
BitAnd
BitOr
BitXor
Lcm
Gcd
Round
RoundUp
Trunc
Atan2
Hypot
Hypotx
Pow
ShiftLeft
ShiftRight
UnsignedShift
Fill
Ring1	a * (b + 1) == a * b + a
Ring2	a * b + a + b
Ring3	a * a * b
Ring4	a * a * b - a * b * b
DifSqr	a * a - b * b
SumSqr	a * a + b * b
SqrSum	(a + b) ^ 2
SqrDif	(a - b) ^ 2
AbsDif	abs(a - b)
Thresh
AMClip
ScaleNeg
Clip2
Excess
Fold2
Wrap2
FirstArg
RandRange
ExpRandRange
NumBinarySelectors

Instances

Enum BinaryOp Source #
Methods succ :: BinaryOp -> BinaryOp # pred :: BinaryOp -> BinaryOp # toEnum :: Int -> BinaryOp # fromEnum :: BinaryOp -> Int # enumFrom :: BinaryOp -> [BinaryOp] # enumFromThen :: BinaryOp -> BinaryOp -> [BinaryOp] # enumFromTo :: BinaryOp -> BinaryOp -> [BinaryOp] # enumFromThenTo :: BinaryOp -> BinaryOp -> BinaryOp -> [BinaryOp] #
Eq BinaryOp Source #
Methods (==) :: BinaryOp -> BinaryOp -> Bool # (/=) :: BinaryOp -> BinaryOp -> Bool #
Ord BinaryOp Source #
Methods compare :: BinaryOp -> BinaryOp -> Ordering # (<) :: BinaryOp -> BinaryOp -> Bool # (<=) :: BinaryOp -> BinaryOp -> Bool # (>) :: BinaryOp -> BinaryOp -> Bool # (>=) :: BinaryOp -> BinaryOp -> Bool # max :: BinaryOp -> BinaryOp -> BinaryOp # min :: BinaryOp -> BinaryOp -> BinaryOp #
Show BinaryOp Source #
Methods showsPrec :: Int -> BinaryOp -> ShowS # show :: BinaryOp -> String # showList :: [BinaryOp] -> ShowS #

biOpToSpecialI :: BinaryOp -> Int16 Source #

specialIToBiOp :: Int16 -> BinaryOp Source #

module Vivid.SynthDef.Types

getSDHashName :: SynthDef a -> ByteString Source #

makeSynthDef :: VarList argList => SDName -> argList -> SDBody' (InnerVars argList) [Signal] -> SynthDef (InnerVars argList) Source #

shrinkSDArgs :: Subset new old => SynthDef old -> SynthDef new Source #

Like shrinkNodeArgs but for SynthDefs

type SDBody a = SDBody' (SDBodyArgs a) Source #

Orphan instances

Hashable (SynthDef a) Source #	This is the hash of the UGen graph and params, but not the name! So (re)naming a SynthDef will not change its hash.
Methods hashWithSalt :: Int -> SynthDef a -> Int # hash :: SynthDef a -> Int #