{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE BlockArguments, LambdaCase, OverloadedStrings #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts, FlexibleInstances, UndecidableInstances #-}
{-# LANGUAGE PatternSynonyms, ViewPatterns #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}

module Gpu.Vulkan.Internal (

	-- * INFO

	-- ** ApplicationInfo

	M.ApplicationInfo(..),
	M.ApiVersion, M.makeApiVersion, M.fromApiVersion,
	M.Variant, M.Major, M.Minor, M.Patch,
	M.apiVersion_1_0, M.apiVersion_1_1, M.apiVersion_1_2, M.apiVersion_1_3,

	-- ** SubmitInfo

	SubmitInfo(..),
	SubmitInfoListToMiddle(..), SemaphorePipelineStageFlags(..),

	SubmitInfo2(..), SubmitInfo2ListToMiddle(..),

	-- * PROPERTIES

	LayerProperties(..), layerPropertiesFromMiddle,
	M.FormatProperties(..),

	-- * NAME

	LayerName(..), layerKhronosValidation,

	-- * PIPELINE VALUES

	-- ** ViewPort

	M.Viewport, pattern M.Viewport,
	M.viewportX, M.viewportY, M.viewportWidth, M.viewportHeight,
	M.viewportMinDepth, M.viewportMaxDepth,

	-- ** StencilOpState

	M.StencilOpState(..),

	-- ** ClearValue

	M.ClearValue(..), M.ClearValueListToCore,

	-- *** ClearType

	M.ClearType(..), M.ClearColorType(..),

	-- *** ClearColorValue

	M.ClearColorValueToCore,

	-- *** ClearDepthStencilValue

	M.ClearDepthStencilValue, pattern M.ClearDepthStencilValue,
	M.clearDepthStencilValueDepth, M.clearDepthStencilValueStencil,

	-- * RECT, OFFSET AND EXTENT

	-- ** Rect

	M.Rect2d, pattern M.Rect2d, M.rect2dExtent, M.rect2dOffset,

	-- ** Offset

	M.Offset2d, pattern M.Offset2d, M.offset2dX, M.offset2dY,
	M.Offset3d, pattern M.Offset3d, M.offset3dX, M.offset3dY, M.offset3dZ,

	-- ** Extent

	M.Extent2d, pattern M.Extent2d,
	M.extent2dWidth, M.extent2dHeight,

	M.Extent3d, pattern M.Extent3d,
	M.extent3dWidth, M.extent3dHeight, M.extent3dDepth,

	-- * OTHERS

	M.Size(..),

	DependencyInfo(..), dependencyInfoToMiddle,
	BlitImageInfo2(..), blitImageInfo2ToMiddle,

	Sec(..), pattern NanoSec, pattern MicroSec, pattern MilliSec,

	M.remainingMipLevels, M.remainingArrayLayers

	) where

import Foreign.Storable.PeekPoke
import Data.Kind
import Data.TypeLevel.Tuple.Uncurry
import Data.TypeLevel.Tuple.MapIndex qualified as TMapIndex
import Data.TypeLevel.Maybe qualified as TMaybe
import Data.HeteroParList qualified as HeteroParList
import Data.HeteroParList qualified as HPList
import Data.HeteroParList (pattern (:**))
import Data.Word
import Data.Fixed
import Data.Fixed.Generic qualified as FixedG
import Data.Text qualified as T

import qualified Gpu.Vulkan.Middle as M
import Gpu.Vulkan.Enum
import qualified Gpu.Vulkan.Semaphore.Type as Semaphore
import qualified Gpu.Vulkan.Semaphore.Internal as Semaphore
import qualified Gpu.Vulkan.Semaphore.Middle as Semaphore.M
import qualified Gpu.Vulkan.CommandBuffer.Type as CommandBuffer
import qualified Gpu.Vulkan.Pipeline.Enum as Pipeline

import Gpu.Vulkan.Memory.Middle qualified as Memory.M
import {-# SOURCE #-} Gpu.Vulkan.Buffer.Internal qualified as Buffer
import Gpu.Vulkan.Image.Internal qualified as Image
import Gpu.Vulkan.Image.Enum qualified as Image

import Gpu.Vulkan.CommandBuffer.Internal qualified as CommandBuffer

data SubmitInfo n sss ss ssss = SubmitInfo {
	forall (n :: Maybe (*)) (sss :: [*]) (ss :: [*]) (ssss :: [*]).
SubmitInfo n sss ss ssss -> M n
submitInfoNext :: TMaybe.M n,
	forall (n :: Maybe (*)) (sss :: [*]) (ss :: [*]) (ssss :: [*]).
SubmitInfo n sss ss ssss -> PL SemaphorePipelineStageFlags sss
submitInfoWaitSemaphoreDstStageMasks ::
		HeteroParList.PL SemaphorePipelineStageFlags sss,
	forall (n :: Maybe (*)) (sss :: [*]) (ss :: [*]) (ssss :: [*]).
SubmitInfo n sss ss ssss -> PL C ss
submitInfoCommandBuffers :: HeteroParList.PL CommandBuffer.C ss,
	forall (n :: Maybe (*)) (sss :: [*]) (ss :: [*]) (ssss :: [*]).
SubmitInfo n sss ss ssss -> PL S ssss
submitInfoSignalSemaphores ::
		HeteroParList.PL Semaphore.S ssss }

class M.SubmitInfoListToCore (MiddleNextList ns3s2s4) => SubmitInfoListToMiddle
	(ns3s2s4 :: [(Maybe Type, [Type], [Type], [Type])]) where
	type MiddleNextList ns3s2s4 :: [Maybe Type]
	submitInfoListToMiddle ::
		HeteroParList.PL (U4 SubmitInfo) ns3s2s4 ->
		HeteroParList.PL M.SubmitInfo (MiddleNextList ns3s2s4)

instance SubmitInfoListToMiddle '[] where
	type MiddleNextList '[] = '[]
	submitInfoListToMiddle :: PL (U4 SubmitInfo) '[] -> PL SubmitInfo (MiddleNextList '[])
submitInfoListToMiddle PL (U4 SubmitInfo) '[]
HeteroParList.Nil = PL SubmitInfo '[]
PL SubmitInfo (MiddleNextList '[])
forall {k} (t :: k -> *). PL t '[]
HeteroParList.Nil

instance (
	WithPoked (TMaybe.M n),
	SubmitInfoListToMiddle nssvsss ) =>
	SubmitInfoListToMiddle ('(n, sss, svss, ssss) ': nssvsss) where
	type MiddleNextList ('(n, sss, svss, ssss) ': nssvsss) =
		n ': MiddleNextList nssvsss
	submitInfoListToMiddle :: PL (U4 SubmitInfo) ('(n, sss, svss, ssss) : nssvsss)
-> PL SubmitInfo (MiddleNextList ('(n, sss, svss, ssss) : nssvsss))
submitInfoListToMiddle (U4 SubmitInfo s1 s2 s3 s4
si :** PL (U4 SubmitInfo) ss1
sis) =
		SubmitInfo s1 s2 s3 s4 -> SubmitInfo s1
forall (n :: Maybe (*)) (sss :: [*]) (svss :: [*]) (ssss :: [*]).
SubmitInfo n sss svss ssss -> SubmitInfo n
submitInfoToMiddle SubmitInfo s1 s2 s3 s4
si SubmitInfo s1
-> PL SubmitInfo (MiddleNextList nssvsss)
-> PL SubmitInfo (s1 : MiddleNextList nssvsss)
forall {k} (t :: k -> *) (s :: k) (ss1 :: [k]).
t s -> PL t ss1 -> PL t (s : ss1)
:** PL (U4 SubmitInfo) ss1 -> PL SubmitInfo (MiddleNextList ss1)
forall (ns3s2s4 :: [(Maybe (*), [*], [*], [*])]).
SubmitInfoListToMiddle ns3s2s4 =>
PL (U4 SubmitInfo) ns3s2s4
-> PL SubmitInfo (MiddleNextList ns3s2s4)
submitInfoListToMiddle PL (U4 SubmitInfo) ss1
sis

submitInfoToMiddle ::
	SubmitInfo n sss svss ssss -> M.SubmitInfo n
submitInfoToMiddle :: forall (n :: Maybe (*)) (sss :: [*]) (svss :: [*]) (ssss :: [*]).
SubmitInfo n sss svss ssss -> SubmitInfo n
submitInfoToMiddle SubmitInfo {
	submitInfoNext :: forall (n :: Maybe (*)) (sss :: [*]) (ss :: [*]) (ssss :: [*]).
SubmitInfo n sss ss ssss -> M n
submitInfoNext = M n
mnxt,
	submitInfoWaitSemaphoreDstStageMasks :: forall (n :: Maybe (*)) (sss :: [*]) (ss :: [*]) (ssss :: [*]).
SubmitInfo n sss ss ssss -> PL SemaphorePipelineStageFlags sss
submitInfoWaitSemaphoreDstStageMasks =
		PL SemaphorePipelineStageFlags sss -> [(S, StageFlags)]
forall (sss :: [*]).
PL SemaphorePipelineStageFlags sss -> [(S, StageFlags)]
semaphorePipelineStageFlagsToMiddle -> [(S, StageFlags)]
wsdsms,
	submitInfoCommandBuffers :: forall (n :: Maybe (*)) (sss :: [*]) (ss :: [*]) (ssss :: [*]).
SubmitInfo n sss ss ssss -> PL C ss
submitInfoCommandBuffers = (forall s. C s -> C) -> PL C svss -> [C]
forall k (t :: k -> *) a (ss :: [k]).
(forall (s :: k). t s -> a) -> PL t ss -> [a]
HeteroParList.toList (\C s
x -> C s -> C
forall s. C s -> C
CommandBuffer.unC C s
x) -> [C]
cbs,
	submitInfoSignalSemaphores :: forall (n :: Maybe (*)) (sss :: [*]) (ss :: [*]) (ssss :: [*]).
SubmitInfo n sss ss ssss -> PL S ssss
submitInfoSignalSemaphores =
		(forall s. S s -> S) -> PL S ssss -> [S]
forall k (t :: k -> *) a (ss :: [k]).
(forall (s :: k). t s -> a) -> PL t ss -> [a]
HeteroParList.toList (\(Semaphore.S S
s) -> S
s) -> [S]
ssmprs
	} = M.SubmitInfo {
	submitInfoNext :: M n
M.submitInfoNext = M n
mnxt,
	submitInfoWaitSemaphoreDstStageMasks :: [(S, StageFlags)]
M.submitInfoWaitSemaphoreDstStageMasks = [(S, StageFlags)]
wsdsms,
	submitInfoCommandBuffers :: [C]
M.submitInfoCommandBuffers = [C]
cbs,
	submitInfoSignalSemaphores :: [S]
M.submitInfoSignalSemaphores = [S]
ssmprs }

data SemaphorePipelineStageFlags ss =
	SemaphorePipelineStageFlags (Semaphore.S ss) Pipeline.StageFlags
	deriving Int -> SemaphorePipelineStageFlags ss -> ShowS
[SemaphorePipelineStageFlags ss] -> ShowS
SemaphorePipelineStageFlags ss -> String
(Int -> SemaphorePipelineStageFlags ss -> ShowS)
-> (SemaphorePipelineStageFlags ss -> String)
-> ([SemaphorePipelineStageFlags ss] -> ShowS)
-> Show (SemaphorePipelineStageFlags ss)
forall ss. Int -> SemaphorePipelineStageFlags ss -> ShowS
forall ss. [SemaphorePipelineStageFlags ss] -> ShowS
forall ss. SemaphorePipelineStageFlags ss -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall ss. Int -> SemaphorePipelineStageFlags ss -> ShowS
showsPrec :: Int -> SemaphorePipelineStageFlags ss -> ShowS
$cshow :: forall ss. SemaphorePipelineStageFlags ss -> String
show :: SemaphorePipelineStageFlags ss -> String
$cshowList :: forall ss. [SemaphorePipelineStageFlags ss] -> ShowS
showList :: [SemaphorePipelineStageFlags ss] -> ShowS
Show

data SubmitInfo2 mn wsas cbas ssas = SubmitInfo2 {
	forall (mn :: Maybe (*)) (wsas :: [(Maybe (*), *)])
       (cbas :: [(Maybe (*), *)]) (ssas :: [(Maybe (*), *)]).
SubmitInfo2 mn wsas cbas ssas -> M mn
submitInfo2Next :: TMaybe.M mn,
	forall (mn :: Maybe (*)) (wsas :: [(Maybe (*), *)])
       (cbas :: [(Maybe (*), *)]) (ssas :: [(Maybe (*), *)]).
SubmitInfo2 mn wsas cbas ssas -> SubmitFlags
submitInfo2Flags :: SubmitFlags,
	forall (mn :: Maybe (*)) (wsas :: [(Maybe (*), *)])
       (cbas :: [(Maybe (*), *)]) (ssas :: [(Maybe (*), *)]).
SubmitInfo2 mn wsas cbas ssas -> PL (U2 SubmitInfo) wsas
submitInfo2WaitSemaphoreInfos ::
		HPList.PL (U2 Semaphore.SubmitInfo) wsas,
	forall (mn :: Maybe (*)) (wsas :: [(Maybe (*), *)])
       (cbas :: [(Maybe (*), *)]) (ssas :: [(Maybe (*), *)]).
SubmitInfo2 mn wsas cbas ssas -> PL (U2 SubmitInfo) cbas
submitInfo2CommandBufferInfos ::
		HPList.PL (U2 CommandBuffer.SubmitInfo) cbas,
	forall (mn :: Maybe (*)) (wsas :: [(Maybe (*), *)])
       (cbas :: [(Maybe (*), *)]) (ssas :: [(Maybe (*), *)]).
SubmitInfo2 mn wsas cbas ssas -> PL (U2 SubmitInfo) ssas
submitInfo2SignalSemaphoreInfos ::
		HPList.PL (U2 Semaphore.SubmitInfo) ssas }

class M.SubmitInfo2ListToCore (SubmitInfo2ArgsListToMiddle sias) => SubmitInfo2ListToMiddle sias where
	type family SubmitInfo2ArgsListToMiddle sias ::
		[(Maybe Type, [Maybe Type], [Maybe Type], [Maybe Type])]
	submitInfo2ListToMiddle ::
		HPList.PL (U4 SubmitInfo2) sias ->
		HPList.PL (U4 M.SubmitInfo2) (SubmitInfo2ArgsListToMiddle sias)

instance SubmitInfo2ListToMiddle '[] where
	type SubmitInfo2ArgsListToMiddle '[] = '[]
	submitInfo2ListToMiddle :: PL (U4 SubmitInfo2) '[]
-> PL (U4 SubmitInfo2) (SubmitInfo2ArgsListToMiddle '[])
submitInfo2ListToMiddle PL (U4 SubmitInfo2) '[]
HPList.Nil = PL (U4 SubmitInfo2) '[]
PL (U4 SubmitInfo2) (SubmitInfo2ArgsListToMiddle '[])
forall {k} (t :: k -> *). PL t '[]
HPList.Nil

instance (
	WithPoked (TMaybe.M mn),
	Semaphore.SubmitInfoListToMiddle wsas,
	CommandBuffer.SubmitInfoListToMiddle cbas,
	Semaphore.SubmitInfoListToMiddle ssas,
	SubmitInfo2ListToMiddle sias ) =>
	SubmitInfo2ListToMiddle ('(mn, wsas, cbas, ssas) ': sias) where
	type SubmitInfo2ArgsListToMiddle ('(mn, wsas, cbas, ssas) ': sias) =
		'(mn,	TMapIndex.M0_2 wsas,
			TMapIndex.M0_2 cbas,
			TMapIndex.M0_2 ssas) ': SubmitInfo2ArgsListToMiddle sias
	submitInfo2ListToMiddle :: PL (U4 SubmitInfo2) ('(mn, wsas, cbas, ssas) : sias)
-> PL
     (U4 SubmitInfo2)
     (SubmitInfo2ArgsListToMiddle ('(mn, wsas, cbas, ssas) : sias))
submitInfo2ListToMiddle (U4 SubmitInfo2 s1 s2 s3 s4
si :** PL (U4 SubmitInfo2) ss1
sis) =
		SubmitInfo2 s1 (M0_2 wsas) (M0_2 cbas) (M0_2 ssas)
-> U4 SubmitInfo2 '(s1, M0_2 wsas, M0_2 cbas, M0_2 ssas)
forall {k} {k1} {k2} {k3} (t :: k -> k1 -> k2 -> k3 -> *) (s1 :: k)
       (s2 :: k1) (s3 :: k2) (s4 :: k3).
t s1 s2 s3 s4 -> U4 t '(s1, s2, s3, s4)
U4 (SubmitInfo2 s1 s2 s3 s4
-> SubmitInfo2 s1 (M0_2 s2) (M0_2 s3) (M0_2 s4)
forall (wsas :: [(Maybe (*), *)]) (cbas :: [(Maybe (*), *)])
       (ssas :: [(Maybe (*), *)]) (mn :: Maybe (*)).
(SubmitInfoListToMiddle wsas, SubmitInfoListToMiddle cbas,
 SubmitInfoListToMiddle ssas) =>
SubmitInfo2 mn wsas cbas ssas
-> SubmitInfo2 mn (M0_2 wsas) (M0_2 cbas) (M0_2 ssas)
submitInfo2ToMiddle SubmitInfo2 s1 s2 s3 s4
si) U4 SubmitInfo2 '(s1, M0_2 wsas, M0_2 cbas, M0_2 ssas)
-> PL (U4 SubmitInfo2) (SubmitInfo2ArgsListToMiddle sias)
-> PL
     (U4 SubmitInfo2)
     ('(s1, M0_2 wsas, M0_2 cbas, M0_2 ssas)
        : SubmitInfo2ArgsListToMiddle sias)
forall {k} (t :: k -> *) (s :: k) (ss1 :: [k]).
t s -> PL t ss1 -> PL t (s : ss1)
:** PL (U4 SubmitInfo2) ss1
-> PL (U4 SubmitInfo2) (SubmitInfo2ArgsListToMiddle ss1)
forall (sias :: [(Maybe (*), [(Maybe (*), *)], [(Maybe (*), *)],
                  [(Maybe (*), *)])]).
SubmitInfo2ListToMiddle sias =>
PL (U4 SubmitInfo2) sias
-> PL (U4 SubmitInfo2) (SubmitInfo2ArgsListToMiddle sias)
submitInfo2ListToMiddle PL (U4 SubmitInfo2) ss1
sis

{-
type family SubmitInfo2ArgsListToMiddle sias where
	SubmitInfo2ArgsListToMiddle '[] = '[]
	SubmitInfo2ArgsListToMiddle ('(mn, wsas, cbas, ssas) ': sias) =
		'(mn,	TMapIndex.M0_2 wsas,
			TMapIndex.M0_2 cbas,
			TMapIndex.M0_2 ssas) ': SubmitInfo2ArgsListToMiddle sias
			-}

submitInfo2ToMiddle :: (
	Semaphore.SubmitInfoListToMiddle wsas,
	CommandBuffer.SubmitInfoListToMiddle cbas,
	Semaphore.SubmitInfoListToMiddle ssas ) =>
	SubmitInfo2 mn wsas cbas ssas ->
	M.SubmitInfo2 mn (TMapIndex.M0_2 wsas)
		(TMapIndex.M0_2 cbas) (TMapIndex.M0_2 ssas)
submitInfo2ToMiddle :: forall (wsas :: [(Maybe (*), *)]) (cbas :: [(Maybe (*), *)])
       (ssas :: [(Maybe (*), *)]) (mn :: Maybe (*)).
(SubmitInfoListToMiddle wsas, SubmitInfoListToMiddle cbas,
 SubmitInfoListToMiddle ssas) =>
SubmitInfo2 mn wsas cbas ssas
-> SubmitInfo2 mn (M0_2 wsas) (M0_2 cbas) (M0_2 ssas)
submitInfo2ToMiddle SubmitInfo2 {
	submitInfo2Next :: forall (mn :: Maybe (*)) (wsas :: [(Maybe (*), *)])
       (cbas :: [(Maybe (*), *)]) (ssas :: [(Maybe (*), *)]).
SubmitInfo2 mn wsas cbas ssas -> M mn
submitInfo2Next = M mn
mnxt,
	submitInfo2Flags :: forall (mn :: Maybe (*)) (wsas :: [(Maybe (*), *)])
       (cbas :: [(Maybe (*), *)]) (ssas :: [(Maybe (*), *)]).
SubmitInfo2 mn wsas cbas ssas -> SubmitFlags
submitInfo2Flags = SubmitFlags
fs,
	submitInfo2WaitSemaphoreInfos :: forall (mn :: Maybe (*)) (wsas :: [(Maybe (*), *)])
       (cbas :: [(Maybe (*), *)]) (ssas :: [(Maybe (*), *)]).
SubmitInfo2 mn wsas cbas ssas -> PL (U2 SubmitInfo) wsas
submitInfo2WaitSemaphoreInfos = PL (U2 SubmitInfo) wsas
wss,
	submitInfo2CommandBufferInfos :: forall (mn :: Maybe (*)) (wsas :: [(Maybe (*), *)])
       (cbas :: [(Maybe (*), *)]) (ssas :: [(Maybe (*), *)]).
SubmitInfo2 mn wsas cbas ssas -> PL (U2 SubmitInfo) cbas
submitInfo2CommandBufferInfos = PL (U2 SubmitInfo) cbas
cbs,
	submitInfo2SignalSemaphoreInfos :: forall (mn :: Maybe (*)) (wsas :: [(Maybe (*), *)])
       (cbas :: [(Maybe (*), *)]) (ssas :: [(Maybe (*), *)]).
SubmitInfo2 mn wsas cbas ssas -> PL (U2 SubmitInfo) ssas
submitInfo2SignalSemaphoreInfos = PL (U2 SubmitInfo) ssas
sss
	} = M.SubmitInfo2 {
	submitInfo2Next :: M mn
M.submitInfo2Next = M mn
mnxt,
	submitInfo2Flags :: SubmitFlags
M.submitInfo2Flags = SubmitFlags
fs,
	submitInfo2WaitSemaphoreInfos :: PL SubmitInfo (M0_2 wsas)
M.submitInfo2WaitSemaphoreInfos =
		PL (U2 SubmitInfo) wsas -> PL SubmitInfo (M0_2 wsas)
forall (mnsss :: [(Maybe (*), *)]).
SubmitInfoListToMiddle mnsss =>
PL (U2 SubmitInfo) mnsss -> PL SubmitInfo (M0_2 mnsss)
Semaphore.submitInfoListToMiddle PL (U2 SubmitInfo) wsas
wss,
	submitInfo2CommandBufferInfos :: PL SubmitInfo (M0_2 cbas)
M.submitInfo2CommandBufferInfos =
		PL (U2 SubmitInfo) cbas -> PL SubmitInfo (M0_2 cbas)
forall (mnscs :: [(Maybe (*), *)]).
SubmitInfoListToMiddle mnscs =>
PL (U2 SubmitInfo) mnscs -> PL SubmitInfo (M0_2 mnscs)
CommandBuffer.submitInfoListToMiddle PL (U2 SubmitInfo) cbas
cbs,
	submitInfo2SignalSemaphoreInfos :: PL SubmitInfo (M0_2 ssas)
M.submitInfo2SignalSemaphoreInfos =
		PL (U2 SubmitInfo) ssas -> PL SubmitInfo (M0_2 ssas)
forall (mnsss :: [(Maybe (*), *)]).
SubmitInfoListToMiddle mnsss =>
PL (U2 SubmitInfo) mnsss -> PL SubmitInfo (M0_2 mnsss)
Semaphore.submitInfoListToMiddle PL (U2 SubmitInfo) ssas
sss }

-- deriving instance (Show n, Show (HeteroParList SemaphorePipelineStageFlags sss)) =>
--	Show (SubmitInfo n sss s vs)

-- deriving instance Show (HeteroParList Semaphore.S ss)

semaphorePipelineStageFlagsToMiddle ::
	HeteroParList.PL SemaphorePipelineStageFlags sss ->
	[(Semaphore.M.S, Pipeline.StageFlags)]
semaphorePipelineStageFlagsToMiddle :: forall (sss :: [*]).
PL SemaphorePipelineStageFlags sss -> [(S, StageFlags)]
semaphorePipelineStageFlagsToMiddle = (forall s. SemaphorePipelineStageFlags s -> (S, StageFlags))
-> PL SemaphorePipelineStageFlags sss -> [(S, StageFlags)]
forall k (t :: k -> *) a (ss :: [k]).
(forall (s :: k). t s -> a) -> PL t ss -> [a]
HeteroParList.toList
	\(SemaphorePipelineStageFlags (Semaphore.S S
s) StageFlags
psfs) -> (S
s, StageFlags
psfs)

class SemaphorePipelineStageFlagsFromMiddle sss where
	semaphorePipelineStageFlagsFromMiddle ::
		[(Semaphore.M.S, Pipeline.StageFlags)] ->
		HeteroParList.PL SemaphorePipelineStageFlags sss

instance SemaphorePipelineStageFlagsFromMiddle '[] where
	semaphorePipelineStageFlagsFromMiddle :: [(S, StageFlags)] -> PL SemaphorePipelineStageFlags '[]
semaphorePipelineStageFlagsFromMiddle = \case
		[] -> PL SemaphorePipelineStageFlags '[]
forall {k} (t :: k -> *). PL t '[]
HeteroParList.Nil
		[(S, StageFlags)]
_ -> String -> PL SemaphorePipelineStageFlags '[]
forall a. HasCallStack => String -> a
error (String -> PL SemaphorePipelineStageFlags '[])
-> String -> PL SemaphorePipelineStageFlags '[]
forall a b. (a -> b) -> a -> b
$
			String
"semaphorePipelineStageFlagsFromMiddle @'[] xs: " String -> ShowS
forall a. [a] -> [a] -> [a]
++
			String
"xs should be null"

instance SemaphorePipelineStageFlagsFromMiddle sss =>
	SemaphorePipelineStageFlagsFromMiddle (ss ': sss) where
	semaphorePipelineStageFlagsFromMiddle :: [(S, StageFlags)] -> PL SemaphorePipelineStageFlags (ss : sss)
semaphorePipelineStageFlagsFromMiddle = \case
		(S
s, StageFlags
psfs) : [(S, StageFlags)]
spsfss ->
			S ss -> StageFlags -> SemaphorePipelineStageFlags ss
forall ss. S ss -> StageFlags -> SemaphorePipelineStageFlags ss
SemaphorePipelineStageFlags (S -> S ss
forall s. S -> S s
Semaphore.S S
s) StageFlags
psfs SemaphorePipelineStageFlags ss
-> PL SemaphorePipelineStageFlags sss
-> PL SemaphorePipelineStageFlags (ss : sss)
forall {k} (t :: k -> *) (s :: k) (ss1 :: [k]).
t s -> PL t ss1 -> PL t (s : ss1)
:**
			[(S, StageFlags)] -> PL SemaphorePipelineStageFlags sss
forall (sss :: [*]).
SemaphorePipelineStageFlagsFromMiddle sss =>
[(S, StageFlags)] -> PL SemaphorePipelineStageFlags sss
semaphorePipelineStageFlagsFromMiddle [(S, StageFlags)]
spsfss
		[] -> String -> PL SemaphorePipelineStageFlags (ss : sss)
forall a. HasCallStack => String -> a
error (String -> PL SemaphorePipelineStageFlags (ss : sss))
-> String -> PL SemaphorePipelineStageFlags (ss : sss)
forall a b. (a -> b) -> a -> b
$
			String
"semaphorePipelineStageFlagsFromMiddle " String -> ShowS
forall a. [a] -> [a] -> [a]
++
			String
"@(ss ': sss) xs: xs should not be null"

data LayerProperties = LayerProperties {
	LayerProperties -> LayerName
layerPropertiesLayerName :: LayerName,
	LayerProperties -> ApiVersion
layerPropertiesSpecVersion :: M.ApiVersion,
	LayerProperties -> ApiVersion
layerPropertiesImplementationVersion :: M.ApiVersion,
	LayerProperties -> Text
layerPropertiesDescription :: T.Text }
	deriving Int -> LayerProperties -> ShowS
[LayerProperties] -> ShowS
LayerProperties -> String
(Int -> LayerProperties -> ShowS)
-> (LayerProperties -> String)
-> ([LayerProperties] -> ShowS)
-> Show LayerProperties
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LayerProperties -> ShowS
showsPrec :: Int -> LayerProperties -> ShowS
$cshow :: LayerProperties -> String
show :: LayerProperties -> String
$cshowList :: [LayerProperties] -> ShowS
showList :: [LayerProperties] -> ShowS
Show

layerPropertiesFromMiddle :: M.LayerProperties -> LayerProperties
layerPropertiesFromMiddle :: LayerProperties -> LayerProperties
layerPropertiesFromMiddle M.LayerProperties {
	layerPropertiesLayerName :: LayerProperties -> Text
M.layerPropertiesLayerName = Text
ln,
	layerPropertiesSpecVersion :: LayerProperties -> ApiVersion
M.layerPropertiesSpecVersion = ApiVersion
sv,
	layerPropertiesImplementationVersion :: LayerProperties -> ApiVersion
M.layerPropertiesImplementationVersion = ApiVersion
iv,
	layerPropertiesDescription :: LayerProperties -> Text
M.layerPropertiesDescription = Text
dsc } = LayerProperties {
	layerPropertiesLayerName :: LayerName
layerPropertiesLayerName = Text -> LayerName
LayerName Text
ln,
	layerPropertiesSpecVersion :: ApiVersion
layerPropertiesSpecVersion = ApiVersion
sv,
	layerPropertiesImplementationVersion :: ApiVersion
layerPropertiesImplementationVersion = ApiVersion
iv,
	layerPropertiesDescription :: Text
layerPropertiesDescription = Text
dsc }

newtype LayerName = LayerName { LayerName -> Text
unLayerName :: T.Text } deriving (Int -> LayerName -> ShowS
[LayerName] -> ShowS
LayerName -> String
(Int -> LayerName -> ShowS)
-> (LayerName -> String)
-> ([LayerName] -> ShowS)
-> Show LayerName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LayerName -> ShowS
showsPrec :: Int -> LayerName -> ShowS
$cshow :: LayerName -> String
show :: LayerName -> String
$cshowList :: [LayerName] -> ShowS
showList :: [LayerName] -> ShowS
Show, LayerName -> LayerName -> Bool
(LayerName -> LayerName -> Bool)
-> (LayerName -> LayerName -> Bool) -> Eq LayerName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LayerName -> LayerName -> Bool
== :: LayerName -> LayerName -> Bool
$c/= :: LayerName -> LayerName -> Bool
/= :: LayerName -> LayerName -> Bool
Eq)

layerKhronosValidation :: LayerName
layerKhronosValidation :: LayerName
layerKhronosValidation = Text -> LayerName
LayerName Text
"VK_LAYER_KHRONOS_validation"

data DependencyInfo mn mbas bmbas imbas = DependencyInfo {
	forall (mn :: Maybe (*)) (mbas :: [Maybe (*)])
       (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]).
DependencyInfo mn mbas bmbas imbas -> M mn
dependencyInfoNext :: TMaybe.M mn,
	forall (mn :: Maybe (*)) (mbas :: [Maybe (*)])
       (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]).
DependencyInfo mn mbas bmbas imbas -> DependencyFlags
dependencyInfoDependencyFlags :: DependencyFlags,
	forall (mn :: Maybe (*)) (mbas :: [Maybe (*)])
       (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]).
DependencyInfo mn mbas bmbas imbas -> PL Barrier2 mbas
dependencyInfoMemoryBarriers :: HPList.PL Memory.M.Barrier2 mbas,
	forall (mn :: Maybe (*)) (mbas :: [Maybe (*)])
       (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]).
DependencyInfo mn mbas bmbas imbas -> PL (U5 MemoryBarrier2) bmbas
dependencyInfoBufferMemoryBarriers ::
		HPList.PL (U5 Buffer.MemoryBarrier2) bmbas,
	forall (mn :: Maybe (*)) (mbas :: [Maybe (*)])
       (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]).
DependencyInfo mn mbas bmbas imbas -> PL (U5 MemoryBarrier2) imbas
dependencyInfoImageMemoryBarriers ::
		HPList.PL (U5 Image.MemoryBarrier2) imbas }

dependencyInfoToMiddle :: (
	Buffer.MemoryBarrier2ListToMiddle bmbas,
	Image.MemoryBarrier2ListToMiddle imbas ) =>
	DependencyInfo mn mbas bmbas imbas ->
	M.DependencyInfo mn mbas (TMapIndex.M0_5 bmbas) (TMapIndex.M0_5 imbas)
dependencyInfoToMiddle :: forall (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]) (mn :: Maybe (*))
       (mbas :: [Maybe (*)]).
(MemoryBarrier2ListToMiddle bmbas,
 MemoryBarrier2ListToMiddle imbas) =>
DependencyInfo mn mbas bmbas imbas
-> DependencyInfo mn mbas (M0_5 bmbas) (M0_5 imbas)
dependencyInfoToMiddle DependencyInfo {
	dependencyInfoNext :: forall (mn :: Maybe (*)) (mbas :: [Maybe (*)])
       (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]).
DependencyInfo mn mbas bmbas imbas -> M mn
dependencyInfoNext = M mn
mnxt,
	dependencyInfoDependencyFlags :: forall (mn :: Maybe (*)) (mbas :: [Maybe (*)])
       (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]).
DependencyInfo mn mbas bmbas imbas -> DependencyFlags
dependencyInfoDependencyFlags = DependencyFlags
fs,
	dependencyInfoMemoryBarriers :: forall (mn :: Maybe (*)) (mbas :: [Maybe (*)])
       (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]).
DependencyInfo mn mbas bmbas imbas -> PL Barrier2 mbas
dependencyInfoMemoryBarriers = PL Barrier2 mbas
mbs,
	dependencyInfoBufferMemoryBarriers :: forall (mn :: Maybe (*)) (mbas :: [Maybe (*)])
       (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]).
DependencyInfo mn mbas bmbas imbas -> PL (U5 MemoryBarrier2) bmbas
dependencyInfoBufferMemoryBarriers = PL (U5 MemoryBarrier2) bmbas
bmbs,
	dependencyInfoImageMemoryBarriers :: forall (mn :: Maybe (*)) (mbas :: [Maybe (*)])
       (bmbas :: [(Maybe (*), *, *, Symbol, O)])
       (imbas :: [(Maybe (*), *, *, Symbol, Format)]).
DependencyInfo mn mbas bmbas imbas -> PL (U5 MemoryBarrier2) imbas
dependencyInfoImageMemoryBarriers = PL (U5 MemoryBarrier2) imbas
imbs
	} = M.DependencyInfo {
	dependencyInfoNext :: M mn
M.dependencyInfoNext = M mn
mnxt,
	dependencyInfoDependencyFlags :: DependencyFlags
M.dependencyInfoDependencyFlags = DependencyFlags
fs,
	dependencyInfoMemoryBarriers :: PL Barrier2 mbas
M.dependencyInfoMemoryBarriers = PL Barrier2 mbas
mbs,
	dependencyInfoBufferMemoryBarriers :: PL MemoryBarrier2 (M0_5 bmbas)
M.dependencyInfoBufferMemoryBarriers =
		PL (U5 MemoryBarrier2) bmbas -> PL MemoryBarrier2 (M0_5 bmbas)
forall (nsmsbnmobjs :: [(Maybe (*), *, *, Symbol, O)]).
MemoryBarrier2ListToMiddle nsmsbnmobjs =>
PL (U5 MemoryBarrier2) nsmsbnmobjs
-> PL MemoryBarrier2 (M0_5 nsmsbnmobjs)
Buffer.memoryBarrier2ListToMiddle PL (U5 MemoryBarrier2) bmbas
bmbs,
	dependencyInfoImageMemoryBarriers :: PL MemoryBarrier2 (M0_5 imbas)
M.dependencyInfoImageMemoryBarriers =
		PL (U5 MemoryBarrier2) imbas -> PL MemoryBarrier2 (M0_5 imbas)
forall (mbargs :: [(Maybe (*), *, *, Symbol, Format)]).
MemoryBarrier2ListToMiddle mbargs =>
PL (U5 MemoryBarrier2) mbargs -> PL MemoryBarrier2 (M0_5 mbargs)
Image.memoryBarrier2ListToMiddle PL (U5 MemoryBarrier2) imbas
imbs }

data BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras = BlitImageInfo2 {
	forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras -> M mn
blitImageInfo2Next :: TMaybe.M mn,
	forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras
-> Binded sms sis nms fmts
blitImageInfo2SrcImage :: Image.Binded sms sis nms fmts,
	forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras -> Layout
blitImageInfo2SrcImageLayout :: Image.Layout,
	forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras
-> Binded smd sid nmd fmtd
blitImageInfo2DstImage :: Image.Binded smd sid nmd fmtd,
	forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras -> Layout
blitImageInfo2DstImageLayout :: Image.Layout,
	forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras
-> PL Blit2 ras
blitImageInfo2Regions :: HPList.PL Image.Blit2 ras,
	forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras -> Filter
blitImageInfo2Filter :: Filter }

blitImageInfo2ToMiddle ::
	BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras ->
	M.BlitImageInfo2 mn ras
blitImageInfo2ToMiddle :: forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras
-> BlitImageInfo2 mn ras
blitImageInfo2ToMiddle BlitImageInfo2 {
	blitImageInfo2Next :: forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras -> M mn
blitImageInfo2Next = M mn
mnxt,
	blitImageInfo2SrcImage :: forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras
-> Binded sms sis nms fmts
blitImageInfo2SrcImage = Image.Binded I
si,
	blitImageInfo2SrcImageLayout :: forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras -> Layout
blitImageInfo2SrcImageLayout = Layout
sil,
	blitImageInfo2DstImage :: forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras
-> Binded smd sid nmd fmtd
blitImageInfo2DstImage = Image.Binded I
di,
	blitImageInfo2DstImageLayout :: forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras -> Layout
blitImageInfo2DstImageLayout = Layout
dil,
	blitImageInfo2Regions :: forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras
-> PL Blit2 ras
blitImageInfo2Regions = PL Blit2 ras
rs,
	blitImageInfo2Filter :: forall (mn :: Maybe (*)) sms sis (nms :: Symbol) (fmts :: Format)
       smd sid (nmd :: Symbol) (fmtd :: Format) (ras :: [Maybe (*)]).
BlitImageInfo2 mn sms sis nms fmts smd sid nmd fmtd ras -> Filter
blitImageInfo2Filter = Filter
flt } = M.BlitImageInfo2 {
	blitImageInfo2Next :: M mn
M.blitImageInfo2Next = M mn
mnxt,
	blitImageInfo2SrcImage :: I
M.blitImageInfo2SrcImage = I
si, blitImageInfo2SrcImageLayout :: Layout
M.blitImageInfo2SrcImageLayout = Layout
sil,
	blitImageInfo2DstImage :: I
M.blitImageInfo2DstImage = I
di, blitImageInfo2DstImageLayout :: Layout
M.blitImageInfo2DstImageLayout = Layout
dil,
	blitImageInfo2Regions :: PL Blit2 ras
M.blitImageInfo2Regions = PL Blit2 ras
rs, blitImageInfo2Filter :: Filter
M.blitImageInfo2Filter = Filter
flt }

newtype Sec = Sec (FixedG.F E9 Word64)

pattern NanoSec :: Word64 -> Sec
pattern $mNanoSec :: forall {r}. Sec -> (Word64 -> r) -> ((# #) -> r) -> r
$bNanoSec :: Word64 -> Sec
NanoSec ns = Sec (FixedG.MkF ns)

pattern MicroSec :: FixedG.F E3 Word64 -> Sec
pattern $mMicroSec :: forall {r}. Sec -> (F E3 Word64 -> r) -> ((# #) -> r) -> r
$bMicroSec :: F E3 Word64 -> Sec
MicroSec ms <- Sec (FixedG.changeUnit -> ms) where
	MicroSec F E3 Word64
ms = F E9 Word64 -> Sec
Sec (F E9 Word64 -> Sec) -> F E9 Word64 -> Sec
forall a b. (a -> b) -> a -> b
$ F E3 Word64 -> F E9 Word64
forall {k1} {k2} (a :: k1) n (a' :: k2). F a n -> F a' n
FixedG.changeUnit F E3 Word64
ms

pattern MilliSec :: FixedG.F E6 Word64 -> Sec
pattern $mMilliSec :: forall {r}. Sec -> (F E6 Word64 -> r) -> ((# #) -> r) -> r
$bMilliSec :: F E6 Word64 -> Sec
MilliSec ms <- Sec (FixedG.changeUnit -> ms) where
	MilliSec F E6 Word64
ms = F E9 Word64 -> Sec
Sec (F E9 Word64 -> Sec) -> F E9 Word64 -> Sec
forall a b. (a -> b) -> a -> b
$ F E6 Word64 -> F E9 Word64
forall {k1} {k2} (a :: k1) n (a' :: k2). F a n -> F a' n
FixedG.changeUnit F E6 Word64
ms