{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE OverloadedLists #-}

{- |
  All the provided render passes and pipelines packaged and delivered.
-}

module Render.Basic where

import RIO

import Control.Monad.Trans.Resource (ResourceT)
import Data.Kind (Type)
import Data.Tagged (Tagged(..))
import RIO.FilePath ((</>), (<.>))
import RIO.Vector.Partial as Vector (headM)
import Vulkan.Core10 qualified as Vk
import Vulkan.Zero (Zero(..))

-- keid-core

import Engine.Stage.Component qualified as Stage
import Engine.Types (StageRIO)
import Engine.Types qualified as Engine
import Engine.Vulkan.Pipeline qualified as Pipeline
import Engine.Vulkan.Pipeline.External (type (^))
import Engine.Vulkan.Pipeline.External qualified as External
import Engine.Vulkan.Pipeline.Graphics qualified as Graphics
import Engine.Vulkan.Shader qualified as Shader
import Engine.Vulkan.Swapchain qualified as Swapchain
import Engine.Vulkan.Types (DsLayoutBindings, HasSwapchain, HasVulkan, RenderPass(..))

-- keid-render-basic

import Render.Debug.Pipeline qualified as Debug
import Render.DepthOnly.Pipeline qualified as DepthOnly
import Render.DescSets.Set0 (Scene)
import Render.DescSets.Set0 qualified as Scene
import Render.DescSets.Sun (Sun)
import Render.DescSets.Sun qualified as Sun
import Render.Font.EvanwSdf.Pipeline qualified as EvanwSdf
import Render.ForwardMsaa (ForwardMsaa)
import Render.ForwardMsaa qualified as ForwardMsaa
import Render.Lit.Colored.Pipeline qualified as LitColored
import Render.Lit.Material.Pipeline qualified as LitMaterial
import Render.Lit.Textured.Pipeline qualified as LitTextured
import Render.Samplers qualified as Samplers
import Render.ShadowMap.Pipeline qualified as ShadowPipe
import Render.ShadowMap.RenderPass (ShadowMap)
import Render.ShadowMap.RenderPass qualified as ShadowPass
import Render.Skybox.Pipeline qualified as Skybox
import Render.Unlit.Colored.Pipeline qualified as UnlitColored
import Render.Unlit.Line2d.Pipeline qualified as UnlitLine2d
import Render.Unlit.Sprite.Pipeline qualified as UnlitSprite
import Render.Unlit.Textured.Pipeline qualified as UnlitTextured
import Render.Unlit.TileMap.Pipeline qualified as UnlitTileMap

type Stage = Engine.Stage RenderPasses Pipelines
type Frame = Engine.Frame RenderPasses Pipelines
type StageFrameRIO r s a = Engine.StageFrameRIO RenderPasses Pipelines r s a

-- |  Basic rendering component without any extensions.
type Rendering = Stage.Rendering RenderPasses Pipelines

-- |  Basic rendering component without any extensions and resources.
rendering_ :: Rendering st
rendering_ :: forall st. Rendering st
rendering_ = Stage.Rendering
  { $sel:rAllocateRP:Rendering :: SwapchainResources -> ResourceT (StageRIO st) RenderPasses
rAllocateRP = forall swapchain env.
(HasSwapchain swapchain, HasLogFunc env, HasVulkan env) =>
swapchain -> ResourceT (RIO env) RenderPasses
allocate_
  , $sel:rAllocateP:Rendering :: SwapchainResources
-> RenderPasses -> ResourceT (StageRIO st) Pipelines
rAllocateP = forall swapchain st.
HasSwapchain swapchain =>
swapchain -> RenderPasses -> ResourceT (StageRIO st) Pipelines
allocatePipelines_
  }

data RenderPasses = RenderPasses
  { RenderPasses -> ForwardMsaa
rpForwardMsaa :: ForwardMsaa
  , RenderPasses -> ShadowMap
rpShadowPass  :: ShadowMap
  }

instance RenderPass RenderPasses where
  updateRenderpass :: forall env swapchain.
(HasLogFunc env, HasSwapchain swapchain, HasVulkan env,
 MonadResource (RIO env)) =>
swapchain -> RenderPasses -> RIO env RenderPasses
updateRenderpass swapchain
swapchain RenderPasses{ForwardMsaa
ShadowMap
rpShadowPass :: ShadowMap
rpForwardMsaa :: ForwardMsaa
$sel:rpShadowPass:RenderPasses :: RenderPasses -> ShadowMap
$sel:rpForwardMsaa:RenderPasses :: RenderPasses -> ForwardMsaa
..} = ForwardMsaa -> ShadowMap -> RenderPasses
RenderPasses
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) env swapchain.
(MonadResource m, MonadVulkan env m, HasLogFunc env,
 HasSwapchain swapchain) =>
swapchain -> ForwardMsaa -> m ForwardMsaa
ForwardMsaa.updateMsaa swapchain
swapchain ForwardMsaa
rpForwardMsaa
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure ShadowMap
rpShadowPass -- XXX: not a screen pass

  refcountRenderpass :: forall env. MonadResource (RIO env) => RenderPasses -> RIO env ()
refcountRenderpass RenderPasses{ForwardMsaa
ShadowMap
rpShadowPass :: ShadowMap
rpForwardMsaa :: ForwardMsaa
$sel:rpShadowPass:RenderPasses :: RenderPasses -> ShadowMap
$sel:rpForwardMsaa:RenderPasses :: RenderPasses -> ForwardMsaa
..} = do
    forall a env.
(RenderPass a, MonadResource (RIO env)) =>
a -> RIO env ()
refcountRenderpass ForwardMsaa
rpForwardMsaa
    forall a env.
(RenderPass a, MonadResource (RIO env)) =>
a -> RIO env ()
refcountRenderpass ShadowMap
rpShadowPass

data Settings = Settings
  { Settings -> Word32
sShadowSize   :: Word32
  , Settings -> Word32
sShadowLayers :: Word32
  }
  deriving (Settings -> Settings -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Settings -> Settings -> Bool
$c/= :: Settings -> Settings -> Bool
== :: Settings -> Settings -> Bool
$c== :: Settings -> Settings -> Bool
Eq, Int -> Settings -> ShowS
[Settings] -> ShowS
Settings -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Settings] -> ShowS
$cshowList :: [Settings] -> ShowS
show :: Settings -> String
$cshow :: Settings -> String
showsPrec :: Int -> Settings -> ShowS
$cshowsPrec :: Int -> Settings -> ShowS
Show)

instance Zero Settings where
  zero :: Settings
zero = Settings
    -- XXX: 1x1 placeholder image
    { $sel:sShadowSize:Settings :: Word32
sShadowSize   = Word32
1
    , $sel:sShadowLayers:Settings :: Word32
sShadowLayers = Word32
1
    }

allocate
  :: ( HasSwapchain swapchain
     , HasLogFunc env
     , HasVulkan env
     )
  => Settings
  -> swapchain
  -> ResourceT (RIO env) RenderPasses
allocate :: forall swapchain env.
(HasSwapchain swapchain, HasLogFunc env, HasVulkan env) =>
Settings -> swapchain -> ResourceT (RIO env) RenderPasses
allocate Settings{Word32
sShadowLayers :: Word32
sShadowSize :: Word32
$sel:sShadowLayers:Settings :: Settings -> Word32
$sel:sShadowSize:Settings :: Settings -> Word32
..} swapchain
swapchain = do
  ForwardMsaa
rpForwardMsaa <- forall (m :: * -> *) env swapchain.
(MonadResource m, MonadVulkan env m, HasLogFunc env,
 HasSwapchain swapchain) =>
swapchain -> m ForwardMsaa
ForwardMsaa.allocateMsaa swapchain
swapchain

  ShadowMap
rpShadowPass <- forall (m :: * -> *) env context.
(MonadResource m, MonadVulkan env m, HasLogFunc env,
 HasSwapchain context) =>
context -> Word32 -> Word32 -> m ShadowMap
ShadowPass.allocate
    swapchain
swapchain
    Word32
sShadowSize
    Word32
sShadowLayers

  pure RenderPasses{ForwardMsaa
ShadowMap
rpShadowPass :: ShadowMap
rpForwardMsaa :: ForwardMsaa
$sel:rpShadowPass:RenderPasses :: ShadowMap
$sel:rpForwardMsaa:RenderPasses :: ForwardMsaa
..}

allocate_
  :: ( HasSwapchain swapchain
     , HasLogFunc env
     , HasVulkan env
     )
  => swapchain
  -> ResourceT (RIO env) RenderPasses
allocate_ :: forall swapchain env.
(HasSwapchain swapchain, HasLogFunc env, HasVulkan env) =>
swapchain -> ResourceT (RIO env) RenderPasses
allocate_ = forall swapchain env.
(HasSwapchain swapchain, HasLogFunc env, HasVulkan env) =>
Settings -> swapchain -> ResourceT (RIO env) RenderPasses
allocate forall a. Zero a => a
zero

type Pipelines = PipelinesF Identity
type PipelineObservers = PipelinesF External.Observers
type PipelineWorkers = PipelinesF External.ConfigureGraphics

data PipelinesF (f :: Type -> Type) = Pipelines
  { forall (f :: * -> *). PipelinesF f -> SampleCountFlagBits
pMSAA       :: Vk.SampleCountFlagBits
  , forall (f :: * -> *). PipelinesF f -> Tagged Scene DsLayoutBindings
pSceneBinds :: Tagged Scene DsLayoutBindings
  , forall (f :: * -> *).
PipelinesF f -> Tagged '[Scene] DescriptorSetLayout
pSceneLayout :: Tagged '[Scene] Vk.DescriptorSetLayout

  , forall (f :: * -> *). PipelinesF f -> Tagged Sun DsLayoutBindings
pShadowBinds :: Tagged Sun DsLayoutBindings
  , forall (f :: * -> *).
PipelinesF f -> Tagged '[Sun] DescriptorSetLayout
pShadowLayout :: Tagged '[Sun] Vk.DescriptorSetLayout

  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pEvanwSdf :: f ^ EvanwSdf.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pSkybox   :: f ^ Skybox.Pipeline

  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pDebugUV      :: f ^ Debug.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pDebugTexture :: f ^ Debug.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pDebugShadow  :: f ^ Debug.Pipeline

  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pDepthOnly :: f ^ DepthOnly.Pipeline

  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitColored       :: f ^ LitColored.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitColoredBlend  :: f ^ LitColored.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitMaterial      :: f ^ LitMaterial.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitMaterialBlend :: f ^ LitMaterial.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitTextured      :: f ^ LitTextured.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitTexturedBlend :: f ^ LitTextured.Pipeline

  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pUnlitColored        :: f ^ UnlitColored.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pUnlitColoredNoDepth :: f ^ UnlitColored.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pUnlitTextured       :: f ^ UnlitTextured.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pUnlitTexturedBlend  :: f ^ UnlitTextured.Pipeline

  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLine2d        :: f ^ UnlitLine2d.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLine2dNoDepth :: f ^ UnlitLine2d.Pipeline

  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pSprite              :: f ^ UnlitSprite.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pSpriteOutline       :: f ^ UnlitSprite.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pTileMap             :: f ^ UnlitTileMap.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pTileMapBlend        :: f ^ UnlitTileMap.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pWireframe           :: f ^ UnlitColored.Pipeline
  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pWireframeNoDepth    :: f ^ UnlitColored.Pipeline

  , forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pShadowCast :: f ^ ShadowPipe.Pipeline
  }

allocatePipelines_
  :: HasSwapchain swapchain
  => swapchain
  -> RenderPasses
  -> ResourceT (StageRIO st) Pipelines
allocatePipelines_ :: forall swapchain st.
HasSwapchain swapchain =>
swapchain -> RenderPasses -> ResourceT (StageRIO st) Pipelines
allocatePipelines_ swapchain
swapchain RenderPasses
renderpasses = do
  Collection Sampler
samplers <- forall env (io :: * -> *).
MonadVulkan env io =>
("max anisotropy" ::: Float) -> ResourceT io (Collection Sampler)
Samplers.allocate (forall a. HasSwapchain a => a -> "max anisotropy" ::: Float
Swapchain.getAnisotropy swapchain
swapchain)

  forall st.
Tagged Scene DsLayoutBindings
-> SampleCountFlagBits
-> RenderPasses
-> ResourceT (StageRIO st) Pipelines
allocatePipelines
    (forall (samplers :: * -> *) (textures :: * -> *)
       (cubemaps :: * -> *) a b.
(Foldable samplers, Foldable textures, Foldable cubemaps) =>
samplers Sampler
-> textures a
-> cubemaps b
-> Word32
-> Tagged Scene DsLayoutBindings
Scene.mkBindings Collection Sampler
samplers forall a. Maybe a
Nothing forall a. Maybe a
Nothing Word32
0)
    (forall a. HasSwapchain a => a -> SampleCountFlagBits
Swapchain.getMultisample swapchain
swapchain)
    RenderPasses
renderpasses

allocatePipelines
  :: Tagged Scene DsLayoutBindings
  -> Vk.SampleCountFlagBits
  -> RenderPasses
  -> ResourceT (StageRIO st) Pipelines
allocatePipelines :: forall st.
Tagged Scene DsLayoutBindings
-> SampleCountFlagBits
-> RenderPasses
-> ResourceT (StageRIO st) Pipelines
allocatePipelines Tagged Scene DsLayoutBindings
pSceneBinds SampleCountFlagBits
pMSAA RenderPasses{ForwardMsaa
ShadowMap
rpShadowPass :: ShadowMap
rpForwardMsaa :: ForwardMsaa
$sel:rpShadowPass:RenderPasses :: RenderPasses -> ShadowMap
$sel:rpForwardMsaa:RenderPasses :: RenderPasses -> ForwardMsaa
..} = do
  Pipeline
pEvanwSdf <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
EvanwSdf.allocate SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pSkybox   <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
Skybox.allocate SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa

  Pipeline
pDebugUV      <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
Mode
-> SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
Debug.allocate Mode
Debug.UV         SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pDebugTexture <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
Mode
-> SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
Debug.allocate Mode
Debug.Texture    SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pDebugShadow  <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
Mode
-> SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
Debug.allocate (Word32 -> Mode
Debug.Shadow Word32
1) SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa

  Pipeline
pDepthOnly <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
DepthOnly.allocate SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa

  Pipeline
pLitColored       <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
LitColored.allocate SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pLitColoredBlend  <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
LitColored.allocateBlend SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pLitMaterial      <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
LitMaterial.allocate SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pLitMaterialBlend <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
LitMaterial.allocateBlend SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pLitTextured      <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
LitTextured.allocate SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pLitTexturedBlend <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
LitTextured.allocateBlend SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa

  Pipeline
pLine2d              <- forall env (m :: * -> *) renderpass.
(MonadVulkan env m, MonadResource m, HasRenderPass renderpass) =>
Bool
-> SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT m Pipeline
UnlitLine2d.allocate Bool
True SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pLine2dNoDepth       <- forall env (m :: * -> *) renderpass.
(MonadVulkan env m, MonadResource m, HasRenderPass renderpass) =>
Bool
-> SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT m Pipeline
UnlitLine2d.allocate Bool
False SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pSprite              <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Maybe ("max anisotropy" ::: Float)
-> Bool
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
UnlitSprite.allocate SampleCountFlagBits
pMSAA forall a. Maybe a
Nothing Bool
False Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pSpriteOutline       <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Maybe ("max anisotropy" ::: Float)
-> Bool
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
UnlitSprite.allocate SampleCountFlagBits
pMSAA forall a. Maybe a
Nothing Bool
True Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pTileMap             <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
UnlitTileMap.allocate SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pTileMapBlend        <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
UnlitTileMap.allocateBlend SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pUnlitColored        <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
Bool
-> SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
UnlitColored.allocate Bool
True SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pUnlitColoredNoDepth <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
Bool
-> SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
UnlitColored.allocate Bool
False SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pUnlitTextured       <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
UnlitTextured.allocate SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pUnlitTexturedBlend  <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
UnlitTextured.allocateBlend SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pWireframe           <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
Bool
-> SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
UnlitColored.allocateWireframe Bool
True SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa
  Pipeline
pWireframeNoDepth    <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
Bool
-> SampleCountFlagBits
-> Tagged Scene DsLayoutBindings
-> renderpass
-> ResourceT (RIO env) Pipeline
UnlitColored.allocateWireframe Bool
False SampleCountFlagBits
pMSAA Tagged Scene DsLayoutBindings
pSceneBinds ForwardMsaa
rpForwardMsaa

  let pShadowBinds :: Tagged Sun DsLayoutBindings
pShadowBinds = Tagged Sun DsLayoutBindings
Sun.set0
  Pipeline
pShadowCast <- forall env renderpass.
(HasVulkan env, HasRenderPass renderpass) =>
Tagged Sun DsLayoutBindings
-> renderpass -> Settings -> ResourceT (RIO env) Pipeline
ShadowPipe.allocate Tagged Sun DsLayoutBindings
pShadowBinds ShadowMap
rpShadowPass Settings
ShadowPipe.defaults

  let
    pSceneLayout :: Tagged '[Scene] DescriptorSetLayout
pSceneLayout =
      case forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> m a
Vector.headM (forall {k} (s :: k) b. Tagged s b -> b
unTagged forall a b. (a -> b) -> a -> b
$ forall (dsl :: [*]) vertices instances.
Pipeline dsl vertices instances
-> Tagged dsl (Vector DescriptorSetLayout)
Pipeline.pDescLayouts Pipeline
pLitColored) of
        Maybe DescriptorSetLayout
Nothing ->
          forall a. HasCallStack => String -> a
error String
"pLitColored has at least set0 in layout"
        Just DescriptorSetLayout
set0layout ->
          forall {k} (s :: k) b. b -> Tagged s b
Tagged DescriptorSetLayout
set0layout

    pShadowLayout :: Tagged '[Sun] DescriptorSetLayout
pShadowLayout =
      case forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> m a
Vector.headM (forall {k} (s :: k) b. Tagged s b -> b
unTagged forall a b. (a -> b) -> a -> b
$ forall (dsl :: [*]) vertices instances.
Pipeline dsl vertices instances
-> Tagged dsl (Vector DescriptorSetLayout)
Pipeline.pDescLayouts Pipeline
pShadowCast) of
        Maybe DescriptorSetLayout
Nothing ->
          forall a. HasCallStack => String -> a
error String
"pShadowCast has at least set0 in layout"
        Just DescriptorSetLayout
set0layout ->
          forall {k} (s :: k) b. b -> Tagged s b
Tagged DescriptorSetLayout
set0layout

  pure Pipelines{Tagged '[Sun] DescriptorSetLayout
Tagged '[Scene] DescriptorSetLayout
Tagged Sun DsLayoutBindings
Tagged Scene DsLayoutBindings
SampleCountFlagBits
Pipeline
Pipeline
Pipeline
Pipeline
Pipeline
Pipeline
Pipeline
Pipeline
Pipeline
Pipeline
Pipeline
Pipeline
Pipeline
pShadowLayout :: Tagged '[Sun] DescriptorSetLayout
pSceneLayout :: Tagged '[Scene] DescriptorSetLayout
pShadowCast :: Pipeline
pShadowBinds :: Tagged Sun DsLayoutBindings
pWireframeNoDepth :: Pipeline
pWireframe :: Pipeline
pUnlitTexturedBlend :: Pipeline
pUnlitTextured :: Pipeline
pUnlitColoredNoDepth :: Pipeline
pUnlitColored :: Pipeline
pTileMapBlend :: Pipeline
pTileMap :: Pipeline
pSpriteOutline :: Pipeline
pSprite :: Pipeline
pLine2dNoDepth :: Pipeline
pLine2d :: Pipeline
pLitTexturedBlend :: Pipeline
pLitTextured :: Pipeline
pLitMaterialBlend :: Pipeline
pLitMaterial :: Pipeline
pLitColoredBlend :: Pipeline
pLitColored :: Pipeline
pDepthOnly :: Pipeline
pDebugShadow :: Pipeline
pDebugTexture :: Pipeline
pDebugUV :: Pipeline
pSkybox :: Pipeline
pEvanwSdf :: Pipeline
pMSAA :: SampleCountFlagBits
pSceneBinds :: Tagged Scene DsLayoutBindings
$sel:pShadowCast:Pipelines :: Identity ^ Pipeline
$sel:pWireframeNoDepth:Pipelines :: Identity ^ Pipeline
$sel:pWireframe:Pipelines :: Identity ^ Pipeline
$sel:pTileMapBlend:Pipelines :: Identity ^ Pipeline
$sel:pTileMap:Pipelines :: Identity ^ Pipeline
$sel:pSpriteOutline:Pipelines :: Identity ^ Pipeline
$sel:pSprite:Pipelines :: Identity ^ Pipeline
$sel:pLine2dNoDepth:Pipelines :: Identity ^ Pipeline
$sel:pLine2d:Pipelines :: Identity ^ Pipeline
$sel:pUnlitTexturedBlend:Pipelines :: Identity ^ Pipeline
$sel:pUnlitTextured:Pipelines :: Identity ^ Pipeline
$sel:pUnlitColoredNoDepth:Pipelines :: Identity ^ Pipeline
$sel:pUnlitColored:Pipelines :: Identity ^ Pipeline
$sel:pLitTexturedBlend:Pipelines :: Identity ^ Pipeline
$sel:pLitTextured:Pipelines :: Identity ^ Pipeline
$sel:pLitMaterialBlend:Pipelines :: Identity ^ Pipeline
$sel:pLitMaterial:Pipelines :: Identity ^ Pipeline
$sel:pLitColoredBlend:Pipelines :: Identity ^ Pipeline
$sel:pLitColored:Pipelines :: Identity ^ Pipeline
$sel:pDepthOnly:Pipelines :: Identity ^ Pipeline
$sel:pDebugShadow:Pipelines :: Identity ^ Pipeline
$sel:pDebugTexture:Pipelines :: Identity ^ Pipeline
$sel:pDebugUV:Pipelines :: Identity ^ Pipeline
$sel:pSkybox:Pipelines :: Identity ^ Pipeline
$sel:pEvanwSdf:Pipelines :: Identity ^ Pipeline
$sel:pShadowLayout:Pipelines :: Tagged '[Sun] DescriptorSetLayout
$sel:pShadowBinds:Pipelines :: Tagged Sun DsLayoutBindings
$sel:pSceneLayout:Pipelines :: Tagged '[Scene] DescriptorSetLayout
$sel:pSceneBinds:Pipelines :: Tagged Scene DsLayoutBindings
$sel:pMSAA:Pipelines :: SampleCountFlagBits
..}

allocateWorkers
  :: Tagged Scene DsLayoutBindings
  -> Vk.SampleCountFlagBits
  -> RenderPasses
  -> ResourceT (StageRIO st) PipelineWorkers
allocateWorkers :: forall st.
Tagged Scene DsLayoutBindings
-> SampleCountFlagBits
-> RenderPasses
-> ResourceT (StageRIO st) PipelineWorkers
allocateWorkers Tagged Scene DsLayoutBindings
sceneBinds SampleCountFlagBits
pMSAA RenderPasses
renderPasses = do
  Pipelines
builtin <- forall st.
Tagged Scene DsLayoutBindings
-> SampleCountFlagBits
-> RenderPasses
-> ResourceT (StageRIO st) Pipelines
allocatePipelines Tagged Scene DsLayoutBindings
sceneBinds SampleCountFlagBits
pMSAA RenderPasses
renderPasses

  let
    evanwSdfFiles :: Stages (Maybe String)
evanwSdfFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"evanw-sdf" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"evanw-sdf" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process (Config '[Scene] () InstanceAttrs ())
evanwSdfWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"evanw-sdf" Stages (Maybe String)
evanwSdfFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
EvanwSdf.config Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    skyboxFiles :: Stages (Maybe String)
skyboxFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"skybox" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"skybox" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process (Config '[Scene] () () ())
skyboxWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"skybox" Stages (Maybe String)
skyboxFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
Skybox.config Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    debugFiles :: Stages (Maybe String)
debugFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"debug" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"debug" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process
  (Config
     '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) Mode)
debugUVWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"debug-uv" Stages (Maybe String)
debugFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Mode -> Tagged Scene DsLayoutBindings -> Config
Debug.config Mode
Debug.UV Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process
  (Config
     '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) Mode)
debugTextureWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"debug-texture" Stages (Maybe String)
debugFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Mode -> Tagged Scene DsLayoutBindings -> Config
Debug.config Mode
Debug.Texture Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process
  (Config
     '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) Mode)
debugShadowWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"debug-shadow" Stages (Maybe String)
debugFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Mode -> Tagged Scene DsLayoutBindings -> Config
Debug.config (Word32 -> Mode
Debug.Shadow Word32
1) Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    depthOnlyFiles :: Stages (Maybe String)
depthOnlyFiles = forall a. ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.vertexOnly
      (String
shaderDir String -> ShowS
</> String
"depth-only" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")

  Process (Config '[Scene] (Vertex Packed ()) Transform ())
depthOnlyWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"debug" Stages (Maybe String)
depthOnlyFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
DepthOnly.config Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    litColoredFiles :: Stages (Maybe String)
litColoredFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"lit-colored" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"lit-colored" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
litColoredWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"lit-colored" Stages (Maybe String)
litColoredFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
LitColored.config Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
litColoredBlendWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"lit-colored-blend" Stages (Maybe String)
litColoredFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
LitColored.configBlend Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    litMaterialFiles :: Stages (Maybe String)
litMaterialFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"lit-material" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"lit-material" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
litMaterialWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"lit-material" Stages (Maybe String)
litMaterialFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
LitMaterial.config Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
litMaterialBlendWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"lit-material-blend" Stages (Maybe String)
litMaterialFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
LitMaterial.configBlend Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    litTexturedFiles :: Stages (Maybe String)
litTexturedFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"lit-textured" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"lit-textured" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
litTexturedWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"lit-textured" Stages (Maybe String)
litTexturedFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
LitTextured.config Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
litTexturedBlendWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"lit-textured-blend" Stages (Maybe String)
litTexturedFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
LitTextured.configBlend Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    line2dFiles :: Stages (Maybe String)
line2dFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"line-2d" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"line-2d" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process (Config '[Scene] (Vertex Packed ()) InstanceAttrs ())
line2dWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"unlit-colored" Stages (Maybe String)
line2dFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Bool -> Tagged Scene DsLayoutBindings -> Config
UnlitLine2d.config Bool
True Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process (Config '[Scene] (Vertex Packed ()) InstanceAttrs ())
line2dNoDepthWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"unlit-colored-nodepth" Stages (Maybe String)
line2dFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Bool -> Tagged Scene DsLayoutBindings -> Config
UnlitLine2d.config Bool
False Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    unlitColoredFiles :: Stages (Maybe String)
unlitColoredFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"unlit-colored" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"unlit-colored" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
unlitColoredWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"unlit-colored" Stages (Maybe String)
unlitColoredFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Bool -> Tagged Scene DsLayoutBindings -> Config
UnlitColored.config Bool
True Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
unlitColoredNoDepthWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"unlit-colored-nodepth" Stages (Maybe String)
unlitColoredFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Bool -> Tagged Scene DsLayoutBindings -> Config
UnlitColored.config Bool
False Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    unlitTexturedFiles :: Stages (Maybe String)
unlitTexturedFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"unlit-textured" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"unlit-textured" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
unlitTexturedWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"unlit-textured" Stages (Maybe String)
unlitTexturedFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
UnlitTextured.config Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
unlitTexturedBlendWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"unlit-textured" Stages (Maybe String)
unlitTexturedFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
UnlitTextured.configBlend Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    spriteFiles :: Stages (Maybe String)
spriteFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"sprite" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"sprite" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process
  (Config
     '[Scene] () InstanceAttrs ("max anisotropy" ::: Float, Bool))
spriteWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"sprite" Stages (Maybe String)
spriteFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Maybe ("max anisotropy" ::: Float)
-> Bool -> Tagged Scene DsLayoutBindings -> Config
UnlitSprite.config forall a. Maybe a
Nothing Bool
False Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process
  (Config
     '[Scene] () InstanceAttrs ("max anisotropy" ::: Float, Bool))
spriteOutlineWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"sprite" Stages (Maybe String)
spriteFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Maybe ("max anisotropy" ::: Float)
-> Bool -> Tagged Scene DsLayoutBindings -> Config
UnlitSprite.config forall a. Maybe a
Nothing Bool
True Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    tileMapFiles :: Stages (Maybe String)
tileMapFiles =
      forall a.
("vert" ::: a) -> ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.basicStages
        (String
shaderDir String -> ShowS
</> String
"tilemap" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")
        (String
shaderDir String -> ShowS
</> String
"tilemap" String -> ShowS
<.> String
"frag" String -> ShowS
<.> String
"spv")

  Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
tileMapWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"tilemap" Stages (Maybe String)
tileMapFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
UnlitTileMap.config Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
tileMapBlendWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"tilemap" Stages (Maybe String)
tileMapFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Scene DsLayoutBindings -> Config
UnlitTileMap.configBlend Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
wireframeWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"wireframe" Stages (Maybe String)
unlitColoredFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Bool -> Tagged Scene DsLayoutBindings -> Config
UnlitColored.configWireframe Bool
True Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
wireframeNoDepthWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"wireframe-nodepth" Stages (Maybe String)
unlitColoredFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Bool -> Tagged Scene DsLayoutBindings -> Config
UnlitColored.configWireframe Bool
False Tagged Scene DsLayoutBindings
sceneBinds)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  let
    shadowCastFiles :: Stages (Maybe String)
shadowCastFiles =
      forall a. ("vert" ::: a) -> Stages (Maybe ("vert" ::: a))
Graphics.vertexOnly
        (String
shaderDir String -> ShowS
</> String
"shadow-cast" String -> ShowS
<.> String
"vert" String -> ShowS
<.> String
"spv")

  Process (Config '[Sun] (Vertex Packed ()) Transform ())
shadowCastWorker <-
    forall (m :: * -> *) env (stages :: * -> *) config.
(MonadResource m, MonadUnliftIO m, MonadReader env m,
 HasLogFunc env, StageInfo stages) =>
Text
-> stages (Maybe String)
-> ((stages (Maybe ByteString), Reflect stages) -> config)
-> m (Process config)
External.spawnReflect Text
"shadow-cast" Stages (Maybe String)
shadowCastFiles \(Stages (Maybe ByteString)
stageCode, Reflect Stages
reflect) ->
      (Tagged Sun DsLayoutBindings -> Settings -> Config
ShadowPipe.config (forall (f :: * -> *). PipelinesF f -> Tagged Sun DsLayoutBindings
pShadowBinds Pipelines
builtin) Settings
ShadowPipe.defaults)
        { $sel:cStages:Config :: Stages (Maybe ByteString)
Graphics.cStages = Stages (Maybe ByteString)
stageCode
        , $sel:cReflect:Config :: Maybe (Reflect Stages)
Graphics.cReflect = forall a. a -> Maybe a
Just Reflect Stages
reflect
        }

  pure Pipelines
builtin
    { $sel:pEvanwSdf:Pipelines :: ConfigureGraphics ^ Pipeline
pEvanwSdf = Process (Config '[Scene] () InstanceAttrs ())
evanwSdfWorker
    , $sel:pSkybox:Pipelines :: ConfigureGraphics ^ Pipeline
pSkybox = Process (Config '[Scene] () () ())
skyboxWorker
    , $sel:pDebugUV:Pipelines :: ConfigureGraphics ^ Pipeline
pDebugUV = Process
  (Config
     '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) Mode)
debugUVWorker
    , $sel:pDebugTexture:Pipelines :: ConfigureGraphics ^ Pipeline
pDebugTexture = Process
  (Config
     '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) Mode)
debugTextureWorker
    , $sel:pDebugShadow:Pipelines :: ConfigureGraphics ^ Pipeline
pDebugShadow = Process
  (Config
     '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) Mode)
debugShadowWorker
    , $sel:pDepthOnly:Pipelines :: ConfigureGraphics ^ Pipeline
pDepthOnly = Process (Config '[Scene] (Vertex Packed ()) Transform ())
depthOnlyWorker
    , $sel:pLitColored:Pipelines :: ConfigureGraphics ^ Pipeline
pLitColored = Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
litColoredWorker
    , $sel:pLitColoredBlend:Pipelines :: ConfigureGraphics ^ Pipeline
pLitColoredBlend = Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
litColoredBlendWorker
    , $sel:pLitMaterial:Pipelines :: ConfigureGraphics ^ Pipeline
pLitMaterial = Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
litMaterialWorker
    , $sel:pLitMaterialBlend:Pipelines :: ConfigureGraphics ^ Pipeline
pLitMaterialBlend = Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
litMaterialBlendWorker
    , $sel:pLitTextured:Pipelines :: ConfigureGraphics ^ Pipeline
pLitTextured = Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
litTexturedWorker
    , $sel:pLitTexturedBlend:Pipelines :: ConfigureGraphics ^ Pipeline
pLitTexturedBlend = Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
litTexturedBlendWorker
    , $sel:pLine2d:Pipelines :: ConfigureGraphics ^ Pipeline
pLine2d = Process (Config '[Scene] (Vertex Packed ()) InstanceAttrs ())
line2dWorker
    , $sel:pLine2dNoDepth:Pipelines :: ConfigureGraphics ^ Pipeline
pLine2dNoDepth = Process (Config '[Scene] (Vertex Packed ()) InstanceAttrs ())
line2dNoDepthWorker
    , $sel:pUnlitColored:Pipelines :: ConfigureGraphics ^ Pipeline
pUnlitColored = Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
unlitColoredWorker
    , $sel:pUnlitColoredNoDepth:Pipelines :: ConfigureGraphics ^ Pipeline
pUnlitColoredNoDepth = Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
unlitColoredNoDepthWorker
    , $sel:pUnlitTextured:Pipelines :: ConfigureGraphics ^ Pipeline
pUnlitTextured = Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
unlitTexturedWorker
    , $sel:pUnlitTexturedBlend:Pipelines :: ConfigureGraphics ^ Pipeline
pUnlitTexturedBlend = Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
unlitTexturedBlendWorker
    , $sel:pSprite:Pipelines :: ConfigureGraphics ^ Pipeline
pSprite = Process
  (Config
     '[Scene] () InstanceAttrs ("max anisotropy" ::: Float, Bool))
spriteWorker
    , $sel:pSpriteOutline:Pipelines :: ConfigureGraphics ^ Pipeline
pSpriteOutline = Process
  (Config
     '[Scene] () InstanceAttrs ("max anisotropy" ::: Float, Bool))
spriteOutlineWorker
    , $sel:pTileMap:Pipelines :: ConfigureGraphics ^ Pipeline
pTileMap = Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
tileMapWorker
    , $sel:pTileMapBlend:Pipelines :: ConfigureGraphics ^ Pipeline
pTileMapBlend = Process
  (Config '[Scene] (Vertex Packed VertexAttrs) (AttrsF Identity) ())
tileMapBlendWorker
    , $sel:pWireframe:Pipelines :: ConfigureGraphics ^ Pipeline
pWireframe = Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
wireframeWorker
    , $sel:pWireframeNoDepth:Pipelines :: ConfigureGraphics ^ Pipeline
pWireframeNoDepth = Process (Config '[Scene] (Vertex Packed VertexAttrs) Transform ())
wireframeNoDepthWorker
    , $sel:pShadowCast:Pipelines :: ConfigureGraphics ^ Pipeline
pShadowCast = Process (Config '[Sun] (Vertex Packed ()) Transform ())
shadowCastWorker
    }

allocateObservers
  :: RenderPasses
  -> PipelineWorkers
  -> ResourceT (Engine.StageRIO rs) PipelineObservers
allocateObservers :: forall rs.
RenderPasses
-> PipelineWorkers -> ResourceT (StageRIO rs) PipelineObservers
allocateObservers RenderPasses
renderPasses Pipelines{Tagged '[Sun] DescriptorSetLayout
Tagged '[Scene] DescriptorSetLayout
Tagged Sun DsLayoutBindings
Tagged Scene DsLayoutBindings
SampleCountFlagBits
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
ConfigureGraphics ^ Pipeline
pShadowCast :: ConfigureGraphics ^ Pipeline
pWireframeNoDepth :: ConfigureGraphics ^ Pipeline
pWireframe :: ConfigureGraphics ^ Pipeline
pTileMapBlend :: ConfigureGraphics ^ Pipeline
pTileMap :: ConfigureGraphics ^ Pipeline
pSpriteOutline :: ConfigureGraphics ^ Pipeline
pSprite :: ConfigureGraphics ^ Pipeline
pLine2dNoDepth :: ConfigureGraphics ^ Pipeline
pLine2d :: ConfigureGraphics ^ Pipeline
pUnlitTexturedBlend :: ConfigureGraphics ^ Pipeline
pUnlitTextured :: ConfigureGraphics ^ Pipeline
pUnlitColoredNoDepth :: ConfigureGraphics ^ Pipeline
pUnlitColored :: ConfigureGraphics ^ Pipeline
pLitTexturedBlend :: ConfigureGraphics ^ Pipeline
pLitTextured :: ConfigureGraphics ^ Pipeline
pLitMaterialBlend :: ConfigureGraphics ^ Pipeline
pLitMaterial :: ConfigureGraphics ^ Pipeline
pLitColoredBlend :: ConfigureGraphics ^ Pipeline
pLitColored :: ConfigureGraphics ^ Pipeline
pDepthOnly :: ConfigureGraphics ^ Pipeline
pDebugShadow :: ConfigureGraphics ^ Pipeline
pDebugTexture :: ConfigureGraphics ^ Pipeline
pDebugUV :: ConfigureGraphics ^ Pipeline
pSkybox :: ConfigureGraphics ^ Pipeline
pEvanwSdf :: ConfigureGraphics ^ Pipeline
pShadowLayout :: Tagged '[Sun] DescriptorSetLayout
pShadowBinds :: Tagged Sun DsLayoutBindings
pSceneLayout :: Tagged '[Scene] DescriptorSetLayout
pSceneBinds :: Tagged Scene DsLayoutBindings
pMSAA :: SampleCountFlagBits
$sel:pShadowCast:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pWireframeNoDepth:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pWireframe:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pTileMapBlend:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pTileMap:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pSpriteOutline:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pSprite:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pLine2dNoDepth:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pLine2d:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pUnlitTexturedBlend:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pUnlitTextured:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pUnlitColoredNoDepth:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pUnlitColored:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pLitTexturedBlend:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pLitTextured:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pLitMaterialBlend:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pLitMaterial:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pLitColoredBlend:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pLitColored:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pDepthOnly:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pDebugShadow:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pDebugTexture:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pDebugUV:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pSkybox:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pEvanwSdf:Pipelines :: forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
$sel:pShadowLayout:Pipelines :: forall (f :: * -> *).
PipelinesF f -> Tagged '[Sun] DescriptorSetLayout
$sel:pShadowBinds:Pipelines :: forall (f :: * -> *). PipelinesF f -> Tagged Sun DsLayoutBindings
$sel:pSceneLayout:Pipelines :: forall (f :: * -> *).
PipelinesF f -> Tagged '[Scene] DescriptorSetLayout
$sel:pSceneBinds:Pipelines :: forall (f :: * -> *). PipelinesF f -> Tagged Scene DsLayoutBindings
$sel:pMSAA:Pipelines :: forall (f :: * -> *). PipelinesF f -> SampleCountFlagBits
..} = do
  Observer Pipeline
evanwSdfExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pEvanwSdf

  Observer Pipeline
skyboxExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pSkybox

  Observer Pipeline
debugUVExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pDebugUV

  Observer Pipeline
debugTextureExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pDebugTexture

  Observer Pipeline
debugShadowExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pDebugShadow

  Observer Pipeline
depthOnlyExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pDepthOnly

  Observer Pipeline
litColoredExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pLitColored

  Observer Pipeline
litColoredBlendExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pLitColoredBlend

  Observer Pipeline
litMaterialExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pLitMaterial

  Observer Pipeline
litMaterialBlendExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pLitMaterialBlend

  Observer Pipeline
litTexturedExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pLitTextured

  Observer Pipeline
litTexturedBlendExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pLitTexturedBlend

  Observer Pipeline
line2dExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pLine2d

  Observer Pipeline
line2dNoDepthExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pLine2dNoDepth

  Observer Pipeline
unlitColoredExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pUnlitColored

  Observer Pipeline
unlitColoredNoDepthExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pUnlitColoredNoDepth

  Observer Pipeline
unlitTexturedExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pUnlitTextured

  Observer Pipeline
unlitTexturedBlendExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pUnlitTexturedBlend

  Observer Pipeline
spriteExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pSprite

  Observer Pipeline
spriteOutlineExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pSpriteOutline

  Observer Pipeline
tileMapExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pTileMap

  Observer Pipeline
tileMapBlendExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pTileMapBlend

  Observer Pipeline
wireframeExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pWireframe

  Observer Pipeline
wireframeNoDepthExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pWireframeNoDepth

  Observer Pipeline
shadowCastExt <- forall pipeline (dsl :: [*]) vertices instances worker renderpass
       rs.
(pipeline ~ Pipeline dsl vertices instances, HasOutput worker,
 Specialization (Specialization pipeline), HasRenderPass renderpass,
 GetOutput worker ~ Configure pipeline) =>
renderpass
-> SampleCountFlagBits
-> worker
-> ResourceT (StageRIO rs) (Observer pipeline)
External.newObserverGraphics
    ForwardMsaa
forward
    SampleCountFlagBits
pMSAA
    ConfigureGraphics ^ Pipeline
pShadowCast

  pure Pipelines
    { $sel:pEvanwSdf:Pipelines :: Observers ^ Pipeline
pEvanwSdf = Observer Pipeline
evanwSdfExt
    , $sel:pSkybox:Pipelines :: Observers ^ Pipeline
pSkybox = Observer Pipeline
skyboxExt
    , $sel:pDebugUV:Pipelines :: Observers ^ Pipeline
pDebugUV = Observer Pipeline
debugUVExt
    , $sel:pDebugTexture:Pipelines :: Observers ^ Pipeline
pDebugTexture = Observer Pipeline
debugTextureExt
    , $sel:pDebugShadow:Pipelines :: Observers ^ Pipeline
pDebugShadow = Observer Pipeline
debugShadowExt
    , $sel:pDepthOnly:Pipelines :: Observers ^ Pipeline
pDepthOnly = Observer Pipeline
depthOnlyExt
    , $sel:pLitColored:Pipelines :: Observers ^ Pipeline
pLitColored = Observer Pipeline
litColoredExt
    , $sel:pLitColoredBlend:Pipelines :: Observers ^ Pipeline
pLitColoredBlend = Observer Pipeline
litColoredBlendExt
    , $sel:pLitMaterial:Pipelines :: Observers ^ Pipeline
pLitMaterial = Observer Pipeline
litMaterialExt
    , $sel:pLitMaterialBlend:Pipelines :: Observers ^ Pipeline
pLitMaterialBlend = Observer Pipeline
litMaterialBlendExt
    , $sel:pLitTextured:Pipelines :: Observers ^ Pipeline
pLitTextured = Observer Pipeline
litTexturedExt
    , $sel:pLitTexturedBlend:Pipelines :: Observers ^ Pipeline
pLitTexturedBlend = Observer Pipeline
litTexturedBlendExt
    , $sel:pLine2d:Pipelines :: Observers ^ Pipeline
pLine2d = Observer Pipeline
line2dExt
    , $sel:pLine2dNoDepth:Pipelines :: Observers ^ Pipeline
pLine2dNoDepth = Observer Pipeline
line2dNoDepthExt
    , $sel:pUnlitColored:Pipelines :: Observers ^ Pipeline
pUnlitColored = Observer Pipeline
unlitColoredExt
    , $sel:pUnlitColoredNoDepth:Pipelines :: Observers ^ Pipeline
pUnlitColoredNoDepth = Observer Pipeline
unlitColoredNoDepthExt
    , $sel:pUnlitTextured:Pipelines :: Observers ^ Pipeline
pUnlitTextured = Observer Pipeline
unlitTexturedExt
    , $sel:pUnlitTexturedBlend:Pipelines :: Observers ^ Pipeline
pUnlitTexturedBlend = Observer Pipeline
unlitTexturedBlendExt
    , $sel:pSprite:Pipelines :: Observers ^ Pipeline
pSprite = Observer Pipeline
spriteExt
    , $sel:pSpriteOutline:Pipelines :: Observers ^ Pipeline
pSpriteOutline = Observer Pipeline
spriteOutlineExt
    , $sel:pTileMap:Pipelines :: Observers ^ Pipeline
pTileMap = Observer Pipeline
tileMapExt
    , $sel:pTileMapBlend:Pipelines :: Observers ^ Pipeline
pTileMapBlend = Observer Pipeline
tileMapBlendExt
    , $sel:pWireframe:Pipelines :: Observers ^ Pipeline
pWireframe = Observer Pipeline
wireframeExt
    , $sel:pWireframeNoDepth:Pipelines :: Observers ^ Pipeline
pWireframeNoDepth = Observer Pipeline
wireframeNoDepthExt
    , $sel:pShadowCast:Pipelines :: Observers ^ Pipeline
pShadowCast = Observer Pipeline
shadowCastExt
    , Tagged '[Sun] DescriptorSetLayout
Tagged '[Scene] DescriptorSetLayout
Tagged Sun DsLayoutBindings
Tagged Scene DsLayoutBindings
SampleCountFlagBits
pShadowLayout :: Tagged '[Sun] DescriptorSetLayout
pShadowBinds :: Tagged Sun DsLayoutBindings
pSceneLayout :: Tagged '[Scene] DescriptorSetLayout
pSceneBinds :: Tagged Scene DsLayoutBindings
pMSAA :: SampleCountFlagBits
$sel:pShadowLayout:Pipelines :: Tagged '[Sun] DescriptorSetLayout
$sel:pShadowBinds:Pipelines :: Tagged Sun DsLayoutBindings
$sel:pSceneLayout:Pipelines :: Tagged '[Scene] DescriptorSetLayout
$sel:pSceneBinds:Pipelines :: Tagged Scene DsLayoutBindings
$sel:pMSAA:Pipelines :: SampleCountFlagBits
..
    }
  where
    forward :: ForwardMsaa
forward = RenderPasses -> ForwardMsaa
rpForwardMsaa RenderPasses
renderPasses

observePipelines
  :: RenderPasses
  -> PipelineWorkers
  -> PipelineObservers
  -> Engine.StageFrameRIO rp p fr rs ()
observePipelines :: forall rp p fr rs.
RenderPasses
-> PipelineWorkers
-> PipelineObservers
-> StageFrameRIO rp p fr rs ()
observePipelines RenderPasses
fRenderpass PipelineWorkers
workers PipelineObservers
pipelines = do
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @EvanwSdf.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pEvanwSdf

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @Skybox.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pSkybox

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @Debug.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pDebugUV
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @Debug.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pDebugTexture
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @Debug.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pDebugShadow

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @DepthOnly.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pDepthOnly

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @LitColored.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitColored
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @LitColored.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitColoredBlend

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @LitTextured.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitTextured
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @LitTextured.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitTexturedBlend

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @LitMaterial.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitMaterial
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @LitMaterial.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pLitMaterialBlend

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @UnlitColored.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pUnlitColored
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @UnlitColored.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pUnlitColoredNoDepth

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @UnlitTextured.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pUnlitTextured
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @UnlitTextured.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pUnlitTexturedBlend

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @UnlitSprite.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pSprite
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @UnlitSprite.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pSpriteOutline

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @UnlitTileMap.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pTileMap
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @UnlitTileMap.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pTileMapBlend

  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @UnlitColored.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pWireframe
  forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe @UnlitColored.Pipeline forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pWireframeNoDepth

  forall renderpass output pipeline (dsl :: [*]) vertices instances
       spec rp p fr rs.
(HasRenderPass renderpass, HasOutput output,
 GetOutput output ~ Configure pipeline,
 pipeline ~ Pipeline dsl vertices instances,
 spec ~ Specialization pipeline, Specialization spec) =>
renderpass
-> SampleCountFlagBits
-> Tagged dsl [DsLayoutBindings]
-> output
-> ObserverIO (ReleaseKey, pipeline)
-> StageFrameRIO rp p fr rs ()
External.observeGraphics
    (RenderPasses -> ShadowMap
rpShadowPass RenderPasses
fRenderpass) -- XXX: different RP here
    (forall (f :: * -> *). PipelinesF f -> SampleCountFlagBits
pMSAA PipelineWorkers
workers)
    (forall {k} (s :: k) b. b -> Tagged s b
Tagged [forall {k} (s :: k) b. Tagged s b -> b
unTagged forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *). PipelinesF f -> Tagged Scene DsLayoutBindings
pSceneBinds PipelineObservers
pipelines])
    (forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pShadowCast PipelineWorkers
workers)
    (forall (f :: * -> *). PipelinesF f -> f ^ Pipeline
pShadowCast PipelineObservers
pipelines)
  where
    observe
      :: forall
         p
         s vs is
         rps ps fr rs
      .  ( p ~ Graphics.Pipeline s vs is
         , Shader.Specialization (Graphics.Specialization p)
         )
      => (forall a . PipelinesF a -> a ^ p)
      -> Engine.StageFrameRIO rps ps fr rs ()
    observe :: forall p (s :: [*]) vs is rps ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p)) =>
(forall (a :: * -> *). PipelinesF a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
observe =
      forall (pf :: (* -> *) -> *) p renderpass dsl (s :: [*]) vs is rps
       ps fr rs.
(p ~ Pipeline s vs is, Specialization (Specialization p),
 HasRenderPass renderpass) =>
renderpass
-> SampleCountFlagBits
-> Tagged dsl DsLayoutBindings
-> pf ConfigureGraphics
-> pf Observers
-> (forall (a :: * -> *). pf a -> a ^ p)
-> StageFrameRIO rps ps fr rs ()
External.observeField
        @PipelinesF
        @p
        (RenderPasses -> ForwardMsaa
rpForwardMsaa RenderPasses
fRenderpass)
        (forall (f :: * -> *). PipelinesF f -> SampleCountFlagBits
pMSAA PipelineWorkers
workers)
        (forall (f :: * -> *). PipelinesF f -> Tagged Scene DsLayoutBindings
pSceneBinds PipelineObservers
pipelines)
        PipelineWorkers
workers
        PipelineObservers
pipelines

getSceneLayout :: PipelinesF f -> Tagged '[Scene] Vk.DescriptorSetLayout
getSceneLayout :: forall (f :: * -> *).
PipelinesF f -> Tagged '[Scene] DescriptorSetLayout
getSceneLayout = forall (f :: * -> *).
PipelinesF f -> Tagged '[Scene] DescriptorSetLayout
pSceneLayout

getSunLayout :: Pipelines -> Tagged '[Sun] Vk.DescriptorSetLayout
getSunLayout :: Pipelines -> Tagged '[Sun] DescriptorSetLayout
getSunLayout = forall (f :: * -> *).
PipelinesF f -> Tagged '[Sun] DescriptorSetLayout
pShadowLayout

shaderDir :: FilePath
shaderDir :: String
shaderDir = String
"data" String -> ShowS
</> String
"shaders" String -> ShowS
</> String
"basic"

stageSources :: Map Text Graphics.StageCode
stageSources :: Map Text StageCode
stageSources =
  [ (Text
"evanw-sdf", StageCode
EvanwSdf.stageCode)
  , (Text
"skybox", StageCode
Skybox.stageCode)
  , (Text
"debug", StageCode
Debug.stageCode)
  , (Text
"depth-only", StageCode
DepthOnly.stageCode)
  , (Text
"lit-colored", StageCode
LitColored.stageCode)
  , (Text
"lit-material", StageCode
LitMaterial.stageCode)
  , (Text
"lit-textured", StageCode
LitTextured.stageCode)
  , (Text
"unlit-colored", StageCode
UnlitColored.stageCode)
  , (Text
"unlit-textured", StageCode
UnlitTextured.stageCode)
  , (Text
"line-2d", StageCode
UnlitLine2d.stageCode)
  , (Text
"sprite", StageCode
UnlitSprite.stageCode)
  , (Text
"tilemap", StageCode
UnlitTileMap.stageCode)
  , (Text
"shadow-cast", StageCode
ShadowPipe.stageCode)
  ]