{-# language CPP #-}
module Vulkan.Extensions.VK_VALVE_mutable_descriptor_type ( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE(..)
, MutableDescriptorTypeListVALVE(..)
, MutableDescriptorTypeCreateInfoVALVE(..)
, VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION
, pattern VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION
, VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME
, pattern VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME
) where
import Foreign.Marshal.Alloc (allocaBytesAligned)
import Foreign.Ptr (nullPtr)
import Foreign.Ptr (plusPtr)
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.Cont (evalContT)
import Data.Vector (generateM)
import qualified Data.Vector (imapM_)
import qualified Data.Vector (length)
import Vulkan.CStruct (FromCStruct)
import Vulkan.CStruct (FromCStruct(..))
import Vulkan.CStruct (ToCStruct)
import Vulkan.CStruct (ToCStruct(..))
import Vulkan.Zero (Zero(..))
import Data.String (IsString)
import Data.Typeable (Typeable)
import Foreign.Storable (Storable)
import Foreign.Storable (Storable(peek))
import Foreign.Storable (Storable(poke))
import qualified Foreign.Storable (Storable(..))
import GHC.Generics (Generic)
import Foreign.Ptr (Ptr)
import Data.Word (Word32)
import Data.Kind (Type)
import Control.Monad.Trans.Cont (ContT(..))
import Data.Vector (Vector)
import Vulkan.CStruct.Utils (advancePtrBytes)
import Vulkan.Core10.FundamentalTypes (bool32ToBool)
import Vulkan.Core10.FundamentalTypes (boolToBool32)
import Vulkan.Core10.FundamentalTypes (Bool32)
import Vulkan.Core10.Enums.DescriptorType (DescriptorType)
import Vulkan.Core10.Enums.StructureType (StructureType)
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE))
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE))
data PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
{
PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> Bool
mutableDescriptorType :: Bool }
deriving (Typeable, PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> Bool
(PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> Bool)
-> (PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> Bool)
-> Eq PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> Bool
$c/= :: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> Bool
== :: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> Bool
$c== :: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> Bool
Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (PhysicalDeviceMutableDescriptorTypeFeaturesVALVE)
#endif
deriving instance Show PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
instance ToCStruct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE where
withCStruct :: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> (Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> IO b)
-> IO b
withCStruct x :: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
x f :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> IO b
f = Int
-> Int
-> (Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> IO b)
-> IO b
forall a b. Int -> Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned 24 8 ((Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> IO b)
-> IO b)
-> (Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> IO b)
-> IO b
forall a b. (a -> b) -> a -> b
$ \p :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p -> Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
x (Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> IO b
f Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p)
pokeCStruct :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> IO b -> IO b
pokeCStruct p :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p PhysicalDeviceMutableDescriptorTypeFeaturesVALVE{..} f :: IO b
f = do
Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE)
Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
Ptr Bool32 -> Bool32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> Int -> Ptr Bool32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
mutableDescriptorType))
IO b
f
cStructSize :: Int
cStructSize = 24
cStructAlignment :: Int
cStructAlignment = 8
pokeZeroCStruct :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> IO b -> IO b
pokeZeroCStruct p :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p f :: IO b
f = do
Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE)
Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
Ptr Bool32 -> Bool32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> Int -> Ptr Bool32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
forall a. Zero a => a
zero))
IO b
f
instance FromCStruct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE where
peekCStruct :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> IO PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
peekCStruct p :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p = do
Bool32
mutableDescriptorType <- Ptr Bool32 -> IO Bool32
forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
p Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> Int -> Ptr Bool32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16 :: Ptr Bool32))
PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> IO PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> IO PhysicalDeviceMutableDescriptorTypeFeaturesVALVE)
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> IO PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
forall a b. (a -> b) -> a -> b
$ Bool -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
(Bool32 -> Bool
bool32ToBool Bool32
mutableDescriptorType)
instance Storable PhysicalDeviceMutableDescriptorTypeFeaturesVALVE where
sizeOf :: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> Int
sizeOf ~PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
_ = 24
alignment :: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> Int
alignment ~PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
_ = 8
peek :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> IO PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
peek = Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> IO PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
forall a. FromCStruct a => Ptr a -> IO a
peekCStruct
poke :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE -> IO ()
poke ptr :: Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
ptr poked :: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
poked = Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
-> IO ()
-> IO ()
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
ptr PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
poked (() -> IO ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
instance Zero PhysicalDeviceMutableDescriptorTypeFeaturesVALVE where
zero :: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
zero = Bool -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
Bool
forall a. Zero a => a
zero
data MutableDescriptorTypeListVALVE = MutableDescriptorTypeListVALVE
{
MutableDescriptorTypeListVALVE -> Vector DescriptorType
descriptorTypes :: Vector DescriptorType }
deriving (Typeable)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (MutableDescriptorTypeListVALVE)
#endif
deriving instance Show MutableDescriptorTypeListVALVE
instance ToCStruct MutableDescriptorTypeListVALVE where
withCStruct :: MutableDescriptorTypeListVALVE
-> (Ptr MutableDescriptorTypeListVALVE -> IO b) -> IO b
withCStruct x :: MutableDescriptorTypeListVALVE
x f :: Ptr MutableDescriptorTypeListVALVE -> IO b
f = Int -> Int -> (Ptr MutableDescriptorTypeListVALVE -> IO b) -> IO b
forall a b. Int -> Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned 16 8 ((Ptr MutableDescriptorTypeListVALVE -> IO b) -> IO b)
-> (Ptr MutableDescriptorTypeListVALVE -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \p :: Ptr MutableDescriptorTypeListVALVE
p -> Ptr MutableDescriptorTypeListVALVE
-> MutableDescriptorTypeListVALVE -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr MutableDescriptorTypeListVALVE
p MutableDescriptorTypeListVALVE
x (Ptr MutableDescriptorTypeListVALVE -> IO b
f Ptr MutableDescriptorTypeListVALVE
p)
pokeCStruct :: Ptr MutableDescriptorTypeListVALVE
-> MutableDescriptorTypeListVALVE -> IO b -> IO b
pokeCStruct p :: Ptr MutableDescriptorTypeListVALVE
p MutableDescriptorTypeListVALVE{..} f :: IO b
f = ContT b IO b -> IO b
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT b IO b -> IO b) -> ContT b IO b -> IO b
forall a b. (a -> b) -> a -> b
$ do
IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr MutableDescriptorTypeListVALVE
p Ptr MutableDescriptorTypeListVALVE -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: Ptr Word32)) ((Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Vector DescriptorType -> Int
forall a. Vector a -> Int
Data.Vector.length (Vector DescriptorType -> Int) -> Vector DescriptorType -> Int
forall a b. (a -> b) -> a -> b
$ (Vector DescriptorType
descriptorTypes)) :: Word32))
Ptr DescriptorType
pPDescriptorTypes' <- ((Ptr DescriptorType -> IO b) -> IO b)
-> ContT b IO (Ptr DescriptorType)
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((Ptr DescriptorType -> IO b) -> IO b)
-> ContT b IO (Ptr DescriptorType))
-> ((Ptr DescriptorType -> IO b) -> IO b)
-> ContT b IO (Ptr DescriptorType)
forall a b. (a -> b) -> a -> b
$ Int -> Int -> (Ptr DescriptorType -> IO b) -> IO b
forall a b. Int -> Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned @DescriptorType ((Vector DescriptorType -> Int
forall a. Vector a -> Int
Data.Vector.length (Vector DescriptorType
descriptorTypes)) Int -> Int -> Int
forall a. Num a => a -> a -> a
* 4) 4
IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ (Int -> DescriptorType -> IO ()) -> Vector DescriptorType -> IO ()
forall (m :: * -> *) a b.
Monad m =>
(Int -> a -> m b) -> Vector a -> m ()
Data.Vector.imapM_ (\i :: Int
i e :: DescriptorType
e -> Ptr DescriptorType -> DescriptorType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DescriptorType
pPDescriptorTypes' Ptr DescriptorType -> Int -> Ptr DescriptorType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
i)) :: Ptr DescriptorType) (DescriptorType
e)) (Vector DescriptorType
descriptorTypes)
IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr DescriptorType) -> Ptr DescriptorType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr MutableDescriptorTypeListVALVE
p Ptr MutableDescriptorTypeListVALVE
-> Int -> Ptr (Ptr DescriptorType)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8 :: Ptr (Ptr DescriptorType))) (Ptr DescriptorType
pPDescriptorTypes')
IO b -> ContT b IO b
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO b -> ContT b IO b) -> IO b -> ContT b IO b
forall a b. (a -> b) -> a -> b
$ IO b
f
cStructSize :: Int
cStructSize = 16
cStructAlignment :: Int
cStructAlignment = 8
pokeZeroCStruct :: Ptr MutableDescriptorTypeListVALVE -> IO b -> IO b
pokeZeroCStruct _ f :: IO b
f = IO b
f
instance FromCStruct MutableDescriptorTypeListVALVE where
peekCStruct :: Ptr MutableDescriptorTypeListVALVE
-> IO MutableDescriptorTypeListVALVE
peekCStruct p :: Ptr MutableDescriptorTypeListVALVE
p = do
Word32
descriptorTypeCount <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek @Word32 ((Ptr MutableDescriptorTypeListVALVE
p Ptr MutableDescriptorTypeListVALVE -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: Ptr Word32))
Ptr DescriptorType
pDescriptorTypes <- Ptr (Ptr DescriptorType) -> IO (Ptr DescriptorType)
forall a. Storable a => Ptr a -> IO a
peek @(Ptr DescriptorType) ((Ptr MutableDescriptorTypeListVALVE
p Ptr MutableDescriptorTypeListVALVE
-> Int -> Ptr (Ptr DescriptorType)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8 :: Ptr (Ptr DescriptorType)))
Vector DescriptorType
pDescriptorTypes' <- Int -> (Int -> IO DescriptorType) -> IO (Vector DescriptorType)
forall (m :: * -> *) a.
Monad m =>
Int -> (Int -> m a) -> m (Vector a)
generateM (Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
descriptorTypeCount) (\i :: Int
i -> Ptr DescriptorType -> IO DescriptorType
forall a. Storable a => Ptr a -> IO a
peek @DescriptorType ((Ptr DescriptorType
pDescriptorTypes Ptr DescriptorType -> Int -> Ptr DescriptorType
forall a. Ptr a -> Int -> Ptr a
`advancePtrBytes` (4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
i)) :: Ptr DescriptorType)))
MutableDescriptorTypeListVALVE -> IO MutableDescriptorTypeListVALVE
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MutableDescriptorTypeListVALVE
-> IO MutableDescriptorTypeListVALVE)
-> MutableDescriptorTypeListVALVE
-> IO MutableDescriptorTypeListVALVE
forall a b. (a -> b) -> a -> b
$ Vector DescriptorType -> MutableDescriptorTypeListVALVE
MutableDescriptorTypeListVALVE
Vector DescriptorType
pDescriptorTypes'
instance Zero MutableDescriptorTypeListVALVE where
zero :: MutableDescriptorTypeListVALVE
zero = Vector DescriptorType -> MutableDescriptorTypeListVALVE
MutableDescriptorTypeListVALVE
Vector DescriptorType
forall a. Monoid a => a
mempty
data MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoVALVE
{
MutableDescriptorTypeCreateInfoVALVE
-> Vector MutableDescriptorTypeListVALVE
mutableDescriptorTypeLists :: Vector MutableDescriptorTypeListVALVE }
deriving (Typeable)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (MutableDescriptorTypeCreateInfoVALVE)
#endif
deriving instance Show MutableDescriptorTypeCreateInfoVALVE
instance ToCStruct MutableDescriptorTypeCreateInfoVALVE where
withCStruct :: MutableDescriptorTypeCreateInfoVALVE
-> (Ptr MutableDescriptorTypeCreateInfoVALVE -> IO b) -> IO b
withCStruct x :: MutableDescriptorTypeCreateInfoVALVE
x f :: Ptr MutableDescriptorTypeCreateInfoVALVE -> IO b
f = Int
-> Int
-> (Ptr MutableDescriptorTypeCreateInfoVALVE -> IO b)
-> IO b
forall a b. Int -> Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned 32 8 ((Ptr MutableDescriptorTypeCreateInfoVALVE -> IO b) -> IO b)
-> (Ptr MutableDescriptorTypeCreateInfoVALVE -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \p :: Ptr MutableDescriptorTypeCreateInfoVALVE
p -> Ptr MutableDescriptorTypeCreateInfoVALVE
-> MutableDescriptorTypeCreateInfoVALVE -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr MutableDescriptorTypeCreateInfoVALVE
p MutableDescriptorTypeCreateInfoVALVE
x (Ptr MutableDescriptorTypeCreateInfoVALVE -> IO b
f Ptr MutableDescriptorTypeCreateInfoVALVE
p)
pokeCStruct :: Ptr MutableDescriptorTypeCreateInfoVALVE
-> MutableDescriptorTypeCreateInfoVALVE -> IO b -> IO b
pokeCStruct p :: Ptr MutableDescriptorTypeCreateInfoVALVE
p MutableDescriptorTypeCreateInfoVALVE{..} f :: IO b
f = ContT b IO b -> IO b
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT b IO b -> IO b) -> ContT b IO b -> IO b
forall a b. (a -> b) -> a -> b
$ do
IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr MutableDescriptorTypeCreateInfoVALVE
p Ptr MutableDescriptorTypeCreateInfoVALVE
-> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE)
IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr MutableDescriptorTypeCreateInfoVALVE
p Ptr MutableDescriptorTypeCreateInfoVALVE -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr MutableDescriptorTypeCreateInfoVALVE
p Ptr MutableDescriptorTypeCreateInfoVALVE -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16 :: Ptr Word32)) ((Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Vector MutableDescriptorTypeListVALVE -> Int
forall a. Vector a -> Int
Data.Vector.length (Vector MutableDescriptorTypeListVALVE -> Int)
-> Vector MutableDescriptorTypeListVALVE -> Int
forall a b. (a -> b) -> a -> b
$ (Vector MutableDescriptorTypeListVALVE
mutableDescriptorTypeLists)) :: Word32))
Ptr MutableDescriptorTypeListVALVE
pPMutableDescriptorTypeLists' <- ((Ptr MutableDescriptorTypeListVALVE -> IO b) -> IO b)
-> ContT b IO (Ptr MutableDescriptorTypeListVALVE)
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((Ptr MutableDescriptorTypeListVALVE -> IO b) -> IO b)
-> ContT b IO (Ptr MutableDescriptorTypeListVALVE))
-> ((Ptr MutableDescriptorTypeListVALVE -> IO b) -> IO b)
-> ContT b IO (Ptr MutableDescriptorTypeListVALVE)
forall a b. (a -> b) -> a -> b
$ Int -> Int -> (Ptr MutableDescriptorTypeListVALVE -> IO b) -> IO b
forall a b. Int -> Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned @MutableDescriptorTypeListVALVE ((Vector MutableDescriptorTypeListVALVE -> Int
forall a. Vector a -> Int
Data.Vector.length (Vector MutableDescriptorTypeListVALVE
mutableDescriptorTypeLists)) Int -> Int -> Int
forall a. Num a => a -> a -> a
* 16) 8
(Int -> MutableDescriptorTypeListVALVE -> ContT b IO ())
-> Vector MutableDescriptorTypeListVALVE -> ContT b IO ()
forall (m :: * -> *) a b.
Monad m =>
(Int -> a -> m b) -> Vector a -> m ()
Data.Vector.imapM_ (\i :: Int
i e :: MutableDescriptorTypeListVALVE
e -> ((() -> IO b) -> IO b) -> ContT b IO ()
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((() -> IO b) -> IO b) -> ContT b IO ())
-> ((() -> IO b) -> IO b) -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr MutableDescriptorTypeListVALVE
-> MutableDescriptorTypeListVALVE -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct (Ptr MutableDescriptorTypeListVALVE
pPMutableDescriptorTypeLists' Ptr MutableDescriptorTypeListVALVE
-> Int -> Ptr MutableDescriptorTypeListVALVE
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (16 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
i)) :: Ptr MutableDescriptorTypeListVALVE) (MutableDescriptorTypeListVALVE
e) (IO b -> IO b) -> ((() -> IO b) -> IO b) -> (() -> IO b) -> IO b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((() -> IO b) -> () -> IO b
forall a b. (a -> b) -> a -> b
$ ())) (Vector MutableDescriptorTypeListVALVE
mutableDescriptorTypeLists)
IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr MutableDescriptorTypeListVALVE)
-> Ptr MutableDescriptorTypeListVALVE -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr MutableDescriptorTypeCreateInfoVALVE
p Ptr MutableDescriptorTypeCreateInfoVALVE
-> Int -> Ptr (Ptr MutableDescriptorTypeListVALVE)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24 :: Ptr (Ptr MutableDescriptorTypeListVALVE))) (Ptr MutableDescriptorTypeListVALVE
pPMutableDescriptorTypeLists')
IO b -> ContT b IO b
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO b -> ContT b IO b) -> IO b -> ContT b IO b
forall a b. (a -> b) -> a -> b
$ IO b
f
cStructSize :: Int
cStructSize = 32
cStructAlignment :: Int
cStructAlignment = 8
pokeZeroCStruct :: Ptr MutableDescriptorTypeCreateInfoVALVE -> IO b -> IO b
pokeZeroCStruct p :: Ptr MutableDescriptorTypeCreateInfoVALVE
p f :: IO b
f = do
Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr MutableDescriptorTypeCreateInfoVALVE
p Ptr MutableDescriptorTypeCreateInfoVALVE
-> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE)
Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr MutableDescriptorTypeCreateInfoVALVE
p Ptr MutableDescriptorTypeCreateInfoVALVE -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
IO b
f
instance FromCStruct MutableDescriptorTypeCreateInfoVALVE where
peekCStruct :: Ptr MutableDescriptorTypeCreateInfoVALVE
-> IO MutableDescriptorTypeCreateInfoVALVE
peekCStruct p :: Ptr MutableDescriptorTypeCreateInfoVALVE
p = do
Word32
mutableDescriptorTypeListCount <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek @Word32 ((Ptr MutableDescriptorTypeCreateInfoVALVE
p Ptr MutableDescriptorTypeCreateInfoVALVE -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16 :: Ptr Word32))
Ptr MutableDescriptorTypeListVALVE
pMutableDescriptorTypeLists <- Ptr (Ptr MutableDescriptorTypeListVALVE)
-> IO (Ptr MutableDescriptorTypeListVALVE)
forall a. Storable a => Ptr a -> IO a
peek @(Ptr MutableDescriptorTypeListVALVE) ((Ptr MutableDescriptorTypeCreateInfoVALVE
p Ptr MutableDescriptorTypeCreateInfoVALVE
-> Int -> Ptr (Ptr MutableDescriptorTypeListVALVE)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24 :: Ptr (Ptr MutableDescriptorTypeListVALVE)))
Vector MutableDescriptorTypeListVALVE
pMutableDescriptorTypeLists' <- Int
-> (Int -> IO MutableDescriptorTypeListVALVE)
-> IO (Vector MutableDescriptorTypeListVALVE)
forall (m :: * -> *) a.
Monad m =>
Int -> (Int -> m a) -> m (Vector a)
generateM (Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
mutableDescriptorTypeListCount) (\i :: Int
i -> Ptr MutableDescriptorTypeListVALVE
-> IO MutableDescriptorTypeListVALVE
forall a. FromCStruct a => Ptr a -> IO a
peekCStruct @MutableDescriptorTypeListVALVE ((Ptr MutableDescriptorTypeListVALVE
pMutableDescriptorTypeLists Ptr MutableDescriptorTypeListVALVE
-> Int -> Ptr MutableDescriptorTypeListVALVE
forall a. Ptr a -> Int -> Ptr a
`advancePtrBytes` (16 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
i)) :: Ptr MutableDescriptorTypeListVALVE)))
MutableDescriptorTypeCreateInfoVALVE
-> IO MutableDescriptorTypeCreateInfoVALVE
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MutableDescriptorTypeCreateInfoVALVE
-> IO MutableDescriptorTypeCreateInfoVALVE)
-> MutableDescriptorTypeCreateInfoVALVE
-> IO MutableDescriptorTypeCreateInfoVALVE
forall a b. (a -> b) -> a -> b
$ Vector MutableDescriptorTypeListVALVE
-> MutableDescriptorTypeCreateInfoVALVE
MutableDescriptorTypeCreateInfoVALVE
Vector MutableDescriptorTypeListVALVE
pMutableDescriptorTypeLists'
instance Zero MutableDescriptorTypeCreateInfoVALVE where
zero :: MutableDescriptorTypeCreateInfoVALVE
zero = Vector MutableDescriptorTypeListVALVE
-> MutableDescriptorTypeCreateInfoVALVE
MutableDescriptorTypeCreateInfoVALVE
Vector MutableDescriptorTypeListVALVE
forall a. Monoid a => a
mempty
type VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION = 1
pattern VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION :: forall a . Integral a => a
pattern $bVALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION :: a
$mVALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION :: forall r a. Integral a => a -> (Void# -> r) -> (Void# -> r) -> r
VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION = 1
type VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME = "VK_VALVE_mutable_descriptor_type"
pattern VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME :: forall a . (Eq a, IsString a) => a
pattern $bVALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME :: a
$mVALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME :: forall r a.
(Eq a, IsString a) =>
a -> (Void# -> r) -> (Void# -> r) -> r
VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME = "VK_VALVE_mutable_descriptor_type"