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

module Gpu.Vulkan.Queue.Middle.Internal (

	-- * SUBMIT AND WAIT IDLE

	submit, submit2, waitIdle, Q(..),

	-- * SPARSE RESOURCES

	bindSparse, BindSparseInfo(..), bindSparseInfoToCore

	) where

import Foreign.Ptr
import Foreign.Marshal.Array
import Foreign.Storable.PeekPoke
import Control.Arrow
import Control.Monad.Cont.MiscYj
import Data.TypeLevel.Tuple.Uncurry
import Data.HeteroParList qualified as HeteroParList

import Gpu.Vulkan.Base.Middle
import Gpu.Vulkan.Middle.Internal
import Gpu.Vulkan.Exception.Middle.Internal
import Gpu.Vulkan.Exception.Enum
import Gpu.Vulkan.Fence.Middle.Internal qualified as Fence.M
import Gpu.Vulkan.Queue.Core qualified as C

import Data.Kind
import Data.TypeLevel.Maybe qualified as TMaybe
import Data.HeteroParList qualified as HPList
import Gpu.Vulkan.Semaphore.Middle.Internal qualified as Semaphore
import Gpu.Vulkan.Sparse.Buffer.Middle.Internal qualified as Sparse.Buffer
import Gpu.Vulkan.Sparse.Image.Middle.Internal qualified as Sparse.Image
import Gpu.Vulkan.Fence.Middle.Internal qualified as Fence

import Control.Monad
import Debug

newtype Q = Q C.Q deriving Int -> Q -> ShowS
[Q] -> ShowS
Q -> String
(Int -> Q -> ShowS) -> (Q -> String) -> ([Q] -> ShowS) -> Show Q
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Q -> ShowS
showsPrec :: Int -> Q -> ShowS
$cshow :: Q -> String
show :: Q -> String
$cshowList :: [Q] -> ShowS
showList :: [Q] -> ShowS
Show

submit :: SubmitInfoListToCore ns =>
	Q -> HeteroParList.PL SubmitInfo ns -> Maybe Fence.M.F -> IO ()
submit :: forall (ns :: [Maybe (*)]).
SubmitInfoListToCore ns =>
Q -> PL SubmitInfo ns -> Maybe F -> IO ()
submit (Q Q
q) PL SubmitInfo ns
sis Maybe F
mf = PL SubmitInfo ns -> ([SubmitInfo] -> IO ()) -> IO ()
forall (ns :: [Maybe (*)]) a.
SubmitInfoListToCore ns =>
PL SubmitInfo ns -> ([SubmitInfo] -> IO a) -> IO ()
forall a. PL SubmitInfo ns -> ([SubmitInfo] -> IO a) -> IO ()
submitInfoListToCore PL SubmitInfo ns
sis \[SubmitInfo]
csis ->
	let sic :: Int
sic = [SubmitInfo] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [SubmitInfo]
csis in Int -> (Ptr SubmitInfo -> IO ()) -> IO ()
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
sic \Ptr SubmitInfo
psis -> do
		Ptr SubmitInfo -> [SubmitInfo] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr SubmitInfo
psis [SubmitInfo]
csis
		r <- Q -> Word32 -> Ptr SubmitInfo -> F -> IO Int32
C.submit Q
q (Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
sic) Ptr SubmitInfo
psis
			(F -> IO Int32) -> F -> IO Int32
forall a b. (a -> b) -> a -> b
$ Maybe F -> F
Fence.M.maybeFToCore Maybe F
mf
		throwUnlessSuccess $ Result r

submit2 :: SubmitInfo2ListToCore sias =>
	Q -> HeteroParList.PL (U4 SubmitInfo2) sias -> Maybe Fence.M.F -> IO ()
submit2 :: forall (sias :: [(Maybe (*), [Maybe (*)], [Maybe (*)],
                  [Maybe (*)])]).
SubmitInfo2ListToCore sias =>
Q -> PL (U4 SubmitInfo2) sias -> Maybe F -> IO ()
submit2 (Q Q
q) PL (U4 SubmitInfo2) sias
sis Maybe F
mf =
	PL (U4 SubmitInfo2) sias -> ([SubmitInfo2] -> IO ()) -> IO ()
forall (si2as :: [(Maybe (*), [Maybe (*)], [Maybe (*)],
                   [Maybe (*)])])
       a.
SubmitInfo2ListToCore si2as =>
PL (U4 SubmitInfo2) si2as -> ([SubmitInfo2] -> IO a) -> IO ()
forall a.
PL (U4 SubmitInfo2) sias -> ([SubmitInfo2] -> IO a) -> IO ()
submitInfo2ListToCore PL (U4 SubmitInfo2) sias
sis \[SubmitInfo2]
csis -> let sic :: Int
sic = [SubmitInfo2] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [SubmitInfo2]
csis in
	Int -> (Ptr SubmitInfo2 -> IO ()) -> IO ()
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
sic \Ptr SubmitInfo2
psis -> do
	Ptr SubmitInfo2 -> [SubmitInfo2] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr SubmitInfo2
psis [SubmitInfo2]
csis
	r <- Q -> Word32 -> Ptr SubmitInfo2 -> F -> IO Int32
C.submit2 Q
q (Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
sic) Ptr SubmitInfo2
psis
		(F -> IO Int32) -> F -> IO Int32
forall a b. (a -> b) -> a -> b
$ Maybe F -> F
Fence.M.maybeFToCore Maybe F
mf
	throwUnlessSuccess $ Result r

waitIdle :: Q -> IO ()
waitIdle :: Q -> IO ()
waitIdle (Q Q
q) = Result -> IO ()
throwUnlessSuccess (Result -> IO ()) -> (Int32 -> Result) -> Int32 -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> Result
Result (Int32 -> IO ()) -> IO Int32 -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Q -> IO Int32
C.waitIdle Q
q

bindSparse :: HPList.ToListWithCCpsM' WithPoked TMaybe.M mns =>
	Q -> HPList.PL BindSparseInfo mns -> Maybe Fence.F -> IO ()
bindSparse :: forall (mns :: [Maybe (*)]).
ToListWithCCpsM' WithPoked M mns =>
Q -> PL BindSparseInfo mns -> Maybe F -> IO ()
bindSparse (Q Q
q) PL BindSparseInfo mns
is Maybe F
mf =
	Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
debug (String -> IO ()
putStrLn
		String
"Gpu.Vulkan.Queue.Middle.bindSparse begin") IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
	forall {k'} {k1} k2 (c :: k' -> Constraint) (t' :: k2 -> k')
       (ns :: [k2]) (t :: k2 -> *) (m :: k1 -> *) a (b :: k1).
ToListWithCCpsM' c t' ns =>
PL t ns
-> (forall (s :: k2). c (t' s) => t s -> (a -> m b) -> m b)
-> ([a] -> m b)
-> m b
forall k2 (c :: * -> Constraint) (t' :: k2 -> *) (ns :: [k2])
       (t :: k2 -> *) (m :: * -> *) a b.
ToListWithCCpsM' c t' ns =>
PL t ns
-> (forall (s :: k2). c (t' s) => t s -> (a -> m b) -> m b)
-> ([a] -> m b)
-> m b
HPList.withListWithCCpsM' @_ @WithPoked @TMaybe.M PL BindSparseInfo mns
is BindSparseInfo s -> (BindSparseInfo -> IO ()) -> IO ()
forall (s :: Maybe (*)).
WithPoked (M s) =>
BindSparseInfo s -> (BindSparseInfo -> IO ()) -> IO ()
forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
BindSparseInfo mn -> (BindSparseInfo -> IO a) -> IO ()
bindSparseInfoToCore \[BindSparseInfo]
cis ->
	let cic :: Int
cic = [BindSparseInfo] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [BindSparseInfo]
cis in
	Int -> (Ptr BindSparseInfo -> IO ()) -> IO ()
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
cic \Ptr BindSparseInfo
pcis ->
	Ptr BindSparseInfo -> [BindSparseInfo] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr BindSparseInfo
pcis [BindSparseInfo]
cis IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
	let cf :: F
cf = case Maybe F
mf of
		Just (Fence.F F
f) -> F
f
		Maybe F
Nothing -> F
forall a. Ptr a
NullHandle in
	Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
debug (String -> IO ()
putStrLn
		String
"Gpu.Vulkan.Queue.Middle.bindSparse: before C.bindSparse") IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
	(Result -> IO ()
throwUnlessSuccess (Result -> IO ()) -> (Int32 -> Result) -> Int32 -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> Result
Result (Int32 -> IO ()) -> IO Int32 -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Q -> Word32 -> Ptr BindSparseInfo -> F -> IO Int32
C.bindSparse Q
q (Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
cic) Ptr BindSparseInfo
pcis F
cf)

data BindSparseInfo (mn :: Maybe Type) = BindSparseInfo {
	forall (mn :: Maybe (*)). BindSparseInfo mn -> M mn
bindSparseInfoNext :: TMaybe.M mn,
	forall (mn :: Maybe (*)). BindSparseInfo mn -> [S]
bindSparseInfoWaitSemaphores :: [Semaphore.S],
	forall (mn :: Maybe (*)). BindSparseInfo mn -> [MemoryBindInfo]
bindSparseInfoBufferBinds :: [Sparse.Buffer.MemoryBindInfo],
	forall (mn :: Maybe (*)).
BindSparseInfo mn -> [OpaqueMemoryBindInfo]
bindSparseInfoImageOpaqueBinds :: [Sparse.Image.OpaqueMemoryBindInfo],
	forall (mn :: Maybe (*)). BindSparseInfo mn -> [MemoryBindInfo]
bindSparseInfoImageBinds :: [Sparse.Image.MemoryBindInfo],
	forall (mn :: Maybe (*)). BindSparseInfo mn -> [S]
bindSparseInfoSignalSemaphores :: [Semaphore.S] }

bindSparseInfoToCore :: WithPoked (TMaybe.M mn) =>
	BindSparseInfo mn -> (C.BindSparseInfo -> IO a) -> IO ()
bindSparseInfoToCore :: forall (mn :: Maybe (*)) a.
WithPoked (M mn) =>
BindSparseInfo mn -> (BindSparseInfo -> IO a) -> IO ()
bindSparseInfoToCore BindSparseInfo {
	bindSparseInfoNext :: forall (mn :: Maybe (*)). BindSparseInfo mn -> M mn
bindSparseInfoNext = M mn
mnxt,
	bindSparseInfoWaitSemaphores :: forall (mn :: Maybe (*)). BindSparseInfo mn -> [S]
bindSparseInfoWaitSemaphores =
		[S] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([S] -> Int) -> ([S] -> [S]) -> [S] -> (Int, [S])
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& (S -> S
Semaphore.unS (S -> S) -> [S] -> [S]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) -> (Int
wsc, [S]
wss),
	bindSparseInfoBufferBinds :: forall (mn :: Maybe (*)). BindSparseInfo mn -> [MemoryBindInfo]
bindSparseInfoBufferBinds = [MemoryBindInfo] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([MemoryBindInfo] -> Int)
-> ([MemoryBindInfo] -> [MemoryBindInfo])
-> [MemoryBindInfo]
-> (Int, [MemoryBindInfo])
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& [MemoryBindInfo] -> [MemoryBindInfo]
forall a. a -> a
id -> (Int
bbc, [MemoryBindInfo]
bbs),
	bindSparseInfoImageOpaqueBinds :: forall (mn :: Maybe (*)).
BindSparseInfo mn -> [OpaqueMemoryBindInfo]
bindSparseInfoImageOpaqueBinds = [OpaqueMemoryBindInfo] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([OpaqueMemoryBindInfo] -> Int)
-> ([OpaqueMemoryBindInfo] -> [OpaqueMemoryBindInfo])
-> [OpaqueMemoryBindInfo]
-> (Int, [OpaqueMemoryBindInfo])
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& [OpaqueMemoryBindInfo] -> [OpaqueMemoryBindInfo]
forall a. a -> a
id -> (Int
iobc, [OpaqueMemoryBindInfo]
iobs),
	bindSparseInfoImageBinds :: forall (mn :: Maybe (*)). BindSparseInfo mn -> [MemoryBindInfo]
bindSparseInfoImageBinds = [MemoryBindInfo] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([MemoryBindInfo] -> Int)
-> ([MemoryBindInfo] -> [MemoryBindInfo])
-> [MemoryBindInfo]
-> (Int, [MemoryBindInfo])
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& [MemoryBindInfo] -> [MemoryBindInfo]
forall a. a -> a
id -> (Int
ibc, [MemoryBindInfo]
ibs),
	bindSparseInfoSignalSemaphores :: forall (mn :: Maybe (*)). BindSparseInfo mn -> [S]
bindSparseInfoSignalSemaphores =
		[S] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([S] -> Int) -> ([S] -> [S]) -> [S] -> (Int, [S])
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& (S -> S
Semaphore.unS (S -> S) -> [S] -> [S]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) -> (Int
ssc, [S]
sss)
	} BindSparseInfo -> 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 a) -> 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') ->
		Int -> (Ptr S -> IO a) -> IO a
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
wsc \Ptr S
pwss ->
		Ptr S -> [S] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr S
pwss [S]
wss IO () -> IO a -> IO a
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
		Int -> (Ptr MemoryBindInfo -> IO a) -> IO a
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
bbc \Ptr MemoryBindInfo
pbbs ->
		(MemoryBindInfo -> (MemoryBindInfo -> IO a) -> IO a
forall a. MemoryBindInfo -> (MemoryBindInfo -> IO a) -> IO a
Sparse.Buffer.memoryBindInfoToCore (MemoryBindInfo -> (MemoryBindInfo -> IO a) -> IO a)
-> [MemoryBindInfo] -> ([MemoryBindInfo] -> IO a) -> IO a
forall a b (m :: * -> *) c.
(a -> (b -> m c) -> m c) -> [a] -> ([b] -> m c) -> m c
`mapContM` [MemoryBindInfo]
bbs) \[MemoryBindInfo]
cbbs ->
		Ptr MemoryBindInfo -> [MemoryBindInfo] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr MemoryBindInfo
pbbs [MemoryBindInfo]
cbbs IO () -> IO a -> IO a
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
		Int -> (Ptr OpaqueMemoryBindInfo -> IO a) -> IO a
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
iobc \Ptr OpaqueMemoryBindInfo
piobs ->
		(OpaqueMemoryBindInfo -> (OpaqueMemoryBindInfo -> IO a) -> IO a
forall a.
OpaqueMemoryBindInfo -> (OpaqueMemoryBindInfo -> IO a) -> IO a
Sparse.Image.opaqueMemoryBindInfoToCore
			(OpaqueMemoryBindInfo -> (OpaqueMemoryBindInfo -> IO a) -> IO a)
-> [OpaqueMemoryBindInfo]
-> ([OpaqueMemoryBindInfo] -> IO a)
-> IO a
forall a b (m :: * -> *) c.
(a -> (b -> m c) -> m c) -> [a] -> ([b] -> m c) -> m c
`mapContM` [OpaqueMemoryBindInfo]
iobs) \[OpaqueMemoryBindInfo]
ciobs ->
		Ptr OpaqueMemoryBindInfo -> [OpaqueMemoryBindInfo] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr OpaqueMemoryBindInfo
piobs [OpaqueMemoryBindInfo]
ciobs IO () -> IO a -> IO a
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
		Int -> (Ptr MemoryBindInfo -> IO a) -> IO a
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
ibc \Ptr MemoryBindInfo
pibs ->
		(MemoryBindInfo -> (MemoryBindInfo -> IO a) -> IO a
forall a. MemoryBindInfo -> (MemoryBindInfo -> IO a) -> IO a
Sparse.Image.memoryBindInfoToCore (MemoryBindInfo -> (MemoryBindInfo -> IO a) -> IO a)
-> [MemoryBindInfo] -> ([MemoryBindInfo] -> IO a) -> IO a
forall a b (m :: * -> *) c.
(a -> (b -> m c) -> m c) -> [a] -> ([b] -> m c) -> m c
`mapContM` [MemoryBindInfo]
ibs) \[MemoryBindInfo]
cibs ->
		Ptr MemoryBindInfo -> [MemoryBindInfo] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr MemoryBindInfo
pibs [MemoryBindInfo]
cibs IO () -> IO a -> IO a
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
		Int -> (Ptr S -> IO a) -> IO a
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
ssc \Ptr S
psss ->
		Ptr S -> [S] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray Ptr S
psss [S]
sss IO () -> IO a -> IO a
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
		BindSparseInfo -> IO a
f C.BindSparseInfo {
			bindSparseInfoSType :: ()
C.bindSparseInfoSType = (),
			bindSparseInfoPNext :: Ptr ()
C.bindSparseInfoPNext = Ptr ()
pnxt',
			bindSparseInfoWaitSemaphoreCount :: Word32
C.bindSparseInfoWaitSemaphoreCount = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
wsc,
			bindSparseInfoPWaitSemaphores :: Ptr S
C.bindSparseInfoPWaitSemaphores = Ptr S
pwss,
			bindSparseInfoBufferBindCount :: Word32
C.bindSparseInfoBufferBindCount = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
bbc,
			bindSparseInfoPBufferBinds :: Ptr MemoryBindInfo
C.bindSparseInfoPBufferBinds = Ptr MemoryBindInfo
pbbs,
			bindSparseInfoImageOpaqueBindCount :: Word32
C.bindSparseInfoImageOpaqueBindCount =
				Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
iobc,
			bindSparseInfoPImageOpaqueBinds :: Ptr OpaqueMemoryBindInfo
C.bindSparseInfoPImageOpaqueBinds = Ptr OpaqueMemoryBindInfo
piobs,
			bindSparseInfoImageBindCount :: Word32
C.bindSparseInfoImageBindCount = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ibc,
			bindSparseInfoPImageBinds :: Ptr MemoryBindInfo
C.bindSparseInfoPImageBinds = Ptr MemoryBindInfo
pibs,
			bindSparseInfoSignalSemaphoreCount :: Word32
C.bindSparseInfoSignalSemaphoreCount = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
ssc,
			bindSparseInfoPSignalSemaphores :: Ptr S
C.bindSparseInfoPSignalSemaphores = Ptr S
psss }