module Mischief.Materials.Time where

import Mischief.Materials
import Mischief.Render.Material.Definition
import Prelude ()
import Prelude qualified

data TimeMaterial

newtype TimeData f = TimeData (Field f Float)
  deriving stock ((forall x. TimeData f -> Rep (TimeData f) x)
-> (forall x. Rep (TimeData f) x -> TimeData f)
-> Generic (TimeData f)
forall x. Rep (TimeData f) x -> TimeData f
forall x. TimeData f -> Rep (TimeData f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall f x. Rep (TimeData f) x -> TimeData f
forall f x. TimeData f -> Rep (TimeData f) x
$cfrom :: forall f x. TimeData f -> Rep (TimeData f) x
from :: forall x. TimeData f -> Rep (TimeData f) x
$cto :: forall f x. Rep (TimeData f) x -> TimeData f
to :: forall x. Rep (TimeData f) x -> TimeData f
Generic)
  deriving anyclass (Int
[(Text, Text)]
Integer -> TimeData GPU
TimeData CPU -> Ptr Word8 -> IO Int
(Integer -> TimeData GPU)
-> [(Text, Text)]
-> Int
-> (TimeData CPU -> Ptr Word8 -> IO Int)
-> Bufferable TimeData
forall (a :: * -> *).
(Integer -> a GPU)
-> [(Text, Text)]
-> Int
-> (a CPU -> Ptr Word8 -> IO Int)
-> Bufferable a
$cdummyBuffer :: Integer -> TimeData GPU
dummyBuffer :: Integer -> TimeData GPU
$cgetFields :: [(Text, Text)]
getFields :: [(Text, Text)]
$cgetSize :: Int
getSize :: Int
$cputBytes :: TimeData CPU -> Ptr Word8 -> IO Int
putBytes :: TimeData CPU -> Ptr Word8 -> IO Int
Bufferable)

newtype Bindings f = Bindings {forall f. Bindings f -> Uniform f (TimeData f)
x :: Uniform f (TimeData f)}
  deriving stock ((forall x. Bindings f -> Rep (Bindings f) x)
-> (forall x. Rep (Bindings f) x -> Bindings f)
-> Generic (Bindings f)
forall x. Rep (Bindings f) x -> Bindings f
forall x. Bindings f -> Rep (Bindings f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall f x. Rep (Bindings f) x -> Bindings f
forall f x. Bindings f -> Rep (Bindings f) x
$cfrom :: forall f x. Bindings f -> Rep (Bindings f) x
from :: forall x. Bindings f -> Rep (Bindings f) x
$cto :: forall f x. Rep (Bindings f) x -> Bindings f
to :: forall x. Rep (Bindings f) x -> Bindings f
Generic)
  deriving anyclass (Typeable Bindings
Typeable Bindings =>
(Natural -> Proxy (Bindings Internal) -> (Bindings, Natural))
-> (Natural
    -> Proxy (Bindings Internal)
    -> ([WGPUBindGroupLayoutEntry], Natural))
-> (Natural -> Bindings CPU -> ([WGPUBindGroupEntry], Natural))
-> (Natural -> (Bindings GPU, Natural))
-> Bindable Bindings
Natural -> (Bindings GPU, Natural)
Natural
-> Proxy (Bindings Internal)
-> ([WGPUBindGroupLayoutEntry], Natural)
Natural -> Proxy (Bindings Internal) -> (Bindings, Natural)
Natural -> Bindings CPU -> ([WGPUBindGroupEntry], Natural)
forall (a :: * -> *).
Typeable a =>
(Natural -> Proxy (a Internal) -> (Bindings, Natural))
-> (Natural
    -> Proxy (a Internal) -> ([WGPUBindGroupLayoutEntry], Natural))
-> (Natural -> a CPU -> ([WGPUBindGroupEntry], Natural))
-> (Natural -> (a GPU, Natural))
-> Bindable a
$ccollectBindings :: Natural -> Proxy (Bindings Internal) -> (Bindings, Natural)
collectBindings :: Natural -> Proxy (Bindings Internal) -> (Bindings, Natural)
$ccollectLayouts :: Natural
-> Proxy (Bindings Internal)
-> ([WGPUBindGroupLayoutEntry], Natural)
collectLayouts :: Natural
-> Proxy (Bindings Internal)
-> ([WGPUBindGroupLayoutEntry], Natural)
$ccollectEntries :: Natural -> Bindings CPU -> ([WGPUBindGroupEntry], Natural)
collectEntries :: Natural -> Bindings CPU -> ([WGPUBindGroupEntry], Natural)
$cdummyBinding :: Natural -> (Bindings GPU, Natural)
dummyBinding :: Natural -> (Bindings GPU, Natural)
Bindable)

instance Material TimeMaterial where
  type VI TimeMaterial = DefaultVI
  type VO TimeMaterial = DefaultVO

  type IsPhantom TimeMaterial = Prelude.True

  type B TimeMaterial = Bindings

  fetch :: FetchBindings (B TimeMaterial)
fetch =
    FetchBindings
      { camera :: CameraEntity -> Query System (Buffer TimeData)
camera = \CameraEntity
_ -> forall c (m :: * -> *) w.
(MonadSystem w m, Component c) =>
Query m c
qres @(Buffer TimeData),
        mesh :: CameraEntity -> Query System ()
mesh = \CameraEntity
_ -> () -> Query System ()
forall a. a -> Query System a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (),
        result :: Buffer TimeData -> () -> Bindings CPU
result = \Buffer TimeData
t ()
_ -> Uniform CPU (TimeData CPU) -> Bindings CPU
forall f. Uniform f (TimeData f) -> Bindings f
Bindings Buffer TimeData
Uniform CPU (TimeData CPU)
t
      }

getTime :: Shader TimeMaterial Float
getTime :: Shader TimeMaterial (Expr ('Primitive 'TFloat))
getTime = do
  Bindings (TimeData t) <- Shader TimeMaterial (B TimeMaterial GPU)
Shader TimeMaterial (Bindings GPU)
forall a. Material a => Shader a (B a GPU)
bindings
  pure t