-- | **Note:** The argument format for these is a little
--   rough, and is likely to change in the future

{-# LANGUAGE
     DataKinds
   , LambdaCase
   , OverloadedStrings
   , ScopedTypeVariables
   , TypeFamilies, NoMonoLocalBinds
   , ViewPatterns

   , FlexibleContexts

   , NoIncoherentInstances
   , NoMonomorphismRestriction
   , NoUndecidableInstances
   #-}

module Vivid.UGens.Envelopes (
     -- In UGens.Filters.Linear:
   -- decay
     -- In UGens.Filters.Linear:
   -- , decay2
     -- In Vivid.UGens.Demand:
   -- , demandEnvGen
     adsrGen
---   , dadsrGen
   , envGate
   , envGen
   , envGen_wGate
---   , iEnvGen
   , line
   , linen
   , percGen
   , xLine
   ) where

import Vivid.Envelopes
import Vivid.SC.SynthDef.Types (CalculationRate(..))
import Vivid.SynthDef
import Vivid.SynthDef.FromUA
-- import Vivid.SynthDef.TypesafeArgs
import Vivid.UGens.Args
import Vivid.UGens.Algebraic

import GHC.TypeLits
-- import qualified Data.Map as Map
import Data.Monoid
import Data.Proxy

-- | Defaults to 'AR'
adsrGen :: (Args '[] '["peakLevel", {- "curve", -} "bias", "gate", "doneAction"] as, ToSig attackTime (SDBodyArgs as), ToSig decayTime (SDBodyArgs as), ToSig sustainLevel (SDBodyArgs as), ToSig releaseTime (SDBodyArgs as)) => attackTime -> decayTime -> sustainLevel -> releaseTime -> EnvCurve -> as -> SDBody as Signal
adsrGen :: attackTime
-> decayTime
-> sustainLevel
-> releaseTime
-> EnvCurve
-> as
-> SDBody as Signal
adsrGen attackTime
attackTime decayTime
decayTime sustainLevel
sustainLevel releaseTime
releaseTime EnvCurve
curve as
userArgs = do
   Signal
attackTime' <- attackTime -> SDBody as Signal
forall s (args :: [Symbol]).
ToSig s args =>
s -> SDBody' args Signal
toSig attackTime
attackTime
   Signal
decayTime' <- decayTime -> SDBody as Signal
forall s (args :: [Symbol]).
ToSig s args =>
s -> SDBody' args Signal
toSig decayTime
decayTime
   Signal
sustainLevel' <- sustainLevel -> SDBody as Signal
forall s (args :: [Symbol]).
ToSig s args =>
s -> SDBody' args Signal
toSig sustainLevel
sustainLevel
   Signal
releaseTime' <- releaseTime -> SDBody as Signal
forall s (args :: [Symbol]).
ToSig s args =>
s -> SDBody' args Signal
toSig releaseTime
releaseTime
   Signal
peakLevel <- Float -> as -> Proxy "peakLevel" -> SDBody as Signal
forall as (aToLookUp :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol aToLookUp,
 ToSig defaultVal (SDBodyArgs as)) =>
defaultVal -> as -> proxy aToLookUp -> SDBody as Signal
uaArgValWDefault (Float
1::Float) as
userArgs (Proxy "peakLevel"
forall k (t :: k). Proxy t
Proxy::Proxy "peakLevel")
   Signal
bias <- Float -> as -> Proxy "bias" -> SDBody as Signal
forall as (aToLookUp :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol aToLookUp,
 ToSig defaultVal (SDBodyArgs as)) =>
defaultVal -> as -> proxy aToLookUp -> SDBody as Signal
uaArgValWDefault (Float
0::Float) as
userArgs (Proxy "bias"
forall k (t :: k). Proxy t
Proxy::Proxy "bias")
   Signal
doneAction <- Float -> as -> Proxy "doneAction" -> SDBody as Signal
forall as (aToLookUp :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol aToLookUp,
 ToSig defaultVal (SDBodyArgs as)) =>
defaultVal -> as -> proxy aToLookUp -> SDBody as Signal
uaArgValWDefault (Float
0::Float) as
userArgs (Proxy "doneAction"
forall k (t :: k). Proxy t
Proxy::Proxy "doneAction")
   Signal
gate <- Float -> as -> Proxy "gate" -> SDBody as Signal
forall as (aToLookUp :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol aToLookUp,
 ToSig defaultVal (SDBodyArgs as)) =>
defaultVal -> as -> proxy aToLookUp -> SDBody as Signal
uaArgValWDefault (Float
1::Float) as
userArgs (Proxy "gate"
forall k (t :: k). Proxy t
Proxy::Proxy "gate")

   Signal
peakXSustain <- Signal
peakLevel Signal -> Signal -> SDBody as Signal
forall i0 (a :: [Symbol]) i1.
(ToSig i0 a, ToSig i1 a) =>
i0 -> i1 -> SDBody' a Signal
~* Signal
sustainLevel'
   let plusBias :: (Signal, Signal) -> SDBody' a (Signal, Signal)
       plusBias :: (Signal, Signal) -> SDBody' a (Signal, Signal)
plusBias (Signal
a, Signal
b) = do
          Signal
a' <- Signal
bias Signal -> Signal -> SDBody' a Signal
forall i0 (a :: [Symbol]) i1.
(ToSig i0 a, ToSig i1 a) =>
i0 -> i1 -> SDBody' a Signal
~+ Signal
a
          (Signal, Signal) -> SDBody' a (Signal, Signal)
forall (m :: * -> *) a. Monad m => a -> m a
return (Signal
a', Signal
b)
   [(Signal, Signal)]
biasPlusCurveSegs <- ((Signal, Signal)
 -> StateT
      ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
      Identity
      (Signal, Signal))
-> [(Signal, Signal)]
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     [(Signal, Signal)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Signal, Signal)
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     (Signal, Signal)
forall (a :: [Symbol]).
(Signal, Signal) -> SDBody' a (Signal, Signal)
plusBias [
           (Signal
peakLevel, Signal
attackTime')
         , (Signal
peakXSustain, Signal
decayTime')
         , (Float -> Signal
Constant Float
0, Signal
releaseTime')
         ]
-- maybe write in terms of 'dadsr' ^^
   [Signal]
signals <- EnvLiterally (SDBodyArgs as) -> SDBody' (SDBodyArgs as) [Signal]
forall (b :: [Symbol]). EnvLiterally b -> SDBody' b [Signal]
envLiterallyToSignals (EnvLiterally (SDBodyArgs as) -> SDBody' (SDBodyArgs as) [Signal])
-> EnvLiterally (SDBodyArgs as) -> SDBody' (SDBodyArgs as) [Signal]
forall a b. (a -> b) -> a -> b
$ EnvLiterally :: forall (args :: [Symbol]) initial.
ToSig initial args =>
initial
-> Maybe Int
-> Float
-> Maybe Int
-> [EnvSegment]
-> EnvLiterally args
EnvLiterally {
        _envLiterally_initialVal :: Signal
_envLiterally_initialVal = Signal
bias
      , _envLiterally_releaseNode :: Maybe Int
_envLiterally_releaseNode = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2
      , _envLiterally_offset :: Float
_envLiterally_offset = Float
0
      , _envLiterally_loopNode :: Maybe Int
_envLiterally_loopNode = Maybe Int
forall a. Maybe a
Nothing
      , _envLiterally_curveSegments :: [EnvSegment]
_envLiterally_curveSegments =
         ((Signal, Signal) -> EnvSegment)
-> [(Signal, Signal)] -> [EnvSegment]
forall a b. (a -> b) -> [a] -> [b]
map (\(Signal
a,Signal
b)->Signal -> Signal -> EnvCurve -> EnvSegment
EnvSegment Signal
a Signal
b EnvCurve
curve) [(Signal, Signal)]
biasPlusCurveSegs
      }
   UGen -> SDBody as Signal
forall (args :: [Symbol]). UGen -> SDBody' args Signal
addUGen (UGen -> SDBody as Signal) -> UGen -> SDBody as Signal
forall a b. (a -> b) -> a -> b
$ UGenName -> CalculationRate -> [Signal] -> Int -> UGen
UGen (ByteString -> UGenName
UGName_S ByteString
"EnvGen") CalculationRate
AR ([
        Signal
gate
      , Float -> Signal
Constant Float
1 -- levelScale
      , Float -> Signal
Constant Float
0 -- levelBias
      , Float -> Signal
Constant Float
1 -- timeScale
      , Signal
doneAction -- doneActionNum doneAction
      ] [Signal] -> [Signal] -> [Signal]
forall a. Semigroup a => a -> a -> a
<> [Signal]
signals) Int
1

--- dadsrGen ::
--- dadsrGen =


-- TODO: do we need 'fadeSecs' anymore? maybe we should just use 'releaseIn'...
envGate :: Subset '["gate","fadeSecs"] a => SDBody' a Signal
envGate :: SDBody' a Signal
envGate = do
     -- Le -- less than or equal
   Signal
gate <- BinaryOp -> V "fadeSecs" -> Float -> SDBody' a Signal
forall s0 (a :: [Symbol]) s1.
(ToSig s0 a, ToSig s1 a) =>
BinaryOp -> s0 -> s1 -> SDBody' a Signal
biOp BinaryOp
Le (V "fadeSecs"
forall (a :: Symbol). KnownSymbol a => Variable a
V::V "fadeSecs") (Float
0::Float)
   let theEnv :: EnvLiterally args
theEnv = EnvLiterally :: forall (args :: [Symbol]) initial.
ToSig initial args =>
initial
-> Maybe Int
-> Float
-> Maybe Int
-> [EnvSegment]
-> EnvLiterally args
EnvLiterally {
            _envLiterally_initialVal :: Signal
_envLiterally_initialVal = Signal
gate
          , _envLiterally_releaseNode :: Maybe Int
_envLiterally_releaseNode = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1
          , _envLiterally_offset :: Float
_envLiterally_offset = Float
0
          , _envLiterally_loopNode :: Maybe Int
_envLiterally_loopNode = Maybe Int
forall a. Maybe a
Nothing
          , _envLiterally_curveSegments :: [EnvSegment]
_envLiterally_curveSegments = [
               Signal -> Signal -> EnvCurve -> EnvSegment
EnvSegment (Float -> Signal
Constant Float
1) (Float -> Signal
Constant Float
1) EnvCurve
Curve_Sin
             , Signal -> Signal -> EnvCurve -> EnvSegment
EnvSegment (Float -> Signal
Constant Float
0) (Float -> Signal
Constant Float
1) EnvCurve
Curve_Sin
             ]
          }

   V "gate"
-> V "fadeSecs" -> EnvLiterally a -> DoneAction -> SDBody' a Signal
forall gate (a :: [Symbol]) timeScale.
(ToSig gate a, ToSig timeScale a) =>
gate
-> timeScale -> EnvLiterally a -> DoneAction -> SDBody' a Signal
envGen_wGate (V "gate"
forall (a :: Symbol). KnownSymbol a => Variable a
V::V "gate") (V "fadeSecs"
forall (a :: Symbol). KnownSymbol a => Variable a
V::V "fadeSecs") EnvLiterally a
forall (args :: [Symbol]). EnvLiterally args
theEnv DoneAction
FreeEnclosing

-- | Defaults to 'AR'
envGen :: EnvLiterally a -> DoneAction -> SDBody' a Signal
envGen :: EnvLiterally a -> DoneAction -> SDBody' a Signal
envGen EnvLiterally a
theEnv DoneAction
doneAction = do
   [Signal]
curveSignals <- EnvLiterally a -> SDBody' a [Signal]
forall (b :: [Symbol]). EnvLiterally b -> SDBody' b [Signal]
envLiterallyToSignals EnvLiterally a
theEnv
   UGen -> SDBody' a Signal
forall (args :: [Symbol]). UGen -> SDBody' args Signal
addUGen (UGen -> SDBody' a Signal) -> UGen -> SDBody' a Signal
forall a b. (a -> b) -> a -> b
$ UGenName -> CalculationRate -> [Signal] -> Int -> UGen
UGen (ByteString -> UGenName
UGName_S ByteString
"EnvGen") CalculationRate
AR ([
        Float -> Signal
Constant Float
1 -- gate
      , Float -> Signal
Constant Float
1 -- levelScale
      , Float -> Signal
Constant Float
0 -- levelBias
      , Float -> Signal
Constant Float
1 -- timeScale
      , Float -> Signal
Constant (Float -> Signal) -> Float -> Signal
forall a b. (a -> b) -> a -> b
$ DoneAction -> Float
doneActionNum DoneAction
doneAction
      ] [Signal] -> [Signal] -> [Signal]
forall a. Semigroup a => a -> a -> a
<> [Signal]
curveSignals) Int
1

envGen_wGate :: (ToSig gate a, ToSig timeScale a) => gate -> timeScale -> EnvLiterally a -> DoneAction -> SDBody' a Signal
envGen_wGate :: gate
-> timeScale -> EnvLiterally a -> DoneAction -> SDBody' a Signal
envGen_wGate gate
gate timeScale
timeScale EnvLiterally a
theEnv DoneAction
doneAction = do
   Signal
gate' <- gate -> SDBody' a Signal
forall s (args :: [Symbol]).
ToSig s args =>
s -> SDBody' args Signal
toSig gate
gate
   Signal
timeScale' <- timeScale -> SDBody' a Signal
forall s (args :: [Symbol]).
ToSig s args =>
s -> SDBody' args Signal
toSig timeScale
timeScale
   [Signal]
curveSignals <- EnvLiterally a -> SDBody' a [Signal]
forall (b :: [Symbol]). EnvLiterally b -> SDBody' b [Signal]
envLiterallyToSignals EnvLiterally a
theEnv
   UGen -> SDBody' a Signal
forall (args :: [Symbol]). UGen -> SDBody' args Signal
addUGen (UGen -> SDBody' a Signal) -> UGen -> SDBody' a Signal
forall a b. (a -> b) -> a -> b
$ UGenName -> CalculationRate -> [Signal] -> Int -> UGen
UGen (ByteString -> UGenName
UGName_S ByteString
"EnvGen") CalculationRate
AR ([
        Signal
gate' -- Constant 1 -- gate
      , Float -> Signal
Constant Float
1 -- levelScale
      , Float -> Signal
Constant Float
0 -- levelBias
      , Signal
timeScale' -- , Constant 1 -- timeScale
      , Float -> Signal
Constant (Float -> Signal) -> Float -> Signal
forall a b. (a -> b) -> a -> b
$ DoneAction -> Float
doneActionNum DoneAction
doneAction
      ] [Signal] -> [Signal] -> [Signal]
forall a. Semigroup a => a -> a -> a
<> [Signal]
curveSignals) Int
1


--- iEnvGen ::
--- iEnvGen =

-- | \"Generates a line from the start value to the end value.\"
-- 
--   Note this won't change after it's created, so if you'd like
--   to e.g. be able to change the \"freq\" in
-- 
--   > line (start_ 0, end_ (V::V "freq"))
-- 
--   you should write
-- 
--   > (V::V "freq") ~* line (start_ 0, end_ 1)
-- 
--   instead.
-- 
--   Defaults to KR
line :: (Args '[] '["start","end","duration","doneAction"] a) => a -> SDBody a Signal
line :: a -> SDBody a Signal
line = String
-> CalculationRate
-> Vs '["start", "end", "duration", "doneAction"]
-> (UA "start" (SDBodyArgs a), UA "end" (SDBodyArgs a),
    UA "duration" (SDBodyArgs a), UA "doneAction" (SDBodyArgs a))
-> a
-> SDBody a Signal
forall (tags :: [Symbol]) optional userSupplied (args :: [Symbol]).
(GetSymbolVals (Vs tags), FromUA optional, FromUA userSupplied,
 SDBodyArgs optional ~ SDBodyArgs userSupplied,
 SDBodyArgs optional ~ args) =>
String
-> CalculationRate
-> Vs tags
-> optional
-> userSupplied
-> SDBody' args Signal
makeUGen
   String
"Line" CalculationRate
AR
   (Vs '["start", "end", "duration", "doneAction"]
forall (a :: [Symbol]). Vs a
Vs::Vs '["start","end","duration","doneAction"])
   (Float -> UA "start" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "start" as
start_ (Float
0::Float), Float -> UA "end" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "end" as
end_ (Float
0::Float), Float -> UA "duration" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "duration" as
duration_ (Float
1::Float), Float -> UA "doneAction" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "doneAction" as
doneAction_ (Float
0::Float))

-- | "Simple linear envelope generator"
-- 
--   Can't change after it's created -- see the note about 'line' if you want it to
-- 
--   Only computes at "KR"
linen :: (Args '[] '["gate", "attackSecs", "susLevel", "releaseSecs", "doneAction"] a) => a -> SDBody a Signal
linen :: a -> SDBody a Signal
linen = String
-> CalculationRate
-> Vs
     '["gate", "attackSecs", "susLevel", "releaseSecs", "doneAction"]
-> (UA "gate" (SDBodyArgs a), UA "attackSecs" (SDBodyArgs a),
    UA "susLevel" (SDBodyArgs a), UA "releaseSecs" (SDBodyArgs a),
    UA "doneAction" (SDBodyArgs a))
-> a
-> SDBody a Signal
forall (tags :: [Symbol]) optional userSupplied (args :: [Symbol]).
(GetSymbolVals (Vs tags), FromUA optional, FromUA userSupplied,
 SDBodyArgs optional ~ SDBodyArgs userSupplied,
 SDBodyArgs optional ~ args) =>
String
-> CalculationRate
-> Vs tags
-> optional
-> userSupplied
-> SDBody' args Signal
makeUGen
   String
"Linen" CalculationRate
KR
   (Vs '["gate", "attackSecs", "susLevel", "releaseSecs", "doneAction"]
forall (a :: [Symbol]). Vs a
Vs::Vs '["gate", "attackSecs", "susLevel", "releaseSecs", "doneAction"])
   (Float -> UA "gate" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "gate" as
gate_ (Float
1::Float), Float -> UA "attackSecs" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "attackSecs" as
attackTime_ (Float
0.01::Float), Float -> UA "susLevel" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "susLevel" as
susLevel_ (Float
1::Float), Float -> UA "releaseSecs" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "releaseSecs" as
releaseTime_ (Float
1::Float), Float -> UA "doneAction" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "doneAction" as
doneAction_ (Float
0::Float))



-- | Percussive hit
-- 
--   'doneAction' is currently 2 but may either be 0 or 2 in future versions
percGen :: (Args '[] '["attackSecs", "releaseSecs", "level", "curve", "doneAction", "gate", "fadeSecs"] a) => a -> SDBody a Signal
percGen :: a -> SDBody a Signal
percGen a
userArgs = do
   Float
level <- Float
-> a
-> Variable "level"
-> StateT
     ([Int], SynthDef (SDBodyArgs a), VarSet (SDBodyArgs a))
     Identity
     Float
forall as (n :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol n, ToSig defaultVal (SDBodyArgs as)) =>
defaultVal
-> as
-> proxy n
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     Float
uaArgWDef_onlyConst (Float
1::Float) a
userArgs (Variable "level"
forall (a :: Symbol). KnownSymbol a => Variable a
V::V "level")
   Float
attackTime <- Float
-> a
-> Variable "attackSecs"
-> StateT
     ([Int], SynthDef (SDBodyArgs a), VarSet (SDBodyArgs a))
     Identity
     Float
forall as (n :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol n, ToSig defaultVal (SDBodyArgs as)) =>
defaultVal
-> as
-> proxy n
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     Float
uaArgWDef_onlyConst (Float
0.01::Float) a
userArgs (Variable "attackSecs"
forall (a :: Symbol). KnownSymbol a => Variable a
V::V "attackSecs")
   Float
releaseTime <- Float
-> a
-> Variable "releaseSecs"
-> StateT
     ([Int], SynthDef (SDBodyArgs a), VarSet (SDBodyArgs a))
     Identity
     Float
forall as (n :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol n, ToSig defaultVal (SDBodyArgs as)) =>
defaultVal
-> as
-> proxy n
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     Float
uaArgWDef_onlyConst (Float
1::Float) a
userArgs (Variable "releaseSecs"
forall (a :: Symbol). KnownSymbol a => Variable a
V::V "releaseSecs")
   Float
curve <- Float
-> a
-> Variable "curve"
-> StateT
     ([Int], SynthDef (SDBodyArgs a), VarSet (SDBodyArgs a))
     Identity
     Float
forall as (n :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol n, ToSig defaultVal (SDBodyArgs as)) =>
defaultVal
-> as
-> proxy n
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     Float
uaArgWDef_onlyConst (-Float
4::Float) a
userArgs (Variable "curve"
forall (a :: Symbol). KnownSymbol a => Variable a
V::V "curve")
   Int
doneAction <- Float -> Int
forall a. Enum a => a -> Int
fromEnum (Float -> Int)
-> StateT
     ([Int], SynthDef (SDBodyArgs a), VarSet (SDBodyArgs a))
     Identity
     Float
-> StateT
     ([Int], SynthDef (SDBodyArgs a), VarSet (SDBodyArgs a))
     Identity
     Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Float
-> a
-> Variable "doneAction"
-> StateT
     ([Int], SynthDef (SDBodyArgs a), VarSet (SDBodyArgs a))
     Identity
     Float
forall as (n :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol n, ToSig defaultVal (SDBodyArgs as)) =>
defaultVal
-> as
-> proxy n
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     Float
uaArgWDef_onlyConst (Float
2::Float) a
userArgs (Variable "doneAction"
forall (a :: Symbol). KnownSymbol a => Variable a
V::V "doneAction")
   Signal
gate <- Integer -> a -> V "gate" -> SDBody a Signal
forall as (aToLookUp :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol aToLookUp,
 ToSig defaultVal (SDBodyArgs as)) =>
defaultVal -> as -> proxy aToLookUp -> SDBody as Signal
uaArgValWDefault Integer
1 a
userArgs (V "gate"
forall (a :: Symbol). KnownSymbol a => Variable a
V::V "gate")
   Signal
timeScale <- Integer -> a -> V "fadeSecs" -> SDBody a Signal
forall as (aToLookUp :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol aToLookUp,
 ToSig defaultVal (SDBodyArgs as)) =>
defaultVal -> as -> proxy aToLookUp -> SDBody as Signal
uaArgValWDefault Integer
1 a
userArgs (V "fadeSecs"
forall (a :: Symbol). KnownSymbol a => Variable a
V::V "fadeSecs")

   Signal
-> Signal
-> EnvLiterally (SDBodyArgs a)
-> DoneAction
-> SDBody a Signal
forall gate (a :: [Symbol]) timeScale.
(ToSig gate a, ToSig timeScale a) =>
gate
-> timeScale -> EnvLiterally a -> DoneAction -> SDBody' a Signal
envGen_wGate Signal
gate Signal
timeScale (Float
-> [(Float, Float)] -> EnvCurve -> EnvLiterally (SDBodyArgs a)
forall (args :: [Symbol]).
Float -> [(Float, Float)] -> EnvCurve -> EnvLiterally args
env Float
0 [(Float
level, Float
attackTime), (Float
0, Float
releaseTime)] (Float -> EnvCurve
Curve_Curve Float
curve)) (Int -> DoneAction
DoneAction_AsNum Int
doneAction)
 where
   uaArgWDef_onlyConst :: defaultVal
-> as
-> proxy n
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     Float
uaArgWDef_onlyConst defaultVal
defaultVal as
args proxy n
argName =
      defaultVal -> as -> proxy n -> SDBody as Signal
forall as (aToLookUp :: Symbol) defaultVal (proxy :: Symbol -> *).
(FromUA as, KnownSymbol aToLookUp,
 ToSig defaultVal (SDBodyArgs as)) =>
defaultVal -> as -> proxy aToLookUp -> SDBody as Signal
uaArgValWDefault defaultVal
defaultVal as
args proxy n
argName SDBody as Signal
-> (Signal
    -> StateT
         ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
         Identity
         Float)
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     Float
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
         Constant Float
x -> Float
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
x
         Signal
_ -> String
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     Float
forall a. HasCallStack => String -> a
error (String
 -> StateT
      ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
      Identity
      Float)
-> String
-> StateT
     ([Int], SynthDef (SDBodyArgs as), VarSet (SDBodyArgs as))
     Identity
     Float
forall a b. (a -> b) -> a -> b
$ String
"bad argument type: "String -> String -> String
forall a. Semigroup a => a -> a -> a
<>String -> String
forall a. Show a => a -> String
show (proxy n -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal proxy n
argName)String -> String -> String
forall a. Semigroup a => a -> a -> a
<>String
" wasn't a Constant"

-- | \"Generates an exponential curve from the start value to the end value. Both the start and end values must be non-zero and have the same sign.\"
-- 
-- Defaults to KR
xLine :: (Args '[] '["start","end","duration","doneAction"] a) => a -> SDBody a Signal
xLine :: a -> SDBody a Signal
xLine = String
-> CalculationRate
-> Vs '["start", "end", "duration", "doneAction"]
-> (UA "start" (SDBodyArgs a), UA "end" (SDBodyArgs a),
    UA "duration" (SDBodyArgs a), UA "doneAction" (SDBodyArgs a))
-> a
-> SDBody a Signal
forall (tags :: [Symbol]) optional userSupplied (args :: [Symbol]).
(GetSymbolVals (Vs tags), FromUA optional, FromUA userSupplied,
 SDBodyArgs optional ~ SDBodyArgs userSupplied,
 SDBodyArgs optional ~ args) =>
String
-> CalculationRate
-> Vs tags
-> optional
-> userSupplied
-> SDBody' args Signal
makeUGen
   String
"XLine" CalculationRate
KR
   (Vs '["start", "end", "duration", "doneAction"]
forall (a :: [Symbol]). Vs a
Vs::Vs '["start","end","duration","doneAction"])
   (Float -> UA "start" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "start" as
start_ (Float
1::Float), Float -> UA "end" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "end" as
end_ (Float
2::Float), Float -> UA "duration" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "duration" as
duration_ (Float
1::Float), Float -> UA "doneAction" (SDBodyArgs a)
forall s (as :: [Symbol]). ToSig s as => s -> UA "doneAction" as
doneAction_ (Float
0::Float))