packages feed

mischief-render-0.1.1.0: src/Mischief/Shader/Internal/State.hs

{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeAbstractions #-}
{-# OPTIONS_GHC -Wno-redundant-constraints #-}

module Mischief.Shader.Internal.State where

import Control.Monad.State
import Data.Data hiding (cast)
import Data.Map (Map)
import Data.Singletons (SingI, demote)
import Data.Text (Text)
import Data.Text qualified as T
import GHC.TypeLits (Nat, type (+))
import Mischief.Shader.Internal.Singletons
import Unsafe.Coerce (unsafeCoerce)
import Prelude hiding (cos, sin)

data ErasedValue where
  ErasedValue :: a -> ErasedValue

data ShaderState = ShaderState
  { counter :: VarIndex,
    ast :: Stmt,
    dict :: Map TypeRep ErasedValue
  }

newtype VarIndex = VarIndex Integer
  deriving newtype (Show, Num)

nameIndex :: VarIndex -> Text
nameIndex i = "v" <> T.pack (show i)

data Stmt where
  Concat :: Stmt -> Stmt -> Stmt
  Let :: VarIndex -> Expr a -> Stmt
  LetMut :: VarIndex -> Text -> Stmt
  Assign :: VarIndex -> Expr a -> Stmt
  Return :: Expr a -> Stmt
  Debug :: Text -> Stmt
  If :: Expr (Primitive TBool) -> Stmt
  Symbol :: Text -> Stmt
  Empty :: Stmt

data CustomType a = CustomType

instance Eq (CustomType a) where
  _ == _ = False

data Expr (a :: Types) where
  Function :: Text -> [Param] -> Expr a
  Add :: (SingI a) => Expr a -> Expr a -> Expr a
  Sub :: (SingI a) => Expr a -> Expr a -> Expr a
  Mult :: (SingI a) => Expr a -> Expr a -> Expr a
  Div :: (SingI a) => Expr a -> Expr a -> Expr a
  Neg :: (SingI a) => Expr a -> Expr a
  Abs :: (SingI a) => Expr a -> Expr a
  Signum :: (SingI a) => Expr a -> Expr a
  Cast :: (SingI a, SingI b) => Proxy b -> Expr a -> Expr b
  CastVec :: (SingI (VectorType n a), SingI (VectorType n b)) => Proxy (VectorType n b) -> Expr (VectorType n a) -> Expr (VectorType n b)
  ConstantInt :: Int -> Expr (Primitive TInt)
  ConstantFloat :: Float -> Expr (Primitive TFloat)
  ConstantUInt :: Int -> Expr (Primitive TUInt)
  ConstantArray :: forall (a' :: Types). (SingI a') => (Proxy a') -> [Expr a'] -> Expr (ArrayType a')
  ConstantVec :: forall (n :: Nat) (a' :: PrimitiveTypes). (PrintVecElements n a', SingI (VectorType n a')) => Proxy (VectorType n a') -> VecInit n a' -> Expr (VectorType n a')
  ConstantMat :: forall (n :: Nat) (m :: Nat). (PrintMatElements n m, SingI (MatrixType n m)) => Proxy (MatrixType n m) -> MatInit n m -> Expr (MatrixType n m)
  AccessField :: (SingI a) => Expr a -> Text -> Expr b
  Index :: (SingI (ArrayType a)) => Expr (ArrayType a) -> Expr (Primitive TUInt) -> Expr a
  Var :: (SingI a) => VarIndex -> Expr a
  BindingVar :: (SingI a) => Integer -> Expr a
  BuiltInVar :: (SingI a) => Text -> Expr a
  StructInit :: Text -> [Text] -> Expr a
  LocationVar :: (SingI a) => Integer -> Expr a
  VarCustom :: Text -> Expr a
  CustomOperator :: Text -> Expr a -> Expr b -> Expr c
  Void :: (SingI a) => Expr a
  AppendVecs :: forall (n :: Nat) (m :: Nat) a. (SingI a, PrintVecElements (n + m) a, SingI (VectorType (n + m) a)) => Proxy (VectorType (n + m) a) -> Expr (VectorType n a) -> Expr (VectorType m a) -> Expr (VectorType (n + m) a)
  ExtendVec :: forall (n :: Nat) a. (SingI a, PrintVecElements (n + 1) a, SingI (VectorType (n + 1) a)) => Proxy (VectorType (n + 1) a) -> Expr (VectorType n a) -> Expr (Primitive a) -> Expr (VectorType (n + 1) a)
  ConstantBool :: Bool -> Expr (Primitive TBool)

data Param where
  Param :: (SingI a) => Expr a -> Param

type family VectorOrSingleOf a where
  VectorOrSingleOf (VectorType n a) = a
  VectorOrSingleOf (Primitive a) = a

type family NotBool a where
  NotBool TBool = False
  NotBool a = True

instance (SingI a, NotBool a ~ True) => Num (Expr (Primitive a)) where
  (+) = Add
  (*) = Mult
  abs = Abs
  signum = Signum
  fromInteger i =
    let t = demote @a
     in case t of
          TInt -> unsafeCoerce $ ConstantInt (fromInteger i)
          TFloat -> unsafeCoerce $ ConstantFloat (fromInteger i)
          TUInt -> unsafeCoerce $ ConstantUInt (fromInteger i)
          _ -> error "This should be unreachable"
  negate = Neg

instance Fractional (Expr (Primitive TFloat)) where
  fromRational = ConstantFloat . fromRational
  recip = Div 1
  (/) = Div

type family VecInit (n :: Nat) (a :: PrimitiveTypes) where
  VecInit 2 a = (Expr (Primitive a), Expr (Primitive a))
  VecInit 3 a = (Expr (Primitive a), Expr (Primitive a), Expr (Primitive a))
  VecInit 4 a = (Expr (Primitive a), Expr (Primitive a), Expr (Primitive a), Expr (Primitive a))

class PrintVecElements (n :: Nat) (a :: PrimitiveTypes) where
  printVecElements :: VecInit n a -> Text

instance PrintVecElements 2 a where
  printVecElements (a, b) = exprToWGSL a <> ", " <> exprToWGSL b

instance PrintVecElements 3 a where
  printVecElements (a, b, c) = exprToWGSL a <> ", " <> exprToWGSL b <> ", " <> exprToWGSL c

instance PrintVecElements 4 a where
  printVecElements (a, b, c, d) = exprToWGSL a <> ", " <> exprToWGSL b <> ", " <> exprToWGSL c <> ", " <> exprToWGSL d

type family ArrayInit (n :: Nat) a where
  ArrayInit 2 a = (Expr a, Expr a)
  ArrayInit 3 a = (Expr a, Expr a, Expr a)
  ArrayInit 4 a = (Expr a, Expr a, Expr a, Expr a)
  ArrayInit 5 a = (Expr a, Expr a, Expr a, Expr a, Expr a)
  ArrayInit 6 a = (Expr a, Expr a, Expr a, Expr a, Expr a, Expr a)

class PrintArrayElements (n :: Nat) (a :: Types) where
  printArrayElements :: ArrayInit n a -> Text

instance PrintArrayElements 2 a where
  printArrayElements (a, b) = exprToWGSL a <> ", " <> exprToWGSL b

instance PrintArrayElements 3 a where
  printArrayElements (a, b, c) = exprToWGSL a <> ", " <> exprToWGSL b <> ", " <> exprToWGSL c

instance PrintArrayElements 4 a where
  printArrayElements (a, b, c, d) = exprToWGSL a <> ", " <> exprToWGSL b <> ", " <> exprToWGSL c <> ", " <> exprToWGSL d

instance PrintArrayElements 5 a where
  printArrayElements (a, b, c, d, e) = exprToWGSL a <> ", " <> exprToWGSL b <> ", " <> exprToWGSL c <> ", " <> exprToWGSL d <> ", " <> exprToWGSL e

instance PrintArrayElements 6 a where
  printArrayElements (a, b, c, d, e, f) = exprToWGSL a <> ", " <> exprToWGSL b <> ", " <> exprToWGSL c <> ", " <> exprToWGSL d <> ", " <> exprToWGSL e <> ", " <> exprToWGSL f

type family MatInit (n :: Nat) (m :: Nat) where
  MatInit 2 a = (Expr (VectorType a TFloat), Expr (VectorType a TFloat))
  MatInit 3 a = (Expr (VectorType a TFloat), Expr (VectorType a TFloat), Expr (VectorType a TFloat))
  MatInit 4 a = (Expr (VectorType a TFloat), Expr (VectorType a TFloat), Expr (VectorType a TFloat), Expr (VectorType a TFloat))

class PrintMatElements (n :: Nat) (m :: Nat) where
  printMatElements :: MatInit n m -> Text

instance PrintMatElements 2 n where
  printMatElements (a, b) =
    exprToWGSL a <> ", " <> exprToWGSL b

instance PrintMatElements 3 n where
  printMatElements (a, b, c) =
    exprToWGSL a <> ", " <> exprToWGSL b <> ", " <> exprToWGSL c

instance PrintMatElements 4 n where
  printMatElements (a, b, c, d) =
    exprToWGSL a <> ", " <> exprToWGSL b <> ", " <> exprToWGSL c <> ", " <> exprToWGSL d

showArgs :: [Param] -> Text
showArgs [] = ""
showArgs [Param x] = exprToWGSL x
showArgs ((Param x) : xs) = exprToWGSL x <> ", " <> showArgs xs

exprToWGSL :: Expr a -> Text
exprToWGSL (Function t x) = t <> "(" <> showArgs x <> ")"
exprToWGSL (Add a b) = "(" <> exprToWGSL a <> " + " <> exprToWGSL b <> ")"
exprToWGSL (Mult a b) = "(" <> exprToWGSL a <> " * " <> exprToWGSL b <> ")"
exprToWGSL (Sub a b) = "(" <> exprToWGSL a <> " - " <> exprToWGSL b <> ")"
exprToWGSL (Div a b) = "(" <> exprToWGSL a <> " / " <> exprToWGSL b <> ")"
exprToWGSL (Neg a) = "(-" <> exprToWGSL a <> ")"
exprToWGSL (Abs a) = exprToWGSL (Function "abs" [Param a])
exprToWGSL (Signum a) = exprToWGSL (Function "sign" [Param a])
exprToWGSL (Cast (_ :: Proxy b) (a :: Expr a)) =
  let aType = demote @a
      bType = demote @b
   in if aType == bType
        then exprToWGSL a
        else case bType of
          Primitive TInt -> "i32(" <> exprToWGSL a <> ")"
          Primitive TFloat -> "f32(" <> exprToWGSL a <> ")"
          Primitive TUInt -> "u32(" <> exprToWGSL a <> ")"
          _ -> undefined
exprToWGSL (CastVec (_ :: Proxy b) (a :: Expr a)) =
  let aType = demote @a
      bType = demote @b
   in if aType == bType
        then exprToWGSL a
        else case bType of
          VectorType 2 TInt -> "vec2<i32>(" <> exprToWGSL a <> ")"
          VectorType 2 TFloat -> "vec2<f32>(" <> exprToWGSL a <> ")"
          VectorType 2 TUInt -> "vec2<u32>(" <> exprToWGSL a <> ")"
          VectorType 3 TInt -> "vec3<i32>(" <> exprToWGSL a <> ")"
          VectorType 3 TFloat -> "vec3<f32>(" <> exprToWGSL a <> ")"
          VectorType 3 TUInt -> "vec3<u32>(" <> exprToWGSL a <> ")"
          VectorType 4 TInt -> "vec4<i32>(" <> exprToWGSL a <> ")"
          VectorType 4 TFloat -> "vec4<f32>(" <> exprToWGSL a <> ")"
          VectorType 4 TUInt -> "vec4<u32>(" <> exprToWGSL a <> ")"
          _ -> undefined
exprToWGSL (ConstantArray (_ :: Proxy a) x) =
  let element = typeToWGSL' (demote @a)
   in "array<" <> element <> ", " <> T.show (length x) <> ">(" <> T.intercalate ", " (map exprToWGSL x) <> ")"
exprToWGSL (ConstantVec @n @a' (_ :: Proxy a) x) =
  let elements = printVecElements @n @a' x
   in case demote @a of
        VectorType 2 TInt -> "vec2<i32>(" <> elements <> ")"
        VectorType 2 TFloat -> "vec2<f32>(" <> elements <> ")"
        VectorType 2 TUInt -> "vec2<u32>(" <> elements <> ")"
        VectorType 3 TInt -> "vec3<i32>(" <> elements <> ")"
        VectorType 3 TFloat -> "vec3<f32>(" <> elements <> ")"
        VectorType 3 TUInt -> "vec3<u32>(" <> elements <> ")"
        VectorType 4 TInt -> "vec4<i32>(" <> elements <> ")"
        VectorType 4 TFloat -> "vec4<f32>(" <> elements <> ")"
        VectorType 4 TUInt -> "vec4<u32>(" <> elements <> ")"
        _ -> undefined
exprToWGSL (ConstantMat @n @m (_ :: Proxy a) x) =
  let elements = printMatElements @n @m x
   in case demote @a of
        MatrixType 2 2 -> "mat2x2<f32>(" <> elements <> ")"
        MatrixType 3 2 -> "mat2x3<f32>(" <> elements <> ")"
        MatrixType 4 2 -> "mat2x4<f32>(" <> elements <> ")"
        MatrixType 2 3 -> "mat3x2<f32>(" <> elements <> ")"
        MatrixType 3 3 -> "mat3x3<f32>(" <> elements <> ")"
        MatrixType 4 3 -> "mat3x4<f32>(" <> elements <> ")"
        MatrixType 2 4 -> "mat4x2<f32>(" <> elements <> ")"
        MatrixType 3 4 -> "mat4x3<f32>(" <> elements <> ")"
        MatrixType 4 4 -> "mat4x4<f32>(" <> elements <> ")"
        _ -> undefined
exprToWGSL (ConstantInt x) = T.pack $ show x <> "i"
exprToWGSL (ConstantFloat x) = T.pack $ show x <> "f"
exprToWGSL (ConstantUInt x) = T.pack $ show x <> "u"
exprToWGSL (Var x) = nameIndex x
exprToWGSL (BindingVar x) = "b" <> T.pack (show x)
exprToWGSL Void = ""
exprToWGSL (AccessField x f) = exprToWGSL x <> "." <> f
exprToWGSL (Index a i) = exprToWGSL a <> "[" <> exprToWGSL i <> "]"
exprToWGSL (BuiltInVar x) = "input." <> x
exprToWGSL (LocationVar x) = "input.l" <> T.pack (show x)
exprToWGSL (StructInit "" [p]) = p
exprToWGSL (StructInit name params) = name <> "(" <> T.intercalate "," params <> ")"
exprToWGSL (CustomOperator op a b) = "(" <> exprToWGSL a <> " " <> op <> " " <> exprToWGSL b <> ")"
exprToWGSL (VarCustom t) = t
exprToWGSL (AppendVecs (_ :: Proxy v) a b) = case demote @v of
  VectorType 2 TInt -> "vec2<i32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 2 TFloat -> "vec2<f32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 2 TUInt -> "vec2<u32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 3 TInt -> "vec3<i32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 3 TFloat -> "vec3<f32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 3 TUInt -> "vec3<u32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 4 TInt -> "vec4<i32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 4 TFloat -> "vec4<f32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 4 TUInt -> "vec4<u32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  _ -> undefined
exprToWGSL (ExtendVec (_ :: Proxy v) a b) = case demote @v of
  VectorType 2 TInt -> "vec2<i32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 2 TFloat -> "vec2<f32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 2 TUInt -> "vec2<u32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 3 TInt -> "vec3<i32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 3 TFloat -> "vec3<f32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 3 TUInt -> "vec3<u32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 4 TInt -> "vec4<i32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 4 TFloat -> "vec4<f32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  VectorType 4 TUInt -> "vec4<u32>(" <> exprToWGSL a <> "," <> exprToWGSL b <> ")"
  _ -> undefined
exprToWGSL (ConstantBool b) = if b then "true" else "false"

stmtToWGSL :: Stmt -> Text
stmtToWGSL Empty = ""
stmtToWGSL (Concat Empty a) = stmtToWGSL a
stmtToWGSL (Concat a b) = stmtToWGSL a <> "\n" <> stmtToWGSL b
stmtToWGSL (Let a b) = "  let " <> nameIndex a <> " = " <> exprToWGSL b <> ";"
stmtToWGSL (LetMut a t) = "  var " <> nameIndex a <> " : " <> t <> ";"
stmtToWGSL (Assign a b) = nameIndex a <> " = " <> exprToWGSL b <> ";"
stmtToWGSL (Return a) = "  return " <> exprToWGSL a <> ";"
stmtToWGSL (Debug t) = "  //" <> t
stmtToWGSL (If bool) = "  if " <> exprToWGSL bool
stmtToWGSL (Symbol a) = a

-- stmtToWGSL (VLet a b) = "  var " <> nameIndex a <> " = " <> exprToWGSL b <> ";"

newtype Shader m a = Shader (State ShaderState a) deriving newtype (Functor, Applicative, Monad, MonadState ShaderState)

typeToWGSL :: forall (a :: Types). (SingI a) => Expr a -> Text
typeToWGSL _ = typeToWGSL' (demote @a)

typeToWGSL' :: Types -> Text
typeToWGSL' a = case a of
  Primitive TInt -> "i32"
  Primitive TFloat -> "f32"
  Primitive TUInt -> "u32"
  -- ArrayType n t -> "array<" <> typeToWGSL' t <> ", " <> T.pack (show n) <> ">"
  VectorType 2 TFloat -> "vec2<f32>"
  VectorType 2 TInt -> "vec2<i32>"
  VectorType 2 TUInt -> "vec2<u32>"
  VectorType 3 TFloat -> "vec3<f32>"
  VectorType 3 TInt -> "vec3<i32>"
  VectorType 3 TUInt -> "vec3<u32>"
  VectorType 4 TFloat -> "vec4<f32>"
  VectorType 4 TInt -> "vec4<i32>"
  VectorType 4 TUInt -> "vec4<u32>"
  MatrixType 2 2 -> "mat2x2<f32>"
  MatrixType 2 3 -> "mat2x3<f32>"
  MatrixType 2 4 -> "mat2x4<f32>"
  MatrixType 3 2 -> "mat3x2<f32>"
  MatrixType 3 3 -> "mat3x3<f32>"
  MatrixType 3 4 -> "mat3x4<f32>"
  MatrixType 4 2 -> "mat4x2<f32>"
  MatrixType 4 3 -> "mat4x3<f32>"
  MatrixType 4 4 -> "mat4x4<f32>"
  _ -> undefined

addStmt :: Stmt -> Shader m ()
addStmt stmt = do
  state <- get
  put state {ast = Concat state.ast stmt}

newVarIndex :: Shader m VarIndex
newVarIndex = do
  ShaderState {counter, ast, dict} <- get
  put (ShaderState {counter = counter + 1, ast, dict})
  pure counter

var :: (SingI a) => Expr a -> Shader m (Expr a)
var expr = do
  index <- newVarIndex
  addStmt (Let index expr)
  pure $ Var index

-- | If the condition is true, it will return the result of the first branch, otherwise the second.
--
-- If a branch has logic which isn't common to both branches, you should put as much of it as possible in the branch itself, as anything outside the 'select' will always run no matter the branch.
select :: forall a m. (SingI a) => Expr (Primitive TBool) -> Shader m (Expr a) -> Shader m (Expr a) -> Shader m (Expr a)
select bool (Shader a) (Shader b) = do
  index <- newVarIndex
  addStmt (LetMut index (typeToWGSL (undefined :: Expr a)))
  addStmt (If bool)
  addStmt (Symbol " { ")

  s1 <- get
  let (r1, s2) = runState a s1
  let ast2 = Concat (Concat s2.ast $ Assign index r1) $ Symbol " }\n else {\n"
  let (r2, s3) = runState b s2 {ast = ast2}
  let ast3 = Concat (Concat s3.ast $ Assign index r2) $ Symbol " }\n"

  put s3 {ast = ast3}
  pure $ Var index

comment :: Text -> Shader m ()
comment t = addStmt (Debug t)

data CPU

data GPU

data Internal