{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Graphics.HaGL.Eval (
    constEval,
    hostEval,
    IOEvaluator,
    EvalException(..)
) where

import Prelude hiding (id)
import Control.Exception (Exception, throw)
import Control.Applicative (liftA2)
import Control.Monad.State.Lazy
import Data.Functor.Identity
import Data.Bits

import Graphics.HaGL.Numerical
import Graphics.HaGL.GLType
import Graphics.HaGL.GLExpr
import Graphics.HaGL.Util.Types (FinList(..))
import qualified Graphics.HaGL.Util.DepMap as DepMap


type IOEvaluator = forall t. GLExpr HostDomain t -> IO t


data EvalException =
    GenericUniformEval

instance Exception EvalException

instance Show EvalException where
    show :: EvalException -> String
show EvalException
GenericUniformEval = String
"Attempted to evaluate a user-defined uniform variable"


constEval :: GLExpr ConstDomain t -> t
constEval :: forall t. GLExpr 'ConstDomain t -> t
constEval GLExpr 'ConstDomain t
expr = forall a. Identity a -> a
runIdentity forall a b. (a -> b) -> a -> b
$
    forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT (forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr 'ConstDomain t
expr) (forall (d :: GLDomain) (a :: * -> *).
(forall t. Monad a => GLExpr d t -> StateT (EvalState d a) a t)
-> DepMap (GLExpr d) Identity -> EvalState d a
EvalState forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
eval forall (k :: * -> *) (v :: * -> *). GenHashable k => DepMap k v
DepMap.empty)

hostEval ::  IOEvaluator -> GLExpr HostDomain t -> IO t
hostEval :: forall t. IOEvaluator -> GLExpr 'HostDomain t -> IO t
hostEval IOEvaluator
ioev GLExpr 'HostDomain t
expr = 
    forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT (forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr 'HostDomain t
expr) (forall (d :: GLDomain) (a :: * -> *).
(forall t. Monad a => GLExpr d t -> StateT (EvalState d a) a t)
-> DepMap (GLExpr d) Identity -> EvalState d a
EvalState (forall t.
IOEvaluator
-> GLExpr 'HostDomain t -> StateT (EvalState 'HostDomain IO) IO t
hEval IOEvaluator
ioev) forall (k :: * -> *) (v :: * -> *). GenHashable k => DepMap k v
DepMap.empty)


data EvalState d a = EvalState {
    forall (d :: GLDomain) (a :: * -> *).
EvalState d a
-> forall t. Monad a => GLExpr d t -> StateT (EvalState d a) a t
evalfn :: Monad a => forall t. GLExpr d t -> StateT (EvalState d a) a t,
    forall (d :: GLDomain) (a :: * -> *).
EvalState d a -> DepMap (GLExpr d) Identity
cache :: DepMap.DepMap (GLExpr d) Identity
}

cachedEval :: Monad a => GLExpr d t -> StateT (EvalState d a) a t
cachedEval :: forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
expr = do
    GLExpr d t -> StateT (EvalState d a) a t
evfn <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets forall (d :: GLDomain) (a :: * -> *).
EvalState d a
-> forall t. Monad a => GLExpr d t -> StateT (EvalState d a) a t
evalfn
    DepMap (GLExpr d) Identity
c <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets forall (d :: GLDomain) (a :: * -> *).
EvalState d a -> DepMap (GLExpr d) Identity
cache
    case forall (k :: * -> *) t (v :: * -> *).
GenHashable k =>
k t -> DepMap k v -> Maybe (v t)
DepMap.lookup GLExpr d t
expr DepMap (GLExpr d) Identity
c of
        Just (Identity t
val) -> forall (m :: * -> *) a. Monad m => a -> m a
return t
val
        Maybe (Identity t)
Nothing -> do
            t
val :: t <- GLExpr d t -> StateT (EvalState d a) a t
evfn GLExpr d t
expr
            forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\EvalState d a
s -> EvalState d a
s { cache :: DepMap (GLExpr d) Identity
cache = forall (k :: * -> *) t (v :: * -> *).
GenHashable k =>
k t -> v t -> DepMap k v -> DepMap k v
DepMap.insert GLExpr d t
expr (forall a. a -> Identity a
Identity t
val) (forall (d :: GLDomain) (a :: * -> *).
EvalState d a -> DepMap (GLExpr d) Identity
cache EvalState d a
s) })
            forall (m :: * -> *) a. Monad m => a -> m a
return t
val 


hEval :: IOEvaluator -> GLExpr HostDomain t -> StateT (EvalState HostDomain IO) IO t

hEval :: forall t.
IOEvaluator
-> GLExpr 'HostDomain t -> StateT (EvalState 'HostDomain IO) IO t
hEval IOEvaluator
ioev e :: GLExpr 'HostDomain t
e@(GLAtom ExprID
_ (IOFloat String
_)) = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ IOEvaluator
ioev GLExpr 'HostDomain t
e
hEval IOEvaluator
ioev e :: GLExpr 'HostDomain t
e@(GLAtom ExprID
_ (IODouble String
_)) = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ IOEvaluator
ioev GLExpr 'HostDomain t
e
hEval IOEvaluator
ioev e :: GLExpr 'HostDomain t
e@(GLAtom ExprID
_ (IOInt String
_)) = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ IOEvaluator
ioev GLExpr 'HostDomain t
e
hEval IOEvaluator
ioev e :: GLExpr 'HostDomain t
e@(GLAtom ExprID
_ (IOUInt String
_)) = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ IOEvaluator
ioev GLExpr 'HostDomain t
e
hEval IOEvaluator
ioev e :: GLExpr 'HostDomain t
e@(GLAtom ExprID
_ (IOBool String
_)) = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ IOEvaluator
ioev GLExpr 'HostDomain t
e
hEval IOEvaluator
ioev e :: GLExpr 'HostDomain t
e@(GLAtom ExprID
_ (IOPrec GLExpr 'HostDomain t
_ GLExpr 'HostDomain t
_)) = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ IOEvaluator
ioev GLExpr 'HostDomain t
e
hEval IOEvaluator
ioev (GLAtom ExprID
_ (Uniform GLExpr 'HostDomain t
x)) = forall t.
IOEvaluator
-> GLExpr 'HostDomain t -> StateT (EvalState 'HostDomain IO) IO t
hEval IOEvaluator
ioev GLExpr 'HostDomain t
x
hEval IOEvaluator
_ (GLAtom ExprID
_ (GenericUniform String
_)) = forall a e. Exception e => e -> a
throw EvalException
GenericUniformEval
hEval IOEvaluator
_ GLExpr 'HostDomain t
e = forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
eval GLExpr 'HostDomain t
e


eval :: Monad a => GLExpr d t -> StateT (EvalState d a) a t

eval :: forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
eval (GLAtom ExprID
_ (Const t
x)) = forall (m :: * -> *) a. Monad m => a -> m a
return t
x
eval (GLAtom ExprID
_ GLAtom d t
GenVar) = forall a. HasCallStack => String -> a
error String
"Attempted to evaluate an unknown variable"
eval (GLAtom ExprID
_ (Uniform GLExpr 'HostDomain t
_)) = forall a. HasCallStack => String -> a
error String
"Attempted to purely evaluate a uniform variable"
eval (GLAtom ExprID
_ (GenericUniform String
_)) = forall a. HasCallStack => String -> a
error String
"Attempted to purely evaluate a user-defined uniform variable"
eval (GLAtom ExprID
_ (Inp [GLExpr 'ConstDomain t]
_)) = forall a. HasCallStack => String -> a
error String
"Attempted to evaluate an expression in VertexDomain"
eval (GLAtom ExprID
_ (Frag InterpolationType
_ GLExpr 'VertexDomain t
_)) = forall a. HasCallStack => String -> a
error String
"Attempted to evaluate an expression in FragmentDomain"
eval (GLAtom ExprID
_ (GLLift0 t
x0)) = forall (m :: * -> *) a. Monad m => a -> m a
return t
x0
eval (GLAtom ExprID
_ (GLLift1 t1 -> t
f GLExpr 'HostDomain t1
x0)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr 'HostDomain t1
x0 forall a b. (a -> b) -> a -> b
$ \t1
x0 ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1 -> t
f t1
x0
eval (GLAtom ExprID
_ (GLLift2 t1 -> t2 -> t
f GLExpr 'HostDomain t1
x0 GLExpr 'HostDomain t2
y0)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr 'HostDomain t1
x0 GLExpr 'HostDomain t2
y0 forall a b. (a -> b) -> a -> b
$ \t1
x0 t2
y0 ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1 -> t2 -> t
f t1
x0 t2
y0
eval (GLAtom ExprID
_ (GLLift3 t1 -> t2 -> t3 -> t
f GLExpr 'HostDomain t1
x0 GLExpr 'HostDomain t2
y0 GLExpr 'HostDomain t3
z0)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr 'HostDomain t1
x0 GLExpr 'HostDomain t2
y0 GLExpr 'HostDomain t3
z0 forall a b. (a -> b) -> a -> b
$ \t1
x0 t2
y0 t3
z0 ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1 -> t2 -> t3 -> t
f t1
x0 t2
y0 t3
z0
eval (GLAtom ExprID
_ (GLLift4 t1 -> t2 -> t3 -> t4 -> t
f GLExpr 'HostDomain t1
x0 GLExpr 'HostDomain t2
y0 GLExpr 'HostDomain t3
z0 GLExpr 'HostDomain t4
w0)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv4 GLExpr 'HostDomain t1
x0 GLExpr 'HostDomain t2
y0 GLExpr 'HostDomain t3
z0 GLExpr 'HostDomain t4
w0 forall a b. (a -> b) -> a -> b
$ \t1
x0 t2
y0 t3
z0 t4
w0 ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1 -> t2 -> t3 -> t4 -> t
f t1
x0 t2
y0 t3
z0 t4
w0
eval (GLAtom ExprID
_ (GLLift5 t1 -> t2 -> t3 -> t4 -> t5 -> t
f GLExpr 'HostDomain t1
x0 GLExpr 'HostDomain t2
y0 GLExpr 'HostDomain t3
z0 GLExpr 'HostDomain t4
w0 GLExpr 'HostDomain t5
u0)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv5 GLExpr 'HostDomain t1
x0 GLExpr 'HostDomain t2
y0 GLExpr 'HostDomain t3
z0 GLExpr 'HostDomain t4
w0 GLExpr 'HostDomain t5
u0 forall a b. (a -> b) -> a -> b
$ \t1
x0 t2
y0 t3
z0 t4
w0 t5
u0 ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1 -> t2 -> t3 -> t4 -> t5 -> t
f t1
x0 t2
y0 t3
z0 t4
w0 t5
u0
eval (GLAtom ExprID
_ (GLLift6 t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t
f GLExpr 'HostDomain t1
x0 GLExpr 'HostDomain t2
y0 GLExpr 'HostDomain t3
z0 GLExpr 'HostDomain t4
w0 GLExpr 'HostDomain t5
u0 GLExpr 'HostDomain t6
v0)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv6 GLExpr 'HostDomain t1
x0 GLExpr 'HostDomain t2
y0 GLExpr 'HostDomain t3
z0 GLExpr 'HostDomain t4
w0 GLExpr 'HostDomain t5
u0 GLExpr 'HostDomain t6
v0 forall a b. (a -> b) -> a -> b
$ \t1
x0 t2
y0 t3
z0 t4
w0 t5
u0 t6
v0 ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1 -> t2 -> t3 -> t4 -> t5 -> t6 -> t
f t1
x0 t2
y0 t3
z0 t4
w0 t5
u0 t6
v0
eval (GLAtom ExprID
_ GLAtom d t
_) = forall a. HasCallStack => String -> a
error String
"Attempted to purely evaluate an IO* variable"

eval (GLFunc ExprID
_ (GLFunc1 GLExpr d t1 -> GLExpr d t
f GLExpr d t1
_ GLExpr d t1
x0)) = forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval forall a b. (a -> b) -> a -> b
$ GLExpr d t1 -> GLExpr d t
f GLExpr d t1
x0
eval (GLFunc ExprID
_ (GLFunc2 GLExpr d t1 -> GLExpr d t2 -> GLExpr d t
f GLExpr d t1
_ GLExpr d t2
_ GLExpr d t1
x0 GLExpr d t2
y0)) = forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval forall a b. (a -> b) -> a -> b
$ GLExpr d t1 -> GLExpr d t2 -> GLExpr d t
f GLExpr d t1
x0 GLExpr d t2
y0
eval (GLFunc ExprID
_ (GLFunc3 GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t
f GLExpr d t1
_ GLExpr d t2
_ GLExpr d t3
_ GLExpr d t1
x0 GLExpr d t2
y0 GLExpr d t3
z0)) = forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval forall a b. (a -> b) -> a -> b
$ GLExpr d t1 -> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t
f GLExpr d t1
x0 GLExpr d t2
y0 GLExpr d t3
z0
eval (GLFunc ExprID
_ (GLFunc4 GLExpr d t1
-> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t
f GLExpr d t1
_ GLExpr d t2
_ GLExpr d t3
_ GLExpr d t4
_ GLExpr d t1
x0 GLExpr d t2
y0 GLExpr d t3
z0 GLExpr d t4
w0)) = forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval forall a b. (a -> b) -> a -> b
$ GLExpr d t1
-> GLExpr d t2 -> GLExpr d t3 -> GLExpr d t4 -> GLExpr d t
f GLExpr d t1
x0 GLExpr d t2
y0 GLExpr d t3
z0 GLExpr d t4
w0
eval (GLFunc ExprID
_ (GLFunc5 GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t
f GLExpr d t1
_ GLExpr d t2
_ GLExpr d t3
_ GLExpr d t4
_ GLExpr d t5
_ GLExpr d t1
x0 GLExpr d t2
y0 GLExpr d t3
z0 GLExpr d t4
w0 GLExpr d t5
u0)) = forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval forall a b. (a -> b) -> a -> b
$ GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t
f GLExpr d t1
x0 GLExpr d t2
y0 GLExpr d t3
z0 GLExpr d t4
w0 GLExpr d t5
u0
eval (GLFunc ExprID
_ (GLFunc6 GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t6
-> GLExpr d t
f GLExpr d t1
_ GLExpr d t2
_ GLExpr d t3
_ GLExpr d t4
_ GLExpr d t5
_ GLExpr d t6
_ GLExpr d t1
x0 GLExpr d t2
y0 GLExpr d t3
z0 GLExpr d t4
w0 GLExpr d t5
u0 GLExpr d t6
v0)) = forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval forall a b. (a -> b) -> a -> b
$ GLExpr d t1
-> GLExpr d t2
-> GLExpr d t3
-> GLExpr d t4
-> GLExpr d t5
-> GLExpr d t6
-> GLExpr d t
f GLExpr d t1
x0 GLExpr d t2
y0 GLExpr d t3
z0 GLExpr d t4
w0 GLExpr d t5
u0 GLExpr d t6
v0

eval (GLGenExpr ExprID
_ (GLVec2 GLExpr d t1
x GLExpr d t1
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t1
x GLExpr d t1
y forall a b. (a -> b) -> a -> b
$ \t1
x t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1
x forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0 forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- t1
y forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0
eval (GLGenExpr ExprID
_ (GLVec3 GLExpr d t1
x GLExpr d t1
y GLExpr d t1
z)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr d t1
x GLExpr d t1
y GLExpr d t1
z forall a b. (a -> b) -> a -> b
$ \t1
x t1
y t1
z -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1
x forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0 forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- t1
y forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0 forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- t1
z forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0
eval (GLGenExpr ExprID
_ (GLVec4 GLExpr d t1
x GLExpr d t1
y GLExpr d t1
z GLExpr d t1
w)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv4 GLExpr d t1
x GLExpr d t1
y GLExpr d t1
z GLExpr d t1
w forall a b. (a -> b) -> a -> b
$ \t1
x t1
y t1
z t1
w -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1
x forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0 forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- t1
y forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0 forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- t1
z forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0 forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- t1
w forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0
eval (GLGenExpr ExprID
_ (GLMat2x2 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y forall a b. (a -> b) -> a -> b
$ \Vec 2 t1
x Vec 2 t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 2 t1
x forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 2 t1
y
eval (GLGenExpr ExprID
_ (GLMat2x3 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y GLExpr d (Vec 2 t1)
z)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y GLExpr d (Vec 2 t1)
z forall a b. (a -> b) -> a -> b
$ \Vec 2 t1
x Vec 2 t1
y Vec 2 t1
z -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 2 t1
x forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 2 t1
y forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 2 t1
z
eval (GLGenExpr ExprID
_ (GLMat2x4 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y GLExpr d (Vec 2 t1)
z GLExpr d (Vec 2 t1)
w)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv4 GLExpr d (Vec 2 t1)
x GLExpr d (Vec 2 t1)
y GLExpr d (Vec 2 t1)
z GLExpr d (Vec 2 t1)
w forall a b. (a -> b) -> a -> b
$ \Vec 2 t1
x Vec 2 t1
y Vec 2 t1
z Vec 2 t1
w -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 2 t1
x forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 2 t1
y forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 2 t1
z forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 2 t1
w
eval (GLGenExpr ExprID
_ (GLMat3x2 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y forall a b. (a -> b) -> a -> b
$ \Vec 3 t1
x Vec 3 t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 3 t1
x forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 3 t1
y
eval (GLGenExpr ExprID
_ (GLMat3x3 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y GLExpr d (Vec 3 t1)
z)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y GLExpr d (Vec 3 t1)
z forall a b. (a -> b) -> a -> b
$ \Vec 3 t1
x Vec 3 t1
y Vec 3 t1
z -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 3 t1
x forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 3 t1
y forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 3 t1
z
eval (GLGenExpr ExprID
_ (GLMat3x4 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y GLExpr d (Vec 3 t1)
z GLExpr d (Vec 3 t1)
w)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv4 GLExpr d (Vec 3 t1)
x GLExpr d (Vec 3 t1)
y GLExpr d (Vec 3 t1)
z GLExpr d (Vec 3 t1)
w forall a b. (a -> b) -> a -> b
$ \Vec 3 t1
x Vec 3 t1
y Vec 3 t1
z Vec 3 t1
w -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 3 t1
x forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 3 t1
y forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 3 t1
z forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 3 t1
w
eval (GLGenExpr ExprID
_ (GLMat4x2 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y forall a b. (a -> b) -> a -> b
$ \Vec 4 t1
x Vec 4 t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 4 t1
x forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 4 t1
y
eval (GLGenExpr ExprID
_ (GLMat4x3 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y GLExpr d (Vec 4 t1)
z)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y GLExpr d (Vec 4 t1)
z forall a b. (a -> b) -> a -> b
$ \Vec 4 t1
x Vec 4 t1
y Vec 4 t1
z -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 4 t1
x forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 4 t1
y forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 4 t1
z
eval (GLGenExpr ExprID
_ (GLMat4x4 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y GLExpr d (Vec 4 t1)
z GLExpr d (Vec 4 t1)
w)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv4 GLExpr d (Vec 4 t1)
x GLExpr d (Vec 4 t1)
y GLExpr d (Vec 4 t1)
z GLExpr d (Vec 4 t1)
w forall a b. (a -> b) -> a -> b
$ \Vec 4 t1
x Vec 4 t1
y Vec 4 t1
z Vec 4 t1
w -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 4 t1
x forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 4 t1
y forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 4 t1
z forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
tr Vec 4 t1
w
eval (GLGenExpr ExprID
_ (Pre GLExpr d t1
x GLExpr d (Vec n t1)
xs)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t1
x GLExpr d (Vec n t1)
xs forall a b. (a -> b) -> a -> b
$ \t1
x Vec n t1
xs ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1
x forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0 forall (q :: Nat) t (p :: Nat).
RowVec q t -> Mat p q t -> Mat (p + 1) q t
%- Vec n t1
xs
eval (GLGenExpr ExprID
_ (App GLExpr d (Vec n t1)
xs GLExpr d t1
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec n t1)
xs GLExpr d t1
x forall a b. (a -> b) -> a -> b
$ \Vec n t1
xs t1
x ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (p1 :: Nat) (q :: Nat) t (p2 :: Nat).
Mat p1 q t -> Mat p2 q t -> Mat (p1 + p2) q t
vertConcat Vec n t1
xs (t1
x forall t (q :: Nat). t -> RowVec q t -> RowVec (q + 1) t
%| forall t. Mat 1 0 t
m0)
eval (GLGenExpr ExprID
_ (Conc GLExpr d (Vec m t1)
xs GLExpr d (Vec n t1)
ys)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec m t1)
xs GLExpr d (Vec n t1)
ys forall a b. (a -> b) -> a -> b
$ \Vec m t1
xs Vec n t1
ys ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (p1 :: Nat) (q :: Nat) t (p2 :: Nat).
Mat p1 q t -> Mat p2 q t -> Mat (p1 + p2) q t
vertConcat Vec m t1
xs Vec n t1
ys
eval (GLGenExpr ExprID
_ (GLArray [GLExpr 'HostDomain t1]
xs)) = 
    forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval [GLExpr 'HostDomain t1]
xs

eval (GLGenExpr ExprID
_ (OpCoord GLCoord m
coords GLExpr d (Vec n t)
v)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Vec n t)
v forall a b. (a -> b) -> a -> b
$ \Vec n t
v ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Vec n t
v forall (p :: Nat) (q :: Nat) t. Mat p q t -> (Int, Int) -> t
`eltAt` forall (m :: Nat). GLCoord m -> (Int, Int)
coordToIndex GLCoord m
coords
eval (GLGenExpr ExprID
_ (OpCoordMulti GLCoordList l m
coordList GLExpr d (Vec n t1)
v)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Vec n t1)
v forall a b. (a -> b) -> a -> b
$ \Vec n t1
v ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Vec n t1
v forall (p :: Nat) (q :: Nat) t (m :: Nat).
Mat p q t -> FinList m (Int, Int) -> Vec m t
`eltsAt` forall (l :: Nat) (m :: Nat).
GLCoordList l m -> FinList l (Int, Int)
toFinList GLCoordList l m
coordList where
        toFinList :: GLCoordList l m -> FinList l (Int, Int)
        toFinList :: forall (l :: Nat) (m :: Nat).
GLCoordList l m -> FinList l (Int, Int)
toFinList GLCoordList l m
CoordNil = forall t. FinList 0 t
FLNil
        toFinList (CoordCons GLCoord m1
c GLCoordList l2 m2
cs) = forall t (n1 :: Nat). t -> FinList n1 t -> FinList (n1 + 1) t
FLCons (forall (m :: Nat). GLCoord m -> (Int, Int)
coordToIndex GLCoord m1
c) (forall (l :: Nat) (m :: Nat).
GLCoordList l m -> FinList l (Int, Int)
toFinList GLCoordList l2 m2
cs)
eval (GLGenExpr ExprID
_ (OpCol GLCol m
col GLExpr d (Mat r c t1)
m)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Mat r c t1)
m forall a b. (a -> b) -> a -> b
$ \Mat r c t1
m ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Mat r c t1
m forall (p :: Nat) (q :: Nat) t. Mat p q t -> Int -> Vec p t
`matCol` forall (m :: Nat). GLCol m -> Int
colToIndex GLCol m
col
eval (GLGenExpr ExprID
_ (OpArrayElt GLExpr d [t]
arr GLExpr d Int
i)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d [t]
arr GLExpr d Int
i forall a b. (a -> b) -> a -> b
$ \[t]
arr Int
i ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [t]
arr forall a. [a] -> Int -> a
!! forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int
i forall a. Integral a => a -> a -> a
`mod` forall (t :: * -> *) a. Foldable t => t a -> Int
Prelude.length [t]
arr)

eval (GLGenExpr ExprID
_ (Cast GLExpr d t1
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t1
x forall a b. (a -> b) -> a -> b
$ \t1
x ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t t0. (GLPrim t, GLPrim t0) => t0 -> t
glCast t1
x
eval (GLGenExpr ExprID
_ (MatCast GLExpr d (Mat p q t1)
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Mat p q t1)
x forall a b. (a -> b) -> a -> b
$ \Mat p q t1
x ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (p :: Nat) (q :: Nat) t.
(KnownNat p, KnownNat q) =>
[t] -> Mat p q t
fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall t t0. (GLPrim t, GLPrim t0) => t0 -> t
glCast forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (p :: Nat) (q :: Nat) t. Mat p q t -> [t]
toList forall a b. (a -> b) -> a -> b
$ Mat p q t1
x

eval (GLGenExpr ExprID
_ (OpAdd GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall a. Num a => a -> a -> a
(+) t
x t
y
eval (GLGenExpr ExprID
_ (OpSubt GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith (-) t
x t
y
eval (GLGenExpr ExprID
_ (OpMult GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall a. Num a => a -> a -> a
(*) t
x t
y
eval (GLGenExpr ExprID
_ (OpDiv GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall t. GLNumeric t => t -> t -> t
genDiv t
x t
y
eval (GLGenExpr ExprID
_ (OpMod GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall a. Integral a => a -> a -> a
mod t
x t
y
eval (GLGenExpr ExprID
_ (OpNeg GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall a. Num a => a -> a
negate t
x
eval (GLGenExpr ExprID
_ (OpLessThan GLExpr d t1
x GLExpr d t1
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t1
x GLExpr d t1
y forall a b. (a -> b) -> a -> b
$ \t1
x t1
y ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1
x forall a. Ord a => a -> a -> Bool
< t1
y
eval (GLGenExpr ExprID
_ (OpLessThanEqual GLExpr d t1
x GLExpr d t1
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t1
x GLExpr d t1
y forall a b. (a -> b) -> a -> b
$ \t1
x t1
y ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1
x forall a. Ord a => a -> a -> Bool
<= t1
y
eval (GLGenExpr ExprID
_ (OpGreaterThan GLExpr d t1
x GLExpr d t1
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t1
x GLExpr d t1
y forall a b. (a -> b) -> a -> b
$ \t1
x t1
y ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1
x forall a. Ord a => a -> a -> Bool
> t1
y
eval (GLGenExpr ExprID
_ (OpGreaterThanEqual GLExpr d t1
x GLExpr d t1
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t1
x GLExpr d t1
y forall a b. (a -> b) -> a -> b
$ \t1
x t1
y ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1
x forall a. Ord a => a -> a -> Bool
>= t1
y
eval (GLGenExpr ExprID
_ (OpEqual GLExpr d t1
x GLExpr d t1
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t1
x GLExpr d t1
y forall a b. (a -> b) -> a -> b
$ \t1
x t1
y ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1
x forall a. Eq a => a -> a -> Bool
== t1
y
eval (GLGenExpr ExprID
_ (OpNotEqual GLExpr d t1
x GLExpr d t1
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t1
x GLExpr d t1
y forall a b. (a -> b) -> a -> b
$ \t1
x t1
y ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ t1
x forall a. Eq a => a -> a -> Bool
/= t1
y
eval (GLGenExpr ExprID
_ (OpAnd GLExpr d Bool
x GLExpr d Bool
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d Bool
x GLExpr d Bool
y forall a b. (a -> b) -> a -> b
$ \Bool
x Bool
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool
x forall a. Bits a => a -> a -> a
.&. Bool
y
eval (GLGenExpr ExprID
_ (OpOr GLExpr d Bool
x GLExpr d Bool
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d Bool
x GLExpr d Bool
y forall a b. (a -> b) -> a -> b
$ \Bool
x Bool
y ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool
x forall a. Bits a => a -> a -> a
.|. Bool
y
eval (GLGenExpr ExprID
_ (OpXor GLExpr d Bool
x GLExpr d Bool
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d Bool
x GLExpr d Bool
y forall a b. (a -> b) -> a -> b
$ \Bool
x Bool
y ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool
x forall a. Bits a => a -> a -> a
`xor` Bool
y
eval (GLGenExpr ExprID
_ (OpNot GLExpr d Bool
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d Bool
x forall a b. (a -> b) -> a -> b
$ \Bool
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Bits a => a -> a
complement Bool
x
eval (GLGenExpr ExprID
_ (OpCond GLExpr d Bool
x GLExpr d t
y GLExpr d t
z)) =
    -- this is the only case where we have to be lazy
    forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d Bool
x forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> if Bool
x then forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
y else forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
z
eval (GLGenExpr ExprID
_ (OpCompl GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall a. Bits a => a -> a
complement t
x
eval (GLGenExpr ExprID
_ (OpLshift GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith (\GLElt t
x GLElt t
y -> GLElt t
x forall a. Bits a => a -> Int -> a
`shiftL` (forall a. Num a => Integer -> a
fromInteger forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Integral a => a -> Integer
toInteger) GLElt t
y) t
x t
y 
eval (GLGenExpr ExprID
_ (OpRshift GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith (\GLElt t
x GLElt t
y -> GLElt t
x forall a. Bits a => a -> Int -> a
`shiftR` (forall a. Num a => Integer -> a
fromInteger forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Integral a => a -> Integer
toInteger) GLElt t
y) t
x t
y 
eval (GLGenExpr ExprID
_ (OpBitAnd GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall a. Bits a => a -> a -> a
(.&.) t
x t
y 
eval (GLGenExpr ExprID
_ (OpBitOr GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall a. Bits a => a -> a -> a
(.|.) t
x t
y 
eval (GLGenExpr ExprID
_ (OpBitXor GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall a. Bits a => a -> a -> a
xor t
x t
y
eval (GLGenExpr ExprID
_ (OpScalarMult GLExpr d t1
x GLExpr d (Mat p q t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t1
x GLExpr d (Mat p q t1)
y forall a b. (a -> b) -> a -> b
$ \t1
x Mat p q t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (t1
x forall a. Num a => a -> a -> a
*) Mat p q t1
y
eval (GLGenExpr ExprID
_ (OpMatrixMult GLExpr d (Mat p q t1)
x GLExpr d (Mat q r t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Mat p q t1)
x GLExpr d (Mat q r t1)
y forall a b. (a -> b) -> a -> b
$ \Mat p q t1
x Mat q r t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t (p :: Nat) (q :: Nat) (r :: Nat).
Num t =>
Mat p q t -> Mat q r t -> Mat p r t
matMult Mat p q t1
x Mat q r t1
y

eval (GLGenExpr ExprID
_ (Radians GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
radians t
x where
        radians :: a -> a
radians a
deg = (forall a. Floating a => a
pi forall a. Fractional a => a -> a -> a
/ a
180) forall a. Num a => a -> a -> a
* a
deg
eval (GLGenExpr ExprID
_ (Degrees GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x ->
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
degrees t
x where
        degrees :: a -> a
degrees a
rad = (a
180 forall a. Fractional a => a -> a -> a
/ forall a. Floating a => a
pi) forall a. Num a => a -> a -> a
* a
rad
eval (GLGenExpr ExprID
_ (Sin GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
sin t
x
eval (GLGenExpr ExprID
_ (Cos GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
cos t
x
eval (GLGenExpr ExprID
_ (Tan GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
tan t
x
eval (GLGenExpr ExprID
_ (Asin GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
asin t
x
eval (GLGenExpr ExprID
_ (Acos GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
acos t
x
eval (GLGenExpr ExprID
_ (Atan GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
atan t
x
eval (GLGenExpr ExprID
_ (Sinh GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
sinh t
x
eval (GLGenExpr ExprID
_ (Cosh GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
cosh t
x
eval (GLGenExpr ExprID
_ (Tanh GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
tanh t
x
eval (GLGenExpr ExprID
_ (Asinh GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
asinh t
x
eval (GLGenExpr ExprID
_ (Acosh GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
acosh t
x
eval (GLGenExpr ExprID
_ (Atanh GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
atanh t
x

eval (GLGenExpr ExprID
_ (Pow GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall a. Floating a => a -> a -> a
(**) t
x t
y
eval (GLGenExpr ExprID
_ (Exp GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
exp t
x
eval (GLGenExpr ExprID
_ (Log GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
log t
x
eval (GLGenExpr ExprID
_ (Exp2 GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (Float
2 forall a. Floating a => a -> a -> a
**) t
x
eval (GLGenExpr ExprID
_ (Log2 GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (forall a. Floating a => a -> a -> a
logBase Float
2) t
x
eval (GLGenExpr ExprID
_ (Sqrt GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall {a}. Floating a => a -> a
sqrt t
x
eval (GLGenExpr ExprID
_ (Inversesqrt GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (forall a. Fractional a => a -> a
recip forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a}. Floating a => a -> a
sqrt) t
x

eval (GLGenExpr ExprID
_ (Abs GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall a. Num a => a -> a
abs t
x
eval (GLGenExpr ExprID
_ (Sign GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap forall a. Num a => a -> a
signum t
x
eval (GLGenExpr ExprID
_ (Floor GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (RealFrac a, Integral b) => a -> b
floor :: _ -> Int)) t
x
eval (GLGenExpr ExprID
_ (Trunc GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (RealFrac a, Integral b) => a -> b
truncate :: _ -> Int)) t
x
eval (GLGenExpr ExprID
_ (Round GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (RealFrac a, Integral b) => a -> b
round :: _ -> Int)) t
x
eval (GLGenExpr ExprID
_ (RoundEven GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (RealFrac a, Integral b) => a -> b
round :: _ -> Int)) t
x
eval (GLGenExpr ExprID
_ (Ceil GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (RealFrac a, Integral b) => a -> b
ceiling :: _ -> Int)) t
x
eval (GLGenExpr ExprID
_ (Fract GLExpr d t
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x forall a b. (a -> b) -> a -> b
$ \t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (RealFrac a, Integral b) => a -> (b, a)
properFraction :: _ -> (Int, _))) t
x
eval (GLGenExpr ExprID
_ (Mod GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall {a}. RealFrac a => a -> a -> a
mod t
x t
y where
        mod :: a -> a -> a
mod a
x a
y = a
x forall a. Num a => a -> a -> a
- a
y forall a. Num a => a -> a -> a
* (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (RealFrac a, Integral b) => a -> b
floor :: _ -> Int)) (a
x forall a. Fractional a => a -> a -> a
/ a
y)
eval (GLGenExpr ExprID
_ (Min GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall a. Ord a => a -> a -> a
min t
x t
y
eval (GLGenExpr ExprID
_ (Max GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall a. Ord a => a -> a -> a
max t
x t
y
eval (GLGenExpr ExprID
_ (Clamp GLExpr d t
x GLExpr d t
y GLExpr d t
z)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr d t
x GLExpr d t
y GLExpr d t
z forall a b. (a -> b) -> a -> b
$ \t
x t
y t
z -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t -> GLElt t) -> t -> t -> t -> t
glZipWith3 forall {a}. Ord a => a -> a -> a -> a
clamp t
x t
y t
z where
        clamp :: a -> a -> a -> a
clamp a
x a
minVal a
maxVal = forall a. Ord a => a -> a -> a
min (forall a. Ord a => a -> a -> a
max a
x a
minVal) a
maxVal
eval (GLGenExpr ExprID
_ (Mix GLExpr d t
x GLExpr d t
y GLExpr d t
z)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr d t
x GLExpr d t
y GLExpr d t
z forall a b. (a -> b) -> a -> b
$ \t
x t
y t
z -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t -> GLElt t) -> t -> t -> t -> t
glZipWith3 forall {a}. Num a => a -> a -> a -> a
mix t
x t
y t
z where
        mix :: a -> a -> a -> a
mix a
x a
y a
a = a
x forall a. Num a => a -> a -> a
* (a
1 forall a. Num a => a -> a -> a
- a
a) forall a. Num a => a -> a -> a
+ a
y forall a. Num a => a -> a -> a
* a
a
eval (GLGenExpr ExprID
_ (Step GLExpr d t
x GLExpr d t
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y forall a b. (a -> b) -> a -> b
$ \t
x t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall {a} {a}. (Ord a, Num a) => a -> a -> a
step t
x t
y where
        step :: a -> a -> a
step a
edge a
x = if a
x forall a. Ord a => a -> a -> Bool
< a
edge then a
0 else a
1
eval (GLGenExpr ExprID
_ (Smoothstep GLExpr d t
x GLExpr d t
y GLExpr d t
z)) =  forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr d t
x GLExpr d t
y GLExpr d t
z forall a b. (a -> b) -> a -> b
$ \t
x t
y t
z -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t -> GLElt t) -> t -> t -> t -> t
glZipWith3 forall {a}. (Ord a, Fractional a) => a -> a -> a -> a
smoothstep t
x t
y t
z where
        smoothstep :: a -> a -> a -> a
smoothstep a
edge0 a
edge1 a
x = 
            let t :: a
t = forall a. Ord a => a -> a -> a
min (forall a. Ord a => a -> a -> a
max ((a
x forall a. Num a => a -> a -> a
- a
edge0) forall a. Fractional a => a -> a -> a
/ (a
edge1 forall a. Num a => a -> a -> a
- a
edge0)) a
0) a
1 
            in a
t forall a. Num a => a -> a -> a
* a
t forall a. Num a => a -> a -> a
* (a
3 forall a. Num a => a -> a -> a
- a
2 forall a. Num a => a -> a -> a
* a
t)

eval (GLGenExpr ExprID
_ (Length GLExpr d (Vec n t)
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Vec n t)
x forall a b. (a -> b) -> a -> b
$ \Vec n t
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t (n :: Nat). Floating t => Vec n t -> t
Graphics.HaGL.Numerical.length Vec n t
x
eval (GLGenExpr ExprID
_ (Distance GLExpr d (Vec n t)
x GLExpr d (Vec n t)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec n t)
x GLExpr d (Vec n t)
y forall a b. (a -> b) -> a -> b
$ \Vec n t
x Vec n t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Vec n t
x forall t (n :: Nat). Floating t => Vec n t -> Vec n t -> t
`distance` Vec n t
y
eval (GLGenExpr ExprID
_ (Dot GLExpr d (Vec n t)
x GLExpr d (Vec n t)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec n t)
x GLExpr d (Vec n t)
y forall a b. (a -> b) -> a -> b
$ \Vec n t
x Vec n t
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Vec n t
x forall t (n :: Nat). Num t => Vec n t -> Vec n t -> t
`dot` Vec n t
y
eval (GLGenExpr ExprID
_ (Cross GLExpr d (Mat 3 1 t1)
x GLExpr d (Mat 3 1 t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Mat 3 1 t1)
x GLExpr d (Mat 3 1 t1)
y forall a b. (a -> b) -> a -> b
$ \Mat 3 1 t1
x Mat 3 1 t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Mat 3 1 t1
x forall t. Num t => Vec 3 t -> Vec 3 t -> Vec 3 t
`cross` Mat 3 1 t1
y
eval (GLGenExpr ExprID
_ (Normalize GLExpr d (Mat n 1 t1)
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Mat n 1 t1)
x forall a b. (a -> b) -> a -> b
$ \Mat n 1 t1
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t (n :: Nat). Floating t => Vec n t -> Vec n t
normalize Mat n 1 t1
x
eval (GLGenExpr ExprID
_ (Faceforward GLExpr d (Mat n 1 t1)
x GLExpr d (Mat n 1 t1)
y GLExpr d (Mat n 1 t1)
z)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr d (Mat n 1 t1)
x GLExpr d (Mat n 1 t1)
y GLExpr d (Mat n 1 t1)
z forall a b. (a -> b) -> a -> b
$ \Mat n 1 t1
x Mat n 1 t1
y Mat n 1 t1
z -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {a} {p} {n :: Nat}.
(Ord a, Num a, Num p) =>
p -> Vec n a -> Vec n a -> p
faceforward Mat n 1 t1
x Mat n 1 t1
y Mat n 1 t1
z where
        faceforward :: p -> Vec n a -> Vec n a -> p
faceforward p
n Vec n a
i Vec n a
nr = if forall t (n :: Nat). Num t => Vec n t -> Vec n t -> t
dot Vec n a
nr Vec n a
i forall a. Ord a => a -> a -> Bool
< a
0 then p
n else -p
n
eval (GLGenExpr ExprID
_ (Reflect GLExpr d (Mat n 1 t1)
x GLExpr d (Mat n 1 t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Mat n 1 t1)
x GLExpr d (Mat n 1 t1)
y forall a b. (a -> b) -> a -> b
$ \Mat n 1 t1
x Mat n 1 t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {n :: Nat} {t}.
(KnownNat n, Num t, GLType (Mat n 1 t)) =>
Mat n 1 t -> Mat n 1 t -> Mat n 1 t
reflect Mat n 1 t1
x Mat n 1 t1
y where
    GLElt t
c .# :: GLElt t -> t -> t
.# t
v = forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (GLElt t
c forall a. Num a => a -> a -> a
*) t
v
    reflect :: Mat n 1 t -> Mat n 1 t -> Mat n 1 t
reflect Mat n 1 t
i Mat n 1 t
n = Mat n 1 t
i forall a. Num a => a -> a -> a
- Mat n 1 t
2 forall a. Num a => a -> a -> a
* forall t (n :: Nat). Num t => Vec n t -> Vec n t -> t
dot Mat n 1 t
n Mat n 1 t
i forall {t}. (GLType t, Num (GLElt t)) => GLElt t -> t -> t
.# Mat n 1 t
n
eval (GLGenExpr ExprID
_ (Refract GLExpr d (Mat n 1 t1)
x GLExpr d (Mat n 1 t1)
y GLExpr d t1
z)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr d (Mat n 1 t1)
x GLExpr d (Mat n 1 t1)
y GLExpr d t1
z forall a b. (a -> b) -> a -> b
$ \Mat n 1 t1
x Mat n 1 t1
y t1
z -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {a} {n :: Nat}.
(Ord a, KnownNat n, GLType (Vec n a), Floating a) =>
Vec n a -> Vec n a -> a -> Vec n a
refract Mat n 1 t1
x Mat n 1 t1
y t1
z where
        GLElt t
c .# :: GLElt t -> t -> t
.# t
v = forall t. GLType t => (GLElt t -> GLElt t) -> t -> t
glMap (GLElt t
c forall a. Num a => a -> a -> a
*) t
v
        refract :: Vec n a -> Vec n a -> a -> Vec n a
refract Vec n a
i Vec n a
n a
eta =
            let k :: a
k = a
1 forall a. Num a => a -> a -> a
- a
eta forall a. Num a => a -> a -> a
* a
eta forall a. Num a => a -> a -> a
* (a
1 forall a. Num a => a -> a -> a
- forall t (n :: Nat). Num t => Vec n t -> Vec n t -> t
dot Vec n a
n Vec n a
i forall a. Num a => a -> a -> a
* forall t (n :: Nat). Num t => Vec n t -> Vec n t -> t
dot Vec n a
n Vec n a
i)
            in if a
k forall a. Ord a => a -> a -> Bool
< a
0 then Vec n a
0 else a
eta forall {t}. (GLType t, Num (GLElt t)) => GLElt t -> t -> t
.# Vec n a
i forall a. Num a => a -> a -> a
- (a
eta forall a. Num a => a -> a -> a
* forall t (n :: Nat). Num t => Vec n t -> Vec n t -> t
dot Vec n a
n Vec n a
i forall a. Num a => a -> a -> a
+ forall {a}. Floating a => a -> a
sqrt a
k) forall {t}. (GLType t, Num (GLElt t)) => GLElt t -> t -> t
.# Vec n a
n

eval (GLGenExpr ExprID
_ (MatrixCompMult GLExpr d (Mat p q t1)
x GLExpr d (Mat p q t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Mat p q t1)
x GLExpr d (Mat p q t1)
y forall a b. (a -> b) -> a -> b
$ \Mat p q t1
x Mat p q t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t.
GLType t =>
(GLElt t -> GLElt t -> GLElt t) -> t -> t -> t
glZipWith forall a. Num a => a -> a -> a
(*) Mat p q t1
x Mat p q t1
y
eval (GLGenExpr ExprID
_ (OuterProduct GLExpr d (Vec p t1)
x GLExpr d (Vec q t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec p t1)
x GLExpr d (Vec q t1)
y forall a b. (a -> b) -> a -> b
$ \Vec p t1
x Vec q t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Vec p t1
x forall t (p :: Nat) (q :: Nat).
Num t =>
Vec p t -> Vec q t -> Mat p q t
`outerProduct` Vec q t1
y
eval (GLGenExpr ExprID
_ (Transpose GLExpr d (Mat p q t1)
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Mat p q t1)
x forall a b. (a -> b) -> a -> b
$ \Mat p q t1
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
transpose Mat p q t1
x
eval (GLGenExpr ExprID
_ (Determinant GLExpr d (Mat p p Float)
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Mat p p Float)
x forall a b. (a -> b) -> a -> b
$ \Mat p p Float
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t (p :: Nat). (Fractional t, Ord t) => Mat p p t -> t
determinant Mat p p Float
x
eval (GLGenExpr ExprID
_ (Inverse GLExpr d (Mat p p Float)
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Mat p p Float)
x forall a b. (a -> b) -> a -> b
$ \Mat p p Float
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall t (p :: Nat). (Fractional t, Eq t) => Mat p p t -> Mat p p t
inverse Mat p p Float
x

eval (GLGenExpr ExprID
_ (LessThan GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y forall a b. (a -> b) -> a -> b
$ \Vec n t1
x Vec n t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Ord a => a -> a -> Bool
(<) Vec n t1
x Vec n t1
y
eval (GLGenExpr ExprID
_ (LessThanEqual GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y forall a b. (a -> b) -> a -> b
$ \Vec n t1
x Vec n t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Ord a => a -> a -> Bool
(<=) Vec n t1
x Vec n t1
y
eval (GLGenExpr ExprID
_ (GreaterThan GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y forall a b. (a -> b) -> a -> b
$ \Vec n t1
x Vec n t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Ord a => a -> a -> Bool
(>) Vec n t1
x Vec n t1
y
eval (GLGenExpr ExprID
_ (GreaterThanEqual GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y forall a b. (a -> b) -> a -> b
$ \Vec n t1
x Vec n t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Ord a => a -> a -> Bool
(>=) Vec n t1
x Vec n t1
y
eval (GLGenExpr ExprID
_ (Equal GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y forall a b. (a -> b) -> a -> b
$ \Vec n t1
x Vec n t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Eq a => a -> a -> Bool
(==) Vec n t1
x Vec n t1
y
eval (GLGenExpr ExprID
_ (NotEqual GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y)) = forall {a :: * -> *} {d :: GLDomain} {t} {t} {b}.
Monad a =>
GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d (Vec n t1)
x GLExpr d (Vec n t1)
y forall a b. (a -> b) -> a -> b
$ \Vec n t1
x Vec n t1
y -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Eq a => a -> a -> Bool
(/=) Vec n t1
x Vec n t1
y
eval (GLGenExpr ExprID
_ (Any GLExpr d (Vec n Bool)
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Vec n Bool)
x forall a b. (a -> b) -> a -> b
$ \Vec n Bool
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall a. Bits a => a -> a -> a
(.|.) Bool
False Vec n Bool
x
eval (GLGenExpr ExprID
_ (All GLExpr d (Vec n Bool)
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Vec n Bool)
x forall a b. (a -> b) -> a -> b
$ \Vec n Bool
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall a. Bits a => a -> a -> a
(.&.) Bool
True Vec n Bool
x
eval (GLGenExpr ExprID
_ (Not GLExpr d (Mat n 1 Bool)
x)) = forall {a :: * -> *} {d :: GLDomain} {t} {b}.
Monad a =>
GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d (Mat n 1 Bool)
x forall a b. (a -> b) -> a -> b
$ \Mat n 1 Bool
x -> 
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Bits a => a -> a
complement Mat n 1 Bool
x


-- Helper functions

withEv1 :: GLExpr d t
-> (t -> StateT (EvalState d a) a b) -> StateT (EvalState d a) a b
withEv1 GLExpr d t
x t -> StateT (EvalState d a) a b
act = do { t
x <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
x; t -> StateT (EvalState d a) a b
act t
x }
withEv2 :: GLExpr d t
-> GLExpr d t
-> (t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv2 GLExpr d t
x GLExpr d t
y t -> t -> StateT (EvalState d a) a b
act = do { t
x <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
x; t
y <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
y; t -> t -> StateT (EvalState d a) a b
act t
x t
y }
withEv3 :: GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv3 GLExpr d t
x GLExpr d t
y GLExpr d t
z t -> t -> t -> StateT (EvalState d a) a b
act = do { t
x <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
x; t
y <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
y; t
z <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
z; t -> t -> t -> StateT (EvalState d a) a b
act t
x t
y t
z }
withEv4 :: GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv4 GLExpr d t
x GLExpr d t
y GLExpr d t
z GLExpr d t
w t -> t -> t -> t -> StateT (EvalState d a) a b
act = do { t
x <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
x; t
y <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
y; t
z <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
z; t
w <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
w; t -> t -> t -> t -> StateT (EvalState d a) a b
act t
x t
y t
z t
w }
withEv5 :: GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv5 GLExpr d t
x GLExpr d t
y GLExpr d t
z GLExpr d t
w GLExpr d t
u t -> t -> t -> t -> t -> StateT (EvalState d a) a b
act = do { t
x <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
x; t
y <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
y; t
z <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
z; t
w <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
w; t
u <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
u; t -> t -> t -> t -> t -> StateT (EvalState d a) a b
act t
x t
y t
z t
w t
u }
withEv6 :: GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> GLExpr d t
-> (t -> t -> t -> t -> t -> t -> StateT (EvalState d a) a b)
-> StateT (EvalState d a) a b
withEv6 GLExpr d t
x GLExpr d t
y GLExpr d t
z GLExpr d t
w GLExpr d t
u GLExpr d t
v t -> t -> t -> t -> t -> t -> StateT (EvalState d a) a b
act = do { t
x <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
x; t
y <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
y; t
z <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
z; t
w <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
w; t
u <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
u; t
v <- forall (a :: * -> *) (d :: GLDomain) t.
Monad a =>
GLExpr d t -> StateT (EvalState d a) a t
cachedEval GLExpr d t
v; t -> t -> t -> t -> t -> t -> StateT (EvalState d a) a b
act t
x t
y t
z t
w t
u t
v }

tr :: Mat p q t -> Mat q p t
tr = forall {p :: Nat} {q :: Nat} {t}. Mat p q t -> Mat q p t
transpose

coordToIndex :: GLCoord m -> (Int, Int)
coordToIndex :: forall (m :: Nat). GLCoord m -> (Int, Int)
coordToIndex GLCoord m
CoordX = (Int
0, Int
0)
coordToIndex GLCoord m
CoordY = (Int
1, Int
0)
coordToIndex GLCoord m
CoordZ = (Int
2, Int
0)
coordToIndex GLCoord m
CoordW = (Int
3, Int
0)

colToIndex :: GLCol m -> Int
colToIndex :: forall (m :: Nat). GLCol m -> Int
colToIndex GLCol m
Col0 = Int
0
colToIndex GLCol m
Col1 = Int
1
colToIndex GLCol m
Col2 = Int
2
colToIndex GLCol m
Col3 = Int
3