-- | Types of the gloss application
module Dyna.Gloss.Types(
  Run(..),
  Evt(..),
  Dyn(..),
  Env(..),
  newEnv,
  Click(..),
) where

import Prelude hiding ((<*))
import Control.Applicative (liftA2, liftA3)
import Control.Concurrent.Chan.Unagi
import Control.Monad.Reader
import Control.Monad.Base
import Control.Monad.Random.Class
import Control.Monad.Trans.Control (MonadBaseControl(..))
import Data.IORef
import Data.String
import Data.Boolean
import Data.AdditiveGroup
import Data.AffineSpace
import Data.VectorSpace
import Data.Basis
import Data.Cross
import Temporal.Class

import Graphics.Gloss
import Graphics.Gloss.Interface.IO.Game

import Dyna qualified as D
import Dyna.Gloss.Data.Vec

-- | Monad that drives the application
newtype Run a = Run { Run a -> ReaderT Env IO a
unRun :: ReaderT Env IO a }
  deriving (a -> Run b -> Run a
(a -> b) -> Run a -> Run b
(forall a b. (a -> b) -> Run a -> Run b)
-> (forall a b. a -> Run b -> Run a) -> Functor Run
forall a b. a -> Run b -> Run a
forall a b. (a -> b) -> Run a -> Run b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Run b -> Run a
$c<$ :: forall a b. a -> Run b -> Run a
fmap :: (a -> b) -> Run a -> Run b
$cfmap :: forall a b. (a -> b) -> Run a -> Run b
Functor, Functor Run
a -> Run a
Functor Run
-> (forall a. a -> Run a)
-> (forall a b. Run (a -> b) -> Run a -> Run b)
-> (forall a b c. (a -> b -> c) -> Run a -> Run b -> Run c)
-> (forall a b. Run a -> Run b -> Run b)
-> (forall a b. Run a -> Run b -> Run a)
-> Applicative Run
Run a -> Run b -> Run b
Run a -> Run b -> Run a
Run (a -> b) -> Run a -> Run b
(a -> b -> c) -> Run a -> Run b -> Run c
forall a. a -> Run a
forall a b. Run a -> Run b -> Run a
forall a b. Run a -> Run b -> Run b
forall a b. Run (a -> b) -> Run a -> Run b
forall a b c. (a -> b -> c) -> Run a -> Run b -> Run c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Run a -> Run b -> Run a
$c<* :: forall a b. Run a -> Run b -> Run a
*> :: Run a -> Run b -> Run b
$c*> :: forall a b. Run a -> Run b -> Run b
liftA2 :: (a -> b -> c) -> Run a -> Run b -> Run c
$cliftA2 :: forall a b c. (a -> b -> c) -> Run a -> Run b -> Run c
<*> :: Run (a -> b) -> Run a -> Run b
$c<*> :: forall a b. Run (a -> b) -> Run a -> Run b
pure :: a -> Run a
$cpure :: forall a. a -> Run a
$cp1Applicative :: Functor Run
Applicative, Applicative Run
a -> Run a
Applicative Run
-> (forall a b. Run a -> (a -> Run b) -> Run b)
-> (forall a b. Run a -> Run b -> Run b)
-> (forall a. a -> Run a)
-> Monad Run
Run a -> (a -> Run b) -> Run b
Run a -> Run b -> Run b
forall a. a -> Run a
forall a b. Run a -> Run b -> Run b
forall a b. Run a -> (a -> Run b) -> Run b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Run a
$creturn :: forall a. a -> Run a
>> :: Run a -> Run b -> Run b
$c>> :: forall a b. Run a -> Run b -> Run b
>>= :: Run a -> (a -> Run b) -> Run b
$c>>= :: forall a b. Run a -> (a -> Run b) -> Run b
$cp1Monad :: Applicative Run
Monad, MonadReader Env, Monad Run
Monad Run -> (forall a. IO a -> Run a) -> MonadIO Run
IO a -> Run a
forall a. IO a -> Run a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> Run a
$cliftIO :: forall a. IO a -> Run a
$cp1MonadIO :: Monad Run
MonadIO, MonadBase IO, Monad Run
Run a
Run [a]
Monad Run
-> (forall a. Random a => (a, a) -> Run a)
-> (forall a. Random a => Run a)
-> (forall a. Random a => (a, a) -> Run [a])
-> (forall a. Random a => Run [a])
-> MonadRandom Run
(a, a) -> Run a
(a, a) -> Run [a]
forall a. Random a => Run a
forall a. Random a => Run [a]
forall a. Random a => (a, a) -> Run a
forall a. Random a => (a, a) -> Run [a]
forall (m :: * -> *).
Monad m
-> (forall a. Random a => (a, a) -> m a)
-> (forall a. Random a => m a)
-> (forall a. Random a => (a, a) -> m [a])
-> (forall a. Random a => m [a])
-> MonadRandom m
getRandoms :: Run [a]
$cgetRandoms :: forall a. Random a => Run [a]
getRandomRs :: (a, a) -> Run [a]
$cgetRandomRs :: forall a. Random a => (a, a) -> Run [a]
getRandom :: Run a
$cgetRandom :: forall a. Random a => Run a
getRandomR :: (a, a) -> Run a
$cgetRandomR :: forall a. Random a => (a, a) -> Run a
$cp1MonadRandom :: Monad Run
MonadRandom)

newtype StMRun a = StMRun { StMRun a -> StM (ReaderT Env IO) a
unStMRun :: StM (ReaderT Env IO) a }

instance MonadBaseControl IO Run where
    type StM Run a = StMRun a
    liftBaseWith :: (RunInBase Run IO -> IO a) -> Run a
liftBaseWith RunInBase Run IO -> IO a
f = ReaderT Env IO a -> Run a
forall a. ReaderT Env IO a -> Run a
Run (ReaderT Env IO a -> Run a) -> ReaderT Env IO a -> Run a
forall a b. (a -> b) -> a -> b
$ (RunInBase (ReaderT Env IO) IO -> IO a) -> ReaderT Env IO a
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
(RunInBase m b -> b a) -> m a
liftBaseWith ((RunInBase (ReaderT Env IO) IO -> IO a) -> ReaderT Env IO a)
-> (RunInBase (ReaderT Env IO) IO -> IO a) -> ReaderT Env IO a
forall a b. (a -> b) -> a -> b
$ \RunInBase (ReaderT Env IO) IO
q -> RunInBase Run IO -> IO a
f ((a -> StMRun a) -> IO a -> IO (StMRun a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> StMRun a
forall a. StM (ReaderT Env IO) a -> StMRun a
StMRun (IO a -> IO (StMRun a))
-> (Run a -> IO a) -> Run a -> IO (StMRun a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReaderT Env IO a -> IO a
RunInBase (ReaderT Env IO) IO
q (ReaderT Env IO a -> IO a)
-> (Run a -> ReaderT Env IO a) -> Run a -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Run a -> ReaderT Env IO a
forall a. Run a -> ReaderT Env IO a
unRun)
    restoreM :: StM Run a -> Run a
restoreM = ReaderT Env IO a -> Run a
forall a. ReaderT Env IO a -> Run a
Run (ReaderT Env IO a -> Run a)
-> (StMRun a -> ReaderT Env IO a) -> StMRun a -> Run a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ReaderT Env IO a
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
StM m a -> m a
restoreM (a -> ReaderT Env IO a)
-> (StMRun a -> a) -> StMRun a -> ReaderT Env IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StMRun a -> a
forall a. StMRun a -> StM (ReaderT Env IO) a
unStMRun

instance D.Frp Run where
  type Ref Run = IORef

-------------------------------------------------------------------------------
-- FRP type wrappers

-- | Event stream. The meaning of an event is a callback consumer function.
-- If we give callback to it it will do something useful based on it.
--
-- The main function is runEvt:
--
-- > runEvt :: Evt m a -> (a -> m ()) -> m ()
-- > runEvt events callback = ...
--
-- Let's look at simple examples of the event streams:
--
-- Event that never produce anything:
--
-- > never = Evt {
-- >    runEvt _ = pure ()
-- >  }
--
-- So it just ignores the callback and returns right away.
--
-- Event that happens only once:
--
-- > once :: m a -> Evt m a
-- > once get = Evt {
-- >     runEvt go = go =<< get
-- >  }
--
-- It just gets the value right away and applies callback to it.
-- We can try it out in the interpreter:
--
-- > putStrLnE $ fmap ("Your message: " <> ) $ once getLine
--
-- We have useful functions to print out the events: @putStrLnE@ and @printE@.
--
-- Also we have event streams that happen periodically:
--
-- > printE $ clock 1  -- prints time every second
--
-- ## Duplication of the events.
--
-- Note that event streams are functions that do side-effects within some monad.
-- We use them as values but it means that two values with the same event stream definition
-- can produce different results. For example:
--
-- > a = toRandomR (0, 10) $ clock 1
-- > b = a
--
-- Note that a and b will each have their own copy of underlying random event stream.
-- So if you use it in the code don't expect values to be the same.
--
-- But if we want them to be the same we can copy event from it's definition with function:
--
-- > newEvt :: Evt m a -> m (Evt m a)
--
-- It starts the underying event stream process n background and sends all events
-- to the result by channel. With nice property of when we shut down the result event the
-- background process also shuts down.
--
-- > a <- newEvt toRandomR (0, 10) $ clock 1
-- > b = a
--
-- In this example event streams @a@ and @b@ will have the same events during execution.
newtype Evt a = Evt { Evt a -> Evt Run a
unEvt :: D.Evt Run a }
  deriving (a -> Evt b -> Evt a
(a -> b) -> Evt a -> Evt b
(forall a b. (a -> b) -> Evt a -> Evt b)
-> (forall a b. a -> Evt b -> Evt a) -> Functor Evt
forall a b. a -> Evt b -> Evt a
forall a b. (a -> b) -> Evt a -> Evt b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Evt b -> Evt a
$c<$ :: forall a b. a -> Evt b -> Evt a
fmap :: (a -> b) -> Evt a -> Evt b
$cfmap :: forall a b. (a -> b) -> Evt a -> Evt b
Functor, b -> Evt a -> Evt a
NonEmpty (Evt a) -> Evt a
Evt a -> Evt a -> Evt a
(Evt a -> Evt a -> Evt a)
-> (NonEmpty (Evt a) -> Evt a)
-> (forall b. Integral b => b -> Evt a -> Evt a)
-> Semigroup (Evt a)
forall b. Integral b => b -> Evt a -> Evt a
forall a. NonEmpty (Evt a) -> Evt a
forall a. Evt a -> Evt a -> Evt a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> Evt a -> Evt a
stimes :: b -> Evt a -> Evt a
$cstimes :: forall a b. Integral b => b -> Evt a -> Evt a
sconcat :: NonEmpty (Evt a) -> Evt a
$csconcat :: forall a. NonEmpty (Evt a) -> Evt a
<> :: Evt a -> Evt a -> Evt a
$c<> :: forall a. Evt a -> Evt a -> Evt a
Semigroup, Semigroup (Evt a)
Evt a
Semigroup (Evt a)
-> Evt a
-> (Evt a -> Evt a -> Evt a)
-> ([Evt a] -> Evt a)
-> Monoid (Evt a)
[Evt a] -> Evt a
Evt a -> Evt a -> Evt a
forall a. Semigroup (Evt a)
forall a. Evt a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [Evt a] -> Evt a
forall a. Evt a -> Evt a -> Evt a
mconcat :: [Evt a] -> Evt a
$cmconcat :: forall a. [Evt a] -> Evt a
mappend :: Evt a -> Evt a -> Evt a
$cmappend :: forall a. Evt a -> Evt a -> Evt a
mempty :: Evt a
$cmempty :: forall a. Evt a
$cp1Monoid :: forall a. Semigroup (Evt a)
Monoid, Functor Evt
a -> Evt a
Functor Evt
-> (forall a. a -> Evt a)
-> (forall a b. Evt (a -> b) -> Evt a -> Evt b)
-> (forall a b c. (a -> b -> c) -> Evt a -> Evt b -> Evt c)
-> (forall a b. Evt a -> Evt b -> Evt b)
-> (forall a b. Evt a -> Evt b -> Evt a)
-> Applicative Evt
Evt a -> Evt b -> Evt b
Evt a -> Evt b -> Evt a
Evt (a -> b) -> Evt a -> Evt b
(a -> b -> c) -> Evt a -> Evt b -> Evt c
forall a. a -> Evt a
forall a b. Evt a -> Evt b -> Evt a
forall a b. Evt a -> Evt b -> Evt b
forall a b. Evt (a -> b) -> Evt a -> Evt b
forall a b c. (a -> b -> c) -> Evt a -> Evt b -> Evt c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Evt a -> Evt b -> Evt a
$c<* :: forall a b. Evt a -> Evt b -> Evt a
*> :: Evt a -> Evt b -> Evt b
$c*> :: forall a b. Evt a -> Evt b -> Evt b
liftA2 :: (a -> b -> c) -> Evt a -> Evt b -> Evt c
$cliftA2 :: forall a b c. (a -> b -> c) -> Evt a -> Evt b -> Evt c
<*> :: Evt (a -> b) -> Evt a -> Evt b
$c<*> :: forall a b. Evt (a -> b) -> Evt a -> Evt b
pure :: a -> Evt a
$cpure :: forall a. a -> Evt a
$cp1Applicative :: Functor Evt
Applicative, Applicative Evt
a -> Evt a
Applicative Evt
-> (forall a b. Evt a -> (a -> Evt b) -> Evt b)
-> (forall a b. Evt a -> Evt b -> Evt b)
-> (forall a. a -> Evt a)
-> Monad Evt
Evt a -> (a -> Evt b) -> Evt b
Evt a -> Evt b -> Evt b
forall a. a -> Evt a
forall a b. Evt a -> Evt b -> Evt b
forall a b. Evt a -> (a -> Evt b) -> Evt b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Evt a
$creturn :: forall a. a -> Evt a
>> :: Evt a -> Evt b -> Evt b
$c>> :: forall a b. Evt a -> Evt b -> Evt b
>>= :: Evt a -> (a -> Evt b) -> Evt b
$c>>= :: forall a b. Evt a -> (a -> Evt b) -> Evt b
$cp1Monad :: Applicative Evt
Monad, [Evt a] -> Evt a
Evt a -> Evt a -> Evt a
([Evt a] -> Evt a) -> (Evt a -> Evt a -> Evt a) -> Melody (Evt a)
forall a. [Evt a] -> Evt a
forall a. Evt a -> Evt a -> Evt a
forall a. ([a] -> a) -> (a -> a -> a) -> Melody a
+:+ :: Evt a -> Evt a -> Evt a
$c+:+ :: forall a. Evt a -> Evt a -> Evt a
mel :: [Evt a] -> Evt a
$cmel :: forall a. [Evt a] -> Evt a
Melody, [Evt a] -> Evt a
Evt a -> Evt a -> Evt a
([Evt a] -> Evt a) -> (Evt a -> Evt a -> Evt a) -> Harmony (Evt a)
forall a. [Evt a] -> Evt a
forall a. Evt a -> Evt a -> Evt a
forall a. ([a] -> a) -> (a -> a -> a) -> Harmony a
=:= :: Evt a -> Evt a -> Evt a
$c=:= :: forall a. Evt a -> Evt a -> Evt a
har :: [Evt a] -> Evt a
$char :: forall a. [Evt a] -> Evt a
Harmony, Harmony (Evt a)
Melody (Evt a)
Melody (Evt a) -> Harmony (Evt a) -> Compose (Evt a)
forall a. Harmony (Evt a)
forall a. Melody (Evt a)
forall a. Melody a -> Harmony a -> Compose a
$cp2Compose :: forall a. Harmony (Evt a)
$cp1Compose :: forall a. Melody (Evt a)
Compose, Evt a -> Evt a
(Evt a -> Evt a) -> Loop (Evt a)
forall a. Evt a -> Evt a
forall a. (a -> a) -> Loop a
loop :: Evt a -> Evt a
$cloop :: forall a. Evt a -> Evt a
Loop)

type instance DurOf (Evt a) = Float

instance Limit (Evt a) where
  lim :: DurOf (Evt a) -> Evt a -> Evt a
lim DurOf (Evt a)
t (Evt Evt Run a
evt) = Evt Run a -> Evt a
forall a. Evt Run a -> Evt a
Evt (Evt Run a -> Evt a) -> Evt Run a -> Evt a
forall a b. (a -> b) -> a -> b
$ DurOf (Evt Run a) -> Evt Run a -> Evt Run a
forall a. Limit a => DurOf a -> a -> a
lim (Float -> NominalDiffTime
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
DurOf (Evt a)
t) Evt Run a
evt

-- | Dynamic step-wise continuous process
newtype Dyn a = Dyn { Dyn a -> Dyn Run a
unDyn :: D.Dyn Run a }
  deriving (a -> Dyn b -> Dyn a
(a -> b) -> Dyn a -> Dyn b
(forall a b. (a -> b) -> Dyn a -> Dyn b)
-> (forall a b. a -> Dyn b -> Dyn a) -> Functor Dyn
forall a b. a -> Dyn b -> Dyn a
forall a b. (a -> b) -> Dyn a -> Dyn b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Dyn b -> Dyn a
$c<$ :: forall a b. a -> Dyn b -> Dyn a
fmap :: (a -> b) -> Dyn a -> Dyn b
$cfmap :: forall a b. (a -> b) -> Dyn a -> Dyn b
Functor, Functor Dyn
a -> Dyn a
Functor Dyn
-> (forall a. a -> Dyn a)
-> (forall a b. Dyn (a -> b) -> Dyn a -> Dyn b)
-> (forall a b c. (a -> b -> c) -> Dyn a -> Dyn b -> Dyn c)
-> (forall a b. Dyn a -> Dyn b -> Dyn b)
-> (forall a b. Dyn a -> Dyn b -> Dyn a)
-> Applicative Dyn
Dyn a -> Dyn b -> Dyn b
Dyn a -> Dyn b -> Dyn a
Dyn (a -> b) -> Dyn a -> Dyn b
(a -> b -> c) -> Dyn a -> Dyn b -> Dyn c
forall a. a -> Dyn a
forall a b. Dyn a -> Dyn b -> Dyn a
forall a b. Dyn a -> Dyn b -> Dyn b
forall a b. Dyn (a -> b) -> Dyn a -> Dyn b
forall a b c. (a -> b -> c) -> Dyn a -> Dyn b -> Dyn c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Dyn a -> Dyn b -> Dyn a
$c<* :: forall a b. Dyn a -> Dyn b -> Dyn a
*> :: Dyn a -> Dyn b -> Dyn b
$c*> :: forall a b. Dyn a -> Dyn b -> Dyn b
liftA2 :: (a -> b -> c) -> Dyn a -> Dyn b -> Dyn c
$cliftA2 :: forall a b c. (a -> b -> c) -> Dyn a -> Dyn b -> Dyn c
<*> :: Dyn (a -> b) -> Dyn a -> Dyn b
$c<*> :: forall a b. Dyn (a -> b) -> Dyn a -> Dyn b
pure :: a -> Dyn a
$cpure :: forall a. a -> Dyn a
$cp1Applicative :: Functor Dyn
Applicative, Integer -> Dyn a
Dyn a -> Dyn a
Dyn a -> Dyn a -> Dyn a
(Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a)
-> (Dyn a -> Dyn a)
-> (Dyn a -> Dyn a)
-> (Integer -> Dyn a)
-> Num (Dyn a)
forall a. Num a => Integer -> Dyn a
forall a. Num a => Dyn a -> Dyn a
forall a. Num a => Dyn a -> Dyn a -> Dyn a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Dyn a
$cfromInteger :: forall a. Num a => Integer -> Dyn a
signum :: Dyn a -> Dyn a
$csignum :: forall a. Num a => Dyn a -> Dyn a
abs :: Dyn a -> Dyn a
$cabs :: forall a. Num a => Dyn a -> Dyn a
negate :: Dyn a -> Dyn a
$cnegate :: forall a. Num a => Dyn a -> Dyn a
* :: Dyn a -> Dyn a -> Dyn a
$c* :: forall a. Num a => Dyn a -> Dyn a -> Dyn a
- :: Dyn a -> Dyn a -> Dyn a
$c- :: forall a. Num a => Dyn a -> Dyn a -> Dyn a
+ :: Dyn a -> Dyn a -> Dyn a
$c+ :: forall a. Num a => Dyn a -> Dyn a -> Dyn a
Num, Num (Dyn a)
Num (Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a)
-> (Rational -> Dyn a)
-> Fractional (Dyn a)
Rational -> Dyn a
Dyn a -> Dyn a
Dyn a -> Dyn a -> Dyn a
forall a. Fractional a => Num (Dyn a)
forall a. Fractional a => Rational -> Dyn a
forall a. Fractional a => Dyn a -> Dyn a
forall a. Fractional a => Dyn a -> Dyn a -> Dyn a
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Dyn a
$cfromRational :: forall a. Fractional a => Rational -> Dyn a
recip :: Dyn a -> Dyn a
$crecip :: forall a. Fractional a => Dyn a -> Dyn a
/ :: Dyn a -> Dyn a -> Dyn a
$c/ :: forall a. Fractional a => Dyn a -> Dyn a -> Dyn a
$cp1Fractional :: forall a. Fractional a => Num (Dyn a)
Fractional, b -> Dyn a -> Dyn a
NonEmpty (Dyn a) -> Dyn a
Dyn a -> Dyn a -> Dyn a
(Dyn a -> Dyn a -> Dyn a)
-> (NonEmpty (Dyn a) -> Dyn a)
-> (forall b. Integral b => b -> Dyn a -> Dyn a)
-> Semigroup (Dyn a)
forall b. Integral b => b -> Dyn a -> Dyn a
forall a. Semigroup a => NonEmpty (Dyn a) -> Dyn a
forall a. Semigroup a => Dyn a -> Dyn a -> Dyn a
forall a b. (Semigroup a, Integral b) => b -> Dyn a -> Dyn a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> Dyn a -> Dyn a
$cstimes :: forall a b. (Semigroup a, Integral b) => b -> Dyn a -> Dyn a
sconcat :: NonEmpty (Dyn a) -> Dyn a
$csconcat :: forall a. Semigroup a => NonEmpty (Dyn a) -> Dyn a
<> :: Dyn a -> Dyn a -> Dyn a
$c<> :: forall a. Semigroup a => Dyn a -> Dyn a -> Dyn a
Semigroup, Semigroup (Dyn a)
Dyn a
Semigroup (Dyn a)
-> Dyn a
-> (Dyn a -> Dyn a -> Dyn a)
-> ([Dyn a] -> Dyn a)
-> Monoid (Dyn a)
[Dyn a] -> Dyn a
Dyn a -> Dyn a -> Dyn a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Monoid a => Semigroup (Dyn a)
forall a. Monoid a => Dyn a
forall a. Monoid a => [Dyn a] -> Dyn a
forall a. Monoid a => Dyn a -> Dyn a -> Dyn a
mconcat :: [Dyn a] -> Dyn a
$cmconcat :: forall a. Monoid a => [Dyn a] -> Dyn a
mappend :: Dyn a -> Dyn a -> Dyn a
$cmappend :: forall a. Monoid a => Dyn a -> Dyn a -> Dyn a
mempty :: Dyn a
$cmempty :: forall a. Monoid a => Dyn a
$cp1Monoid :: forall a. Monoid a => Semigroup (Dyn a)
Monoid, String -> Dyn a
(String -> Dyn a) -> IsString (Dyn a)
forall a. IsString a => String -> Dyn a
forall a. (String -> a) -> IsString a
fromString :: String -> Dyn a
$cfromString :: forall a. IsString a => String -> Dyn a
IsString,
            Dyn a
Dyn a -> Dyn a
Dyn a -> Dyn a -> Dyn a
Dyn a
-> Dyn a
-> (Dyn a -> Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> Boolean (Dyn a)
forall b.
b -> b -> (b -> b) -> (b -> b -> b) -> (b -> b -> b) -> Boolean b
forall a. Boolean a => Dyn a
forall a. Boolean a => Dyn a -> Dyn a
forall a. Boolean a => Dyn a -> Dyn a -> Dyn a
||* :: Dyn a -> Dyn a -> Dyn a
$c||* :: forall a. Boolean a => Dyn a -> Dyn a -> Dyn a
&&* :: Dyn a -> Dyn a -> Dyn a
$c&&* :: forall a. Boolean a => Dyn a -> Dyn a -> Dyn a
notB :: Dyn a -> Dyn a
$cnotB :: forall a. Boolean a => Dyn a -> Dyn a
false :: Dyn a
$cfalse :: forall a. Boolean a => Dyn a
true :: Dyn a
$ctrue :: forall a. Boolean a => Dyn a
Boolean, Dyn a
Dyn a -> Dyn a
Dyn a -> Dyn a -> Dyn a
Dyn a
-> (Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> AdditiveGroup (Dyn a)
forall v.
v -> (v -> v -> v) -> (v -> v) -> (v -> v -> v) -> AdditiveGroup v
forall a. AdditiveGroup a => Dyn a
forall a. AdditiveGroup a => Dyn a -> Dyn a
forall a. AdditiveGroup a => Dyn a -> Dyn a -> Dyn a
^-^ :: Dyn a -> Dyn a -> Dyn a
$c^-^ :: forall a. AdditiveGroup a => Dyn a -> Dyn a -> Dyn a
negateV :: Dyn a -> Dyn a
$cnegateV :: forall a. AdditiveGroup a => Dyn a -> Dyn a
^+^ :: Dyn a -> Dyn a -> Dyn a
$c^+^ :: forall a. AdditiveGroup a => Dyn a -> Dyn a -> Dyn a
zeroV :: Dyn a
$czeroV :: forall a. AdditiveGroup a => Dyn a
AdditiveGroup, AdditiveGroup (Dyn a)
AdditiveGroup (Dyn a)
-> (Scalar (Dyn a) -> Dyn a -> Dyn a) -> VectorSpace (Dyn a)
Scalar (Dyn a) -> Dyn a -> Dyn a
forall v. AdditiveGroup v -> (Scalar v -> v -> v) -> VectorSpace v
forall a. VectorSpace a => AdditiveGroup (Dyn a)
forall a. VectorSpace a => Scalar (Dyn a) -> Dyn a -> Dyn a
*^ :: Scalar (Dyn a) -> Dyn a -> Dyn a
$c*^ :: forall a. VectorSpace a => Scalar (Dyn a) -> Dyn a -> Dyn a
$cp1VectorSpace :: forall a. VectorSpace a => AdditiveGroup (Dyn a)
VectorSpace, Dyn a -> Dyn a
(Dyn a -> Dyn a) -> HasNormal (Dyn a)
forall a. HasNormal a => Dyn a -> Dyn a
forall v. (v -> v) -> HasNormal v
normalVec :: Dyn a -> Dyn a
$cnormalVec :: forall a. HasNormal a => Dyn a -> Dyn a
HasNormal, Dyn a -> Dyn a
(Dyn a -> Dyn a) -> HasCross2 (Dyn a)
forall a. HasCross2 a => Dyn a -> Dyn a
forall v. (v -> v) -> HasCross2 v
cross2 :: Dyn a -> Dyn a
$ccross2 :: forall a. HasCross2 a => Dyn a -> Dyn a
HasCross2, Dyn a -> Dyn a -> Dyn a
(Dyn a -> Dyn a -> Dyn a) -> HasCross3 (Dyn a)
forall a. HasCross3 a => Dyn a -> Dyn a -> Dyn a
forall v. (v -> v -> v) -> HasCross3 v
cross3 :: Dyn a -> Dyn a -> Dyn a
$ccross3 :: forall a. HasCross3 a => Dyn a -> Dyn a -> Dyn a
HasCross3, AdditiveGroup (Diff (Dyn a))
AdditiveGroup (Diff (Dyn a))
-> (Dyn a -> Dyn a -> Diff (Dyn a))
-> (Dyn a -> Diff (Dyn a) -> Dyn a)
-> AffineSpace (Dyn a)
Dyn a -> Diff (Dyn a) -> Dyn a
Dyn a -> Dyn a -> Diff (Dyn a)
forall p.
AdditiveGroup (Diff p)
-> (p -> p -> Diff p) -> (p -> Diff p -> p) -> AffineSpace p
forall a. AffineSpace a => AdditiveGroup (Diff (Dyn a))
forall a. AffineSpace a => Dyn a -> Diff (Dyn a) -> Dyn a
forall a. AffineSpace a => Dyn a -> Dyn a -> Diff (Dyn a)
.+^ :: Dyn a -> Diff (Dyn a) -> Dyn a
$c.+^ :: forall a. AffineSpace a => Dyn a -> Diff (Dyn a) -> Dyn a
.-. :: Dyn a -> Dyn a -> Diff (Dyn a)
$c.-. :: forall a. AffineSpace a => Dyn a -> Dyn a -> Diff (Dyn a)
$cp1AffineSpace :: forall a. AffineSpace a => AdditiveGroup (Diff (Dyn a))
AffineSpace, VectorSpace (Dyn a)
VectorSpace (Dyn a)
-> (Basis (Dyn a) -> Dyn a)
-> (Dyn a -> [(Basis (Dyn a), Scalar (Dyn a))])
-> (Dyn a -> Basis (Dyn a) -> Scalar (Dyn a))
-> HasBasis (Dyn a)
Basis (Dyn a) -> Dyn a
Dyn a -> [(Basis (Dyn a), Scalar (Dyn a))]
Dyn a -> Basis (Dyn a) -> Scalar (Dyn a)
forall v.
VectorSpace v
-> (Basis v -> v)
-> (v -> [(Basis v, Scalar v)])
-> (v -> Basis v -> Scalar v)
-> HasBasis v
forall a. (BasisArity a, HasBasis a) => VectorSpace (Dyn a)
forall a. (BasisArity a, HasBasis a) => Basis (Dyn a) -> Dyn a
forall a.
(BasisArity a, HasBasis a) =>
Dyn a -> [(Basis (Dyn a), Scalar (Dyn a))]
forall a.
(BasisArity a, HasBasis a) =>
Dyn a -> Basis (Dyn a) -> Scalar (Dyn a)
decompose' :: Dyn a -> Basis (Dyn a) -> Scalar (Dyn a)
$cdecompose' :: forall a.
(BasisArity a, HasBasis a) =>
Dyn a -> Basis (Dyn a) -> Scalar (Dyn a)
decompose :: Dyn a -> [(Basis (Dyn a), Scalar (Dyn a))]
$cdecompose :: forall a.
(BasisArity a, HasBasis a) =>
Dyn a -> [(Basis (Dyn a), Scalar (Dyn a))]
basisValue :: Basis (Dyn a) -> Dyn a
$cbasisValue :: forall a. (BasisArity a, HasBasis a) => Basis (Dyn a) -> Dyn a
$cp1HasBasis :: forall a. (BasisArity a, HasBasis a) => VectorSpace (Dyn a)
HasBasis)

type instance BooleanOf (Dyn a) = Dyn (BooleanOf a)

instance (IfB a) => IfB (Dyn a) where
  ifB :: bool -> Dyn a -> Dyn a -> Dyn a
ifB = (BooleanOf a -> a -> a -> a)
-> Dyn (BooleanOf a) -> Dyn a -> Dyn a -> Dyn a
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 BooleanOf a -> a -> a -> a
forall a bool. (IfB a, bool ~ BooleanOf a) => bool -> a -> a -> a
ifB

instance (EqB a) => EqB (Dyn a) where
  ==* :: Dyn a -> Dyn a -> bool
(==*) = (a -> a -> BooleanOf a) -> Dyn a -> Dyn a -> Dyn (BooleanOf a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> BooleanOf a
forall a bool. (EqB a, bool ~ BooleanOf a) => a -> a -> bool
(==*)

instance (OrdB a) => OrdB (Dyn a) where
  <* :: Dyn a -> Dyn a -> bool
(<*) = (a -> a -> BooleanOf a) -> Dyn a -> Dyn a -> Dyn (BooleanOf a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> BooleanOf a
forall a bool. (OrdB a, bool ~ BooleanOf a) => a -> a -> bool
(<*)
  >* :: Dyn a -> Dyn a -> bool
(>*) = (a -> a -> BooleanOf a) -> Dyn a -> Dyn a -> Dyn (BooleanOf a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> BooleanOf a
forall a bool. (OrdB a, bool ~ BooleanOf a) => a -> a -> bool
(>*)
  <=* :: Dyn a -> Dyn a -> bool
(<=*) = (a -> a -> BooleanOf a) -> Dyn a -> Dyn a -> Dyn (BooleanOf a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> BooleanOf a
forall a bool. (OrdB a, bool ~ BooleanOf a) => a -> a -> bool
(<=*)
  >=* :: Dyn a -> Dyn a -> bool
(>=*) = (a -> a -> BooleanOf a) -> Dyn a -> Dyn a -> Dyn (BooleanOf a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> BooleanOf a
forall a bool. (OrdB a, bool ~ BooleanOf a) => a -> a -> bool
(>=*)

-------------------------------------------------------------------------------

-- | All sorts of clicks
data Click = Click Key KeyState Modifiers Vec

-- | Applicaition environment
data Env = Env
  { Env -> UChan Float
env'frameChan   :: D.UChan Float
  , Env -> UChan Event
env'eventChan   :: D.UChan Event
  , Env -> UChan (Int, Int)
env'resizeChan  :: D.UChan (Int, Int)
  , Env -> UChan Click
env'keyChan     :: D.UChan Click
  , Env -> IORef Vec
env'mousePos    :: IORef Vec
  , Env -> IORef Vec
env'mouseDif1   :: IORef Vec
  , Env -> IORef Vec
env'mouseDif2   :: IORef Vec
  }

-- | Create new environment
newEnv :: IO Env
newEnv :: IO Env
newEnv = do
  UChan Float
env'frameChan <- IO (UChan Float)
forall a. IO (InChan a, OutChan a)
newChan
  UChan Event
env'eventChan <- IO (UChan Event)
forall a. IO (InChan a, OutChan a)
newChan
  UChan (Int, Int)
env'resizeChan <- IO (UChan (Int, Int))
forall a. IO (InChan a, OutChan a)
newChan
  UChan Click
env'keyChan <- IO (UChan Click)
forall a. IO (InChan a, OutChan a)
newChan
  IORef Vec
env'mousePos <- Vec -> IO (IORef Vec)
forall a. a -> IO (IORef a)
newIORef (Float -> Float -> Vec
Vec Float
0 Float
0)
  IORef Vec
env'mouseDif1 <- Vec -> IO (IORef Vec)
forall a. a -> IO (IORef a)
newIORef (Float -> Float -> Vec
Vec Float
0 Float
0)
  IORef Vec
env'mouseDif2 <- Vec -> IO (IORef Vec)
forall a. a -> IO (IORef a)
newIORef (Float -> Float -> Vec
Vec Float
0 Float
0)
  Env -> IO Env
forall (f :: * -> *) a. Applicative f => a -> f a
pure Env :: UChan Float
-> UChan Event
-> UChan (Int, Int)
-> UChan Click
-> IORef Vec
-> IORef Vec
-> IORef Vec
-> Env
Env{UChan Float
UChan (Int, Int)
UChan Event
UChan Click
IORef Vec
env'mouseDif2 :: IORef Vec
env'mouseDif1 :: IORef Vec
env'mousePos :: IORef Vec
env'keyChan :: UChan Click
env'resizeChan :: UChan (Int, Int)
env'eventChan :: UChan Event
env'frameChan :: UChan Float
env'mouseDif2 :: IORef Vec
env'mouseDif1 :: IORef Vec
env'mousePos :: IORef Vec
env'keyChan :: UChan Click
env'resizeChan :: UChan (Int, Int)
env'eventChan :: UChan Event
env'frameChan :: UChan Float
..}