Vivid.Actions.Class

A VividAction m => m a can either be run immediately, be scheduled to run at a precise future time, or be used for non-realtime synthesis.

Note that at the moment VividAction has MonadIO, but this won't be true in upcoming versions (as early as the next release) - so don't get used to it!

Documentation

class (Monad m, MonadIO m) => VividAction (m :: * -> *) where

Minimal complete definition

callBS, sync, waitForSync, wait, getTime, newBufferId, newNodeId, newSyncId, fork, defineSD

Methods

callOSC :: OSC -> m ()

Send an OSC message to the SuperCollider server

callBS :: ByteString -> m ()

Send a ByteString to the SuperCollider server. You usually want to use call instead.

sync :: m ()

Blocks until the server finishes processing commands

waitForSync :: SyncId -> m ()

As the user, you probably don't want to use this:

Many commands already include a "sync" -- e.g. makeBuffer already syncs.

When you do want to do an explicit sync you probably want to use sync instead, or callOSCAndSync

wait :: Real n => n -> m ()

Wait, in seconds

getTime :: m Timestamp

newBufferId :: m BufferId

newNodeId :: m NodeId

newSyncId :: m SyncId

fork :: m () -> m ()

defineSD :: SynthDef a -> m ()

Send a synth definition to be loaded on the SC server

Note that this is sort of optional -- if you don't call it, it'll be called the first time you call synth with the SynthDef

Instances

VividAction IO

Defined in Vivid.GlobalState

Methods

callOSC :: OSC -> IO ()

callBS :: ByteString -> IO ()

sync :: IO ()

waitForSync :: SyncId -> IO ()

wait :: Real n => n -> IO ()

getTime :: IO Timestamp

newBufferId :: IO BufferId

newNodeId :: IO NodeId

newSyncId :: IO SyncId

fork :: IO () -> IO ()

defineSD :: forall (a :: [Symbol]). SynthDef a -> IO ()

VividAction Scheduled

Defined in Vivid.Actions.Scheduled

Methods

callOSC :: OSC -> Scheduled ()

callBS :: ByteString -> Scheduled ()

sync :: Scheduled ()

waitForSync :: SyncId -> Scheduled ()

wait :: Real n => n -> Scheduled ()

getTime :: Scheduled Timestamp

newBufferId :: Scheduled BufferId

newNodeId :: Scheduled NodeId

newSyncId :: Scheduled SyncId

fork :: Scheduled () -> Scheduled ()

defineSD :: forall (a :: [Symbol]). SynthDef a -> Scheduled ()

VividAction NRT

Defined in Vivid.Actions.NRT

Methods

callOSC :: OSC -> NRT ()

callBS :: ByteString -> NRT ()

sync :: NRT ()

waitForSync :: SyncId -> NRT ()

wait :: Real n => n -> NRT ()

getTime :: NRT Timestamp

newBufferId :: NRT BufferId

newNodeId :: NRT NodeId

newSyncId :: NRT SyncId

fork :: NRT () -> NRT ()

defineSD :: forall (a :: [Symbol]). SynthDef a -> NRT ()

VividAction (ReaderT SCServerState IO)

Defined in Vivid.Actions.IO

Methods

callOSC :: OSC -> ReaderT SCServerState IO ()

callBS :: ByteString -> ReaderT SCServerState IO ()

sync :: ReaderT SCServerState IO ()

waitForSync :: SyncId -> ReaderT SCServerState IO ()

wait :: Real n => n -> ReaderT SCServerState IO ()

getTime :: ReaderT SCServerState IO Timestamp

newBufferId :: ReaderT SCServerState IO BufferId

newNodeId :: ReaderT SCServerState IO NodeId

newSyncId :: ReaderT SCServerState IO SyncId

fork :: ReaderT SCServerState IO () -> ReaderT SCServerState IO ()

defineSD :: forall (a :: [Symbol]). SynthDef a -> ReaderT SCServerState IO ()

callOSCAndSync :: VividAction m => OSC -> m ()

Send an OSC message and wait for it to complete before returning

oscWSync :: VividAction m => (SyncId -> m ()) -> m ()

Maybe can dedupe with callOSCAndSync