{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE BlockArguments, LambdaCase #-}
{-# LANGUAGE ScopedTypeVariables, TypeApplications #-}
{-# LANGUAGE GADTs, TypeFamilies #-}
{-# LANGUAGE DataKinds, PolyKinds #-}
{-# LANGUAGE KindSignatures, TypeOperators #-}
{-# LANGUAGE MultiParamTypeClasses, AllowAmbiguousTypes #-}
{-# LANGUAGE FlexibleContexts, FlexibleInstances #-}
{-# LANGUAGE PatternSynonyms, ViewPatterns #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}

module Gpu.Vulkan.Pipeline.Graphics.Middle.Internal (
	CreateInfo(..), CreateInfoListToCore,
	createGs, recreateGs,

	destroyGs,

	G, gNull, gToCore,
	) where

import Prelude hiding (length)
import Prelude qualified as P

import Foreign.Ptr
import Foreign.Marshal.Array
import Foreign.Storable.PeekPoke
import Control.Monad
import Data.TypeLevel.Maybe qualified as TMaybe
import Data.TypeLevel.ParMaybe qualified as TPMaybe
import Data.TypeLevel.Tuple.Uncurry
import Data.TypeLevel.List
import Data.IORef
import qualified Data.HeteroParList as HeteroParList
import Data.HeteroParList (pattern (:**))
import Data.Word
import Data.Int

import Gpu.Vulkan.Base.Middle.Internal
import Gpu.Vulkan.Exception.Middle.Internal
import Gpu.Vulkan.Exception.Enum
import Gpu.Vulkan.Pipeline.Enum

import qualified Gpu.Vulkan.Pipeline.Core as Pipeline.C
import qualified Gpu.Vulkan.Pipeline.ShaderStage.Middle.Internal as ShaderStage
import qualified Gpu.Vulkan.Pipeline.VertexInputState.Middle.Internal as VertexInputState.M
import Gpu.Vulkan.Pipeline.InputAssemblyState.Middle.Internal
	qualified as InputAssemblyState
import Gpu.Vulkan.Pipeline.TessellationState.Middle.Internal
	qualified as TessellationState
import qualified Gpu.Vulkan.Pipeline.ViewportState.Middle.Internal as ViewportState
import qualified Gpu.Vulkan.Pipeline.RasterizationState.Middle.Internal as RasterizationState
import qualified Gpu.Vulkan.Pipeline.MultisampleState.Middle.Internal as MultisampleState
import qualified Gpu.Vulkan.Pipeline.DepthStencilState.Middle.Internal
	as DepthStencilState
import qualified Gpu.Vulkan.Pipeline.ColorBlendState.Middle.Internal
	as ColorBlendState
import qualified Gpu.Vulkan.Pipeline.DynamicState.Middle.Internal
	as DynamicState
import qualified Gpu.Vulkan.PipelineLayout.Middle.Internal as Layout
import qualified Gpu.Vulkan.RenderPass.Middle.Internal as RenderPass
import qualified Gpu.Vulkan.Pipeline.Graphics.Core as C

import Gpu.Vulkan.AllocationCallbacks.Middle.Internal
	qualified as AllocationCallbacks
import qualified Gpu.Vulkan.Device.Middle.Internal as Device
import qualified Gpu.Vulkan.PipelineCache.Middle.Internal as Cache

data CreateInfo mn stg vis ias ts vs rs ms dss cbs ds = CreateInfo {
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> M mn
createInfoNext :: TMaybe.M mn,
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> CreateFlags
createInfoFlags :: CreateFlags,
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> PL (U3 CreateInfo) stg
createInfoStages :: HeteroParList.PL (U3 ShaderStage.CreateInfo) stg,
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo vis)
createInfoVertexInputState :: Maybe (VertexInputState.M.CreateInfo vis),
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo ias)
createInfoInputAssemblyState ::
		Maybe (InputAssemblyState.CreateInfo ias),
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo ts)
createInfoTessellationState :: Maybe (TessellationState.CreateInfo ts),
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo vs)
createInfoViewportState :: Maybe (ViewportState.CreateInfo vs),
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo rs)
createInfoRasterizationState ::
		Maybe (RasterizationState.CreateInfo rs),
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo ms)
createInfoMultisampleState :: Maybe (MultisampleState.CreateInfo ms),
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo dss)
createInfoDepthStencilState :: Maybe (DepthStencilState.CreateInfo dss),
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo cbs)
createInfoColorBlendState :: Maybe (ColorBlendState.CreateInfo cbs),
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo ds)
createInfoDynamicState :: Maybe (DynamicState.CreateInfo ds),
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> P
createInfoLayout :: Layout.P,
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> R
createInfoRenderPass :: RenderPass.R,
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> Word32
createInfoSubpass :: Word32,
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> G
createInfoBasePipelineHandle :: G,
	forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> Int32
createInfoBasePipelineIndex :: Int32 }

createInfoToCore :: (
	WithPoked (TMaybe.M mn),
	ShaderStage.CreateInfoListToCore stg,
	WithPoked (TMaybe.M n2), WithPoked (TMaybe.M n3),
	WithPoked (TMaybe.M n4), WithPoked (TMaybe.M n5),
	WithPoked (TMaybe.M n6), WithPoked (TMaybe.M n7),
	WithPoked (TMaybe.M n8), WithPoked (TMaybe.M n9),
	WithPoked (TMaybe.M n10) ) =>
	CreateInfo mn stg n2 n3 n4 n5 n6 n7 n8 n9 n10 ->
	(C.CreateInfo -> IO a) -> IO ()
createInfoToCore :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (n2 :: Maybe (*)) (n3 :: Maybe (*)) (n4 :: Maybe (*))
       (n5 :: Maybe (*)) (n6 :: Maybe (*)) (n7 :: Maybe (*))
       (n8 :: Maybe (*)) (n9 :: Maybe (*)) (n10 :: Maybe (*)) a.
(WithPoked (M mn), CreateInfoListToCore stg, WithPoked (M n2),
 WithPoked (M n3), WithPoked (M n4), WithPoked (M n5),
 WithPoked (M n6), WithPoked (M n7), WithPoked (M n8),
 WithPoked (M n9), WithPoked (M n10)) =>
CreateInfo mn stg n2 n3 n4 n5 n6 n7 n8 n9 n10
-> (CreateInfo -> IO a) -> IO ()
createInfoToCore CreateInfo {
	createInfoNext :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> M mn
createInfoNext = M mn
mnxt,
	createInfoFlags :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> CreateFlags
createInfoFlags = CreateFlagBits Word32
flgs,
	createInfoStages :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> PL (U3 CreateInfo) stg
createInfoStages = PL (U3 CreateInfo) stg
ss,
	createInfoVertexInputState :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo vis)
createInfoVertexInputState = Maybe (CreateInfo n2)
mvist,
	createInfoInputAssemblyState :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo ias)
createInfoInputAssemblyState = Maybe (CreateInfo n3)
miast,
	createInfoTessellationState :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo ts)
createInfoTessellationState = Maybe (CreateInfo n4)
mtst,
	createInfoViewportState :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo vs)
createInfoViewportState = Maybe (CreateInfo n5)
mvst,
	createInfoRasterizationState :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo rs)
createInfoRasterizationState = Maybe (CreateInfo n6)
mrst,
	createInfoMultisampleState :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo ms)
createInfoMultisampleState = Maybe (CreateInfo n7)
mmst,
	createInfoDepthStencilState :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo dss)
createInfoDepthStencilState = Maybe (CreateInfo n8)
mdsst,
	createInfoColorBlendState :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo cbs)
createInfoColorBlendState = Maybe (CreateInfo n9)
mcbst,
	createInfoDynamicState :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds
-> Maybe (CreateInfo ds)
createInfoDynamicState = Maybe (CreateInfo n10)
mdst,
	createInfoLayout :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> P
createInfoLayout = Layout.P P
lyt,
	createInfoRenderPass :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> R
createInfoRenderPass = RenderPass.R R
rp,
	createInfoSubpass :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> Word32
createInfoSubpass = Word32
sp,
	createInfoBasePipelineHandle :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> G
createInfoBasePipelineHandle = G
bph,
	createInfoBasePipelineIndex :: forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (vis :: Maybe (*)) (ias :: Maybe (*)) (ts :: Maybe (*))
       (vs :: Maybe (*)) (rs :: Maybe (*)) (ms :: Maybe (*))
       (dss :: Maybe (*)) (cbs :: Maybe (*)) (ds :: Maybe (*)).
CreateInfo mn stg vis ias ts vs rs ms dss cbs ds -> Int32
createInfoBasePipelineIndex = Int32
bpi } CreateInfo -> IO a
f =
	M mn -> (forall s. PtrS s (M mn) -> IO ()) -> IO ()
forall a b.
WithPoked a =>
a -> (forall s. PtrS s a -> IO b) -> IO b
forall b. M mn -> (forall s. PtrS s (M mn) -> IO b) -> IO b
withPoked' M mn
mnxt \PtrS s (M mn)
pnxt -> PtrS s (M mn) -> (Ptr (M mn) -> IO ()) -> IO ()
forall s a b. PtrS s a -> (Ptr a -> IO b) -> IO ()
withPtrS PtrS s (M mn)
pnxt \(Ptr (M mn) -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr -> Ptr ()
pnxt') ->
	PL (U3 CreateInfo) stg -> ([CreateInfo] -> IO ()) -> IO ()
forall (cias :: [(Maybe (*), ShaderKind, [*])]) r.
CreateInfoListToCore cias =>
PL (U3 CreateInfo) cias -> ([CreateInfo] -> IO r) -> IO ()
forall r. PL (U3 CreateInfo) stg -> ([CreateInfo] -> IO r) -> IO ()
ShaderStage.createInfoListToCore PL (U3 CreateInfo) stg
ss \[CreateInfo]
css ->
	let sc :: Int
sc = [CreateInfo] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [CreateInfo]
css in
	Int -> (Ptr CreateInfo -> IO ()) -> IO ()
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
sc \Ptr CreateInfo
pss ->
	Ptr CreateInfo -> [CreateInfo] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CreateInfo
pss [CreateInfo]
css IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
	(CreateInfo n2 -> (Ptr CreateInfo -> IO ()) -> IO ())
-> Maybe (CreateInfo n2) -> (Ptr CreateInfo -> IO ()) -> IO ()
forall a b r.
(a -> (Ptr b -> IO r) -> IO r)
-> Maybe a -> (Ptr b -> IO r) -> IO r
maybeToCore CreateInfo n2 -> (Ptr CreateInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO a) -> IO ()
VertexInputState.M.createInfoToCore Maybe (CreateInfo n2)
mvist \Ptr CreateInfo
pvist ->
	(CreateInfo n3 -> (Ptr CreateInfo -> IO ()) -> IO ())
-> Maybe (CreateInfo n3) -> (Ptr CreateInfo -> IO ()) -> IO ()
forall a b r.
(a -> (Ptr b -> IO r) -> IO r)
-> Maybe a -> (Ptr b -> IO r) -> IO r
maybeToCore CreateInfo n3 -> (Ptr CreateInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO a) -> IO ()
InputAssemblyState.createInfoToCore Maybe (CreateInfo n3)
miast \Ptr CreateInfo
piast ->
	(CreateInfo n4 -> (Ptr CreateInfo -> IO ()) -> IO ())
-> Maybe (CreateInfo n4) -> (Ptr CreateInfo -> IO ()) -> IO ()
forall a b r.
(a -> (Ptr b -> IO r) -> IO r)
-> Maybe a -> (Ptr b -> IO r) -> IO r
maybeToCore CreateInfo n4 -> (Ptr CreateInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO a) -> IO ()
TessellationState.createInfoToCore Maybe (CreateInfo n4)
mtst \Ptr CreateInfo
ptst ->
	(CreateInfo n5 -> (Ptr CreateInfo -> IO ()) -> IO ())
-> Maybe (CreateInfo n5) -> (Ptr CreateInfo -> IO ()) -> IO ()
forall a b r.
(a -> (Ptr b -> IO r) -> IO r)
-> Maybe a -> (Ptr b -> IO r) -> IO r
maybeToCore CreateInfo n5 -> (Ptr CreateInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO a) -> IO ()
ViewportState.createInfoToCore Maybe (CreateInfo n5)
mvst \Ptr CreateInfo
pvst ->
	(CreateInfo n6 -> (Ptr CreateInfo -> IO ()) -> IO ())
-> Maybe (CreateInfo n6) -> (Ptr CreateInfo -> IO ()) -> IO ()
forall a b r.
(a -> (Ptr b -> IO r) -> IO r)
-> Maybe a -> (Ptr b -> IO r) -> IO r
maybeToCore CreateInfo n6 -> (Ptr CreateInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO a) -> IO ()
RasterizationState.createInfoToCore Maybe (CreateInfo n6)
mrst \Ptr CreateInfo
prst ->
	(CreateInfo n7 -> (Ptr CreateInfo -> IO ()) -> IO ())
-> Maybe (CreateInfo n7) -> (Ptr CreateInfo -> IO ()) -> IO ()
forall a b r.
(a -> (Ptr b -> IO r) -> IO r)
-> Maybe a -> (Ptr b -> IO r) -> IO r
maybeToCore CreateInfo n7 -> (Ptr CreateInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO a) -> IO ()
MultisampleState.createInfoToCore Maybe (CreateInfo n7)
mmst \Ptr CreateInfo
pmst ->
	(CreateInfo n8 -> (Ptr CreateInfo -> IO ()) -> IO ())
-> Maybe (CreateInfo n8) -> (Ptr CreateInfo -> IO ()) -> IO ()
forall a b r.
(a -> (Ptr b -> IO r) -> IO r)
-> Maybe a -> (Ptr b -> IO r) -> IO r
maybeToCore CreateInfo n8 -> (Ptr CreateInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO a) -> IO ()
DepthStencilState.createInfoToCore Maybe (CreateInfo n8)
mdsst \Ptr CreateInfo
pdsst ->
	(CreateInfo n9 -> (Ptr CreateInfo -> IO ()) -> IO ())
-> Maybe (CreateInfo n9) -> (Ptr CreateInfo -> IO ()) -> IO ()
forall a b r.
(a -> (Ptr b -> IO r) -> IO r)
-> Maybe a -> (Ptr b -> IO r) -> IO r
maybeToCore CreateInfo n9 -> (Ptr CreateInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO a) -> IO ()
ColorBlendState.createInfoToCore Maybe (CreateInfo n9)
mcbst \Ptr CreateInfo
pcbst ->
	(CreateInfo n10 -> (Ptr CreateInfo -> IO a) -> IO ())
-> Maybe (CreateInfo n10) -> (Ptr CreateInfo -> IO a) -> IO ()
forall a b r.
(a -> (Ptr b -> IO r) -> IO ())
-> Maybe a -> (Ptr b -> IO r) -> IO ()
maybeToCore' CreateInfo n10 -> (Ptr CreateInfo -> IO a) -> IO ()
forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
CreateInfo mn -> (Ptr CreateInfo -> IO a) -> IO ()
DynamicState.createInfoToCore Maybe (CreateInfo n10)
mdst \Ptr CreateInfo
pdst ->
	G -> IO P
gToCore G
bph IO P -> (P -> IO a) -> IO a
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \P
bph' ->
	CreateInfo -> IO a
f C.CreateInfo {
		createInfoSType :: ()
C.createInfoSType = (),
		createInfoPNext :: Ptr ()
C.createInfoPNext = Ptr ()
pnxt',
		createInfoFlags :: Word32
C.createInfoFlags = Word32
flgs,
		createInfoStageCount :: Word32
C.createInfoStageCount = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
sc,
		createInfoPStages :: Ptr CreateInfo
C.createInfoPStages = Ptr CreateInfo
pss,
		createInfoPVertexInputState :: Ptr CreateInfo
C.createInfoPVertexInputState = Ptr CreateInfo
pvist,
		createInfoPInputAssemblyState :: Ptr CreateInfo
C.createInfoPInputAssemblyState = Ptr CreateInfo
piast,
		createInfoPTessellationState :: Ptr CreateInfo
C.createInfoPTessellationState = Ptr CreateInfo
ptst,
		createInfoPViewportState :: Ptr CreateInfo
C.createInfoPViewportState = Ptr CreateInfo
pvst,
		createInfoPRasterizationState :: Ptr CreateInfo
C.createInfoPRasterizationState = Ptr CreateInfo
prst,
		createInfoPMultisampleState :: Ptr CreateInfo
C.createInfoPMultisampleState = Ptr CreateInfo
pmst,
		createInfoPDepthStencilState :: Ptr CreateInfo
C.createInfoPDepthStencilState = Ptr CreateInfo
pdsst,
		createInfoPColorBlendState :: Ptr CreateInfo
C.createInfoPColorBlendState = Ptr CreateInfo
pcbst,
		createInfoPDynamicState :: Ptr CreateInfo
C.createInfoPDynamicState = Ptr CreateInfo
pdst,
		createInfoLayout :: P
C.createInfoLayout = P
lyt,
		createInfoRenderPass :: R
C.createInfoRenderPass = R
rp,
		createInfoSubpass :: Word32
C.createInfoSubpass = Word32
sp,
		createInfoBasePipelineHandle :: P
C.createInfoBasePipelineHandle = P
bph',
		createInfoBasePipelineIndex :: Int32
C.createInfoBasePipelineIndex = Int32
bpi }

maybeToCore :: (a -> (Ptr b -> IO r) -> IO r) -> Maybe a -> (Ptr b -> IO r) -> IO r
maybeToCore :: forall a b r.
(a -> (Ptr b -> IO r) -> IO r)
-> Maybe a -> (Ptr b -> IO r) -> IO r
maybeToCore a -> (Ptr b -> IO r) -> IO r
f Maybe a
mx Ptr b -> IO r
g = case Maybe a
mx of Maybe a
Nothing -> Ptr b -> IO r
g Ptr b
forall a. Ptr a
NullPtr; Just a
x -> a -> (Ptr b -> IO r) -> IO r
f a
x Ptr b -> IO r
g

maybeToCore' :: (a -> (Ptr b -> IO r) -> IO ()) -> Maybe a -> (Ptr b -> IO r) -> IO ()
maybeToCore' :: forall a b r.
(a -> (Ptr b -> IO r) -> IO ())
-> Maybe a -> (Ptr b -> IO r) -> IO ()
maybeToCore' a -> (Ptr b -> IO r) -> IO ()
f Maybe a
mx Ptr b -> IO r
g = case Maybe a
mx of Maybe a
Nothing -> () () -> IO r -> IO ()
forall a b. a -> IO b -> IO a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ptr b -> IO r
g Ptr b
forall a. Ptr a
NullPtr; Just a
x -> a -> (Ptr b -> IO r) -> IO ()
f a
x Ptr b -> IO r
g

class Length cias => CreateInfoListToCore cias where
	createInfoListToCore ::
		HeteroParList.PL (U11 CreateInfo) cias ->
		([C.CreateInfo] -> IO r) -> IO ()

instance CreateInfoListToCore '[] where createInfoListToCore :: forall r.
PL (U11 CreateInfo) '[] -> ([CreateInfo] -> IO r) -> IO ()
createInfoListToCore PL (U11 CreateInfo) '[]
HeteroParList.Nil [CreateInfo] -> IO r
f = () () -> IO r -> IO ()
forall a b. a -> IO b -> IO a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ [CreateInfo] -> IO r
f []

instance (
	WithPoked (TMaybe.M mn), ShaderStage.CreateInfoListToCore stg,
	WithPoked (TMaybe.M vis), WithPoked (TMaybe.M ias),
	WithPoked (TMaybe.M ts), WithPoked (TMaybe.M vs),
	WithPoked (TMaybe.M rs), WithPoked (TMaybe.M ms),
	WithPoked (TMaybe.M dss), WithPoked (TMaybe.M cbs),
	WithPoked (TMaybe.M ds), CreateInfoListToCore cias ) =>
	CreateInfoListToCore ('(
		mn, stg, vis, ias, ts, vs, rs, ms, dss, cbs, ds ) ': cias) where
	createInfoListToCore :: forall r.
PL
  (U11 CreateInfo)
  ('(mn, stg, vis, ias, ts, vs, rs, ms, dss, cbs, ds) : cias)
-> ([CreateInfo] -> IO r) -> IO ()
createInfoListToCore (U11 CreateInfo s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11
ci :** PL (U11 CreateInfo) ss1
cis) [CreateInfo] -> IO r
f =
		CreateInfo s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11
-> (CreateInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) (stg :: [(Maybe (*), ShaderKind, [*])])
       (n2 :: Maybe (*)) (n3 :: Maybe (*)) (n4 :: Maybe (*))
       (n5 :: Maybe (*)) (n6 :: Maybe (*)) (n7 :: Maybe (*))
       (n8 :: Maybe (*)) (n9 :: Maybe (*)) (n10 :: Maybe (*)) a.
(WithPoked (M mn), CreateInfoListToCore stg, WithPoked (M n2),
 WithPoked (M n3), WithPoked (M n4), WithPoked (M n5),
 WithPoked (M n6), WithPoked (M n7), WithPoked (M n8),
 WithPoked (M n9), WithPoked (M n10)) =>
CreateInfo mn stg n2 n3 n4 n5 n6 n7 n8 n9 n10
-> (CreateInfo -> IO a) -> IO ()
createInfoToCore CreateInfo s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11
ci \CreateInfo
cci ->
		PL (U11 CreateInfo) ss1 -> ([CreateInfo] -> IO r) -> IO ()
forall (cias :: [(Maybe (*), [(Maybe (*), ShaderKind, [*])],
                  Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*),
                  Maybe (*), Maybe (*), Maybe (*))])
       r.
CreateInfoListToCore cias =>
PL (U11 CreateInfo) cias -> ([CreateInfo] -> IO r) -> IO ()
forall r.
PL (U11 CreateInfo) ss1 -> ([CreateInfo] -> IO r) -> IO ()
createInfoListToCore PL (U11 CreateInfo) ss1
cis \[CreateInfo]
ccis -> [CreateInfo] -> IO r
f ([CreateInfo] -> IO r) -> [CreateInfo] -> IO r
forall a b. (a -> b) -> a -> b
$ CreateInfo
cci CreateInfo -> [CreateInfo] -> [CreateInfo]
forall a. a -> [a] -> [a]
: [CreateInfo]
ccis

gNull :: IO G
gNull :: IO G
gNull = IORef P -> G
G (IORef P -> G) -> IO (IORef P) -> IO G
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P -> IO (IORef P)
forall a. a -> IO (IORef a)
newIORef P
forall a. Ptr a
NullHandle

newtype G = G (IORef Pipeline.C.P)

gToCore :: G -> IO Pipeline.C.P
gToCore :: G -> IO P
gToCore (G IORef P
rp) = IORef P -> IO P
forall a. IORef a -> IO a
readIORef IORef P
rp

gFromCore :: Pipeline.C.P -> IO G
gFromCore :: P -> IO G
gFromCore P
p = IORef P -> G
G (IORef P -> G) -> IO (IORef P) -> IO G
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P -> IO (IORef P)
forall a. a -> IO (IORef a)
newIORef P
p

gListFromCore :: [Pipeline.C.P] -> IO [G]
gListFromCore :: [P] -> IO [G]
gListFromCore [] = [G] -> IO [G]
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
gListFromCore (P
cp : [P]
cps) = (:) (G -> [G] -> [G]) -> IO G -> IO ([G] -> [G])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P -> IO G
gFromCore P
cp IO ([G] -> [G]) -> IO [G] -> IO [G]
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [P] -> IO [G]
gListFromCore [P]
cps

gListToIORefs :: [G] -> [IORef Pipeline.C.P]
gListToIORefs :: [G] -> [IORef P]
gListToIORefs [] = []
gListToIORefs (G IORef P
cp : [G]
cps) = IORef P
cp IORef P -> [IORef P] -> [IORef P]
forall a. a -> [a] -> [a]
: [G] -> [IORef P]
gListToIORefs [G]
cps

gListToCore :: [G] -> IO [Pipeline.C.P]
gListToCore :: [G] -> IO [P]
gListToCore [G]
cps = IORef P -> IO P
forall a. IORef a -> IO a
readIORef (IORef P -> IO P) -> [IORef P] -> IO [P]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
`mapM` [G] -> [IORef P]
gListToIORefs [G]
cps

createGs :: CreateInfoListToCore cias =>
	Device.D -> Maybe Cache.P -> HeteroParList.PL (U11 CreateInfo) cias ->
	TPMaybe.M AllocationCallbacks.A mc -> IO [G]
createGs :: forall (cias :: [(Maybe (*), [(Maybe (*), ShaderKind, [*])],
                  Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*),
                  Maybe (*), Maybe (*), Maybe (*))])
       (mc :: Maybe (*)).
CreateInfoListToCore cias =>
D -> Maybe P -> PL (U11 CreateInfo) cias -> M A mc -> IO [G]
createGs D
dvc Maybe P
mc PL (U11 CreateInfo) cias
cis M A mc
mac = [P] -> IO [G]
gListFromCore ([P] -> IO [G]) -> IO [P] -> IO [G]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< D -> Maybe P -> PL (U11 CreateInfo) cias -> M A mc -> IO [P]
forall (ss :: [(Maybe (*), [(Maybe (*), ShaderKind, [*])],
                Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*),
                Maybe (*), Maybe (*), Maybe (*))])
       (mn' :: Maybe (*)).
CreateInfoListToCore ss =>
D -> Maybe P -> PL (U11 CreateInfo) ss -> M A mn' -> IO [P]
createRaw D
dvc Maybe P
mc PL (U11 CreateInfo) cias
cis M A mc
mac

recreateGs :: CreateInfoListToCore cias =>
	Device.D -> Maybe Cache.P ->
	HeteroParList.PL (U11 CreateInfo) cias ->
	TPMaybe.M AllocationCallbacks.A mc ->
	[G] -> IO ()
recreateGs :: forall (cias :: [(Maybe (*), [(Maybe (*), ShaderKind, [*])],
                  Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*),
                  Maybe (*), Maybe (*), Maybe (*))])
       (mc :: Maybe (*)).
CreateInfoListToCore cias =>
D -> Maybe P -> PL (U11 CreateInfo) cias -> M A mc -> [G] -> IO ()
recreateGs D
dvc Maybe P
mc PL (U11 CreateInfo) cias
cis M A mc
macc [G]
gs =
	D
-> Maybe P
-> PL (U11 CreateInfo) cias
-> M A mc
-> [IORef P]
-> IO ()
forall (ss :: [(Maybe (*), [(Maybe (*), ShaderKind, [*])],
                Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*),
                Maybe (*), Maybe (*), Maybe (*))])
       (mc :: Maybe (*)).
CreateInfoListToCore ss =>
D
-> Maybe P
-> PL (U11 CreateInfo) ss
-> M A mc
-> [IORef P]
-> IO ()
recreateRaw D
dvc Maybe P
mc PL (U11 CreateInfo) cias
cis M A mc
macc ([IORef P] -> IO ()) -> [IORef P] -> IO ()
forall a b. (a -> b) -> a -> b
$ [G] -> [IORef P]
gListToIORefs [G]
gs

createRaw :: forall ss mn' . CreateInfoListToCore ss =>
	Device.D -> Maybe Cache.P ->
	HeteroParList.PL (U11 CreateInfo) ss ->
	TPMaybe.M AllocationCallbacks.A mn' -> IO [Pipeline.C.P]
createRaw :: forall (ss :: [(Maybe (*), [(Maybe (*), ShaderKind, [*])],
                Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*),
                Maybe (*), Maybe (*), Maybe (*))])
       (mn' :: Maybe (*)).
CreateInfoListToCore ss =>
D -> Maybe P -> PL (U11 CreateInfo) ss -> M A mn' -> IO [P]
createRaw (Device.D D
dvc) Maybe P
mc PL (U11 CreateInfo) ss
cis M A mn'
mac = let
	cc :: Ptr PTag
cc = case Maybe P
mc of Maybe P
Nothing -> Ptr PTag
forall a. Ptr a
NullPtr; Just (Cache.P Ptr PTag
c) -> Ptr PTag
c
	cic :: Int
cic = forall k (as :: [k]) n. (Length as, Integral n) => n
length @_ @ss in
	Int -> (Ptr P -> IO [P]) -> IO [P]
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
cic \Ptr P
pps -> do
		PL (U11 CreateInfo) ss -> ([CreateInfo] -> IO ()) -> IO ()
forall (cias :: [(Maybe (*), [(Maybe (*), ShaderKind, [*])],
                  Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*),
                  Maybe (*), Maybe (*), Maybe (*))])
       r.
CreateInfoListToCore cias =>
PL (U11 CreateInfo) cias -> ([CreateInfo] -> IO r) -> IO ()
forall r. PL (U11 CreateInfo) ss -> ([CreateInfo] -> IO r) -> IO ()
createInfoListToCore PL (U11 CreateInfo) ss
cis \[CreateInfo]
ccis -> Int -> (Ptr CreateInfo -> IO ()) -> IO ()
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
cic \Ptr CreateInfo
pcis ->
			Ptr CreateInfo -> [CreateInfo] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr CreateInfo
pcis [CreateInfo]
ccis IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
			M A mn' -> (Ptr A -> IO ()) -> IO ()
forall (ma :: Maybe (*)) b. M A ma -> (Ptr A -> IO b) -> IO ()
AllocationCallbacks.mToCore M A mn'
mac \Ptr A
pac -> do
				r <- D
-> Ptr PTag
-> Word32
-> Ptr CreateInfo
-> Ptr A
-> Ptr P
-> IO Int32
C.create D
dvc Ptr PTag
cc (Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
cic) Ptr CreateInfo
pcis Ptr A
pac Ptr P
pps
				throwUnlessSuccess $ Result r
		Int -> Ptr P -> IO [P]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
cic Ptr P
pps

recreateRaw :: CreateInfoListToCore ss =>
	Device.D -> Maybe Cache.P ->
	HeteroParList.PL (U11 CreateInfo) ss ->
	TPMaybe.M AllocationCallbacks.A mc ->
	[IORef Pipeline.C.P] -> IO ()
recreateRaw :: forall (ss :: [(Maybe (*), [(Maybe (*), ShaderKind, [*])],
                Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*), Maybe (*),
                Maybe (*), Maybe (*), Maybe (*))])
       (mc :: Maybe (*)).
CreateInfoListToCore ss =>
D
-> Maybe P
-> PL (U11 CreateInfo) ss
-> M A mc
-> [IORef P]
-> IO ()
recreateRaw D
dvc Maybe P
mc PL (U11 CreateInfo) ss
cis M A mc
macc [IORef P]
rs = do
	os <- IORef P -> IO P
forall a. IORef a -> IO a
readIORef (IORef P -> IO P) -> [IORef P] -> IO [P]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
`mapM` [IORef P]
rs
	ns <- createRaw dvc mc cis macc
	zipWithM_ writeIORef rs ns
	(\P
o -> D -> P -> M A mc -> IO ()
forall (md :: Maybe (*)). D -> P -> M A md -> IO ()
destroyRaw D
dvc P
o M A mc
macc) `mapM_` os

destroyGs :: Device.D -> [G] -> TPMaybe.M AllocationCallbacks.A md -> IO ()
destroyGs :: forall (md :: Maybe (*)). D -> [G] -> M A md -> IO ()
destroyGs D
dvc [G]
gs M A md
mac = ((\P
g -> P -> IO G
gFromCore P
g IO G -> (G -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \G
g' -> D -> G -> M A md -> IO ()
forall (mn :: Maybe (*)). D -> G -> M A mn -> IO ()
destroy D
dvc G
g' M A md
mac) (P -> IO ()) -> [P] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
`mapM_`) ([P] -> IO ()) -> IO [P] -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [G] -> IO [P]
gListToCore [G]
gs

destroy :: Device.D -> G -> TPMaybe.M AllocationCallbacks.A mn -> IO ()
destroy :: forall (mn :: Maybe (*)). D -> G -> M A mn -> IO ()
destroy (Device.D D
dvc) G
g M A mn
mac = G -> IO P
gToCore G
g IO P -> (P -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \P
p ->
	M A mn -> (Ptr A -> IO ()) -> IO ()
forall (ma :: Maybe (*)) b. M A ma -> (Ptr A -> IO b) -> IO ()
AllocationCallbacks.mToCore M A mn
mac ((Ptr A -> IO ()) -> IO ()) -> (Ptr A -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ D -> P -> Ptr A -> IO ()
Pipeline.C.destroy D
dvc P
p

destroyRaw ::
	Device.D -> Pipeline.C.P -> TPMaybe.M AllocationCallbacks.A md -> IO ()
destroyRaw :: forall (md :: Maybe (*)). D -> P -> M A md -> IO ()
destroyRaw (Device.D D
dvc) P
p M A md
macd =
	M A md -> (Ptr A -> IO ()) -> IO ()
forall (ma :: Maybe (*)) b. M A ma -> (Ptr A -> IO b) -> IO ()
AllocationCallbacks.mToCore M A md
macd ((Ptr A -> IO ()) -> IO ()) -> (Ptr A -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ D -> P -> Ptr A -> IO ()
Pipeline.C.destroy D
dvc P
p