{-# language CPP #-}
-- No documentation found for Chapter "LayerDiscovery"
module Vulkan.Core10.LayerDiscovery  ( enumerateInstanceLayerProperties
                                     , enumerateDeviceLayerProperties
                                     , LayerProperties(..)
                                     ) where

import Vulkan.CStruct.Utils (FixedArray)
import Vulkan.Internal.Utils (traceAroundEvent)
import Control.Exception.Base (bracket)
import Control.Monad (unless)
import Control.Monad.IO.Class (liftIO)
import Foreign.Marshal.Alloc (allocaBytes)
import Foreign.Marshal.Alloc (callocBytes)
import Foreign.Marshal.Alloc (free)
import GHC.Base (when)
import GHC.IO (throwIO)
import Foreign.Ptr (castFunPtr)
import GHC.Ptr (nullFunPtr)
import Foreign.Ptr (nullPtr)
import Foreign.Ptr (plusPtr)
import Data.ByteString (packCString)
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.Cont (evalContT)
import Data.Vector (generateM)
import Vulkan.CStruct (FromCStruct)
import Vulkan.CStruct (FromCStruct(..))
import Vulkan.CStruct (ToCStruct)
import Vulkan.CStruct (ToCStruct(..))
import Vulkan.Zero (Zero(..))
import Control.Monad.IO.Class (MonadIO)
import Data.Typeable (Typeable)
import Foreign.C.Types (CChar)
import Foreign.Storable (Storable)
import Foreign.Storable (Storable(peek))
import Foreign.Storable (Storable(poke))
import qualified Foreign.Storable (Storable(..))
import GHC.Generics (Generic)
import GHC.IO.Exception (IOErrorType(..))
import GHC.IO.Exception (IOException(..))
import Foreign.Ptr (FunPtr)
import Foreign.Ptr (Ptr)
import GHC.Ptr (Ptr(Ptr))
import Data.Word (Word32)
import Data.ByteString (ByteString)
import Data.Kind (Type)
import Control.Monad.Trans.Cont (ContT(..))
import Data.Vector (Vector)
import Vulkan.CStruct.Utils (advancePtrBytes)
import Vulkan.Dynamic (getInstanceProcAddr')
import Vulkan.CStruct.Utils (lowerArrayPtr)
import Vulkan.CStruct.Utils (pokeFixedLengthNullTerminatedByteString)
import Vulkan.NamedType ((:::))
import Vulkan.Dynamic (InstanceCmds(pVkEnumerateDeviceLayerProperties))
import Vulkan.Core10.APIConstants (MAX_DESCRIPTION_SIZE)
import Vulkan.Core10.APIConstants (MAX_EXTENSION_NAME_SIZE)
import Vulkan.Core10.Handles (PhysicalDevice)
import Vulkan.Core10.Handles (PhysicalDevice(..))
import Vulkan.Core10.Handles (PhysicalDevice(PhysicalDevice))
import Vulkan.Core10.Handles (PhysicalDevice_T)
import Vulkan.Core10.Enums.Result (Result)
import Vulkan.Core10.Enums.Result (Result(..))
import Vulkan.Exception (VulkanException(..))
import Vulkan.Core10.Enums.Result (Result(SUCCESS))
foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkEnumerateInstanceLayerProperties
  :: FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result) -> Ptr Word32 -> Ptr LayerProperties -> IO Result

-- | vkEnumerateInstanceLayerProperties - Returns up to requested number of
-- global layer properties
--
-- = Description
--
-- If @pProperties@ is @NULL@, then the number of layer properties
-- available is returned in @pPropertyCount@. Otherwise, @pPropertyCount@
-- /must/ point to a variable set by the application to the number of
-- elements in the @pProperties@ array, and on return the variable is
-- overwritten with the number of structures actually written to
-- @pProperties@. If @pPropertyCount@ is less than the number of layer
-- properties available, at most @pPropertyCount@ structures will be
-- written, and 'Vulkan.Core10.Enums.Result.INCOMPLETE' will be returned
-- instead of 'Vulkan.Core10.Enums.Result.SUCCESS', to indicate that not
-- all the available properties were returned.
--
-- The list of available layers may change at any time due to actions
-- outside of the Vulkan implementation, so two calls to
-- 'enumerateInstanceLayerProperties' with the same parameters /may/ return
-- different results, or retrieve different @pPropertyCount@ values or
-- @pProperties@ contents. Once an instance has been created, the layers
-- enabled for that instance will continue to be enabled and valid for the
-- lifetime of that instance, even if some of them become unavailable for
-- future instances.
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-vkEnumerateInstanceLayerProperties-pPropertyCount-parameter#
--     @pPropertyCount@ /must/ be a valid pointer to a @uint32_t@ value
--
-- -   #VUID-vkEnumerateInstanceLayerProperties-pProperties-parameter# If
--     the value referenced by @pPropertyCount@ is not @0@, and
--     @pProperties@ is not @NULL@, @pProperties@ /must/ be a valid pointer
--     to an array of @pPropertyCount@ 'LayerProperties' structures
--
-- == Return Codes
--
-- [<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-successcodes Success>]
--
--     -   'Vulkan.Core10.Enums.Result.INCOMPLETE'
--
--     -   'Vulkan.Core10.Enums.Result.SUCCESS'
--
-- [<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-errorcodes Failure>]
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_OUT_OF_DEVICE_MEMORY'
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_OUT_OF_HOST_MEMORY'
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_UNKNOWN'
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_VALIDATION_FAILED'
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_VERSION_1_0 VK_VERSION_1_0>,
-- 'LayerProperties'
enumerateInstanceLayerProperties :: forall io
                                  . (MonadIO io)
                                 => io (Result, ("properties" ::: Vector LayerProperties))
enumerateInstanceLayerProperties :: forall (io :: * -> *).
MonadIO io =>
io (Result, "properties" ::: Vector LayerProperties)
enumerateInstanceLayerProperties  = IO (Result, "properties" ::: Vector LayerProperties)
-> io (Result, "properties" ::: Vector LayerProperties)
forall a. IO a -> io a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Result, "properties" ::: Vector LayerProperties)
 -> io (Result, "properties" ::: Vector LayerProperties))
-> (ContT
      (Result, "properties" ::: Vector LayerProperties)
      IO
      (Result, "properties" ::: Vector LayerProperties)
    -> IO (Result, "properties" ::: Vector LayerProperties))
-> ContT
     (Result, "properties" ::: Vector LayerProperties)
     IO
     (Result, "properties" ::: Vector LayerProperties)
-> io (Result, "properties" ::: Vector LayerProperties)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContT
  (Result, "properties" ::: Vector LayerProperties)
  IO
  (Result, "properties" ::: Vector LayerProperties)
-> IO (Result, "properties" ::: Vector LayerProperties)
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT
   (Result, "properties" ::: Vector LayerProperties)
   IO
   (Result, "properties" ::: Vector LayerProperties)
 -> io (Result, "properties" ::: Vector LayerProperties))
-> ContT
     (Result, "properties" ::: Vector LayerProperties)
     IO
     (Result, "properties" ::: Vector LayerProperties)
-> io (Result, "properties" ::: Vector LayerProperties)
forall a b. (a -> b) -> a -> b
$ do
  vkEnumerateInstanceLayerPropertiesPtr <- IO (FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result))
-> ContT
     (Result, "properties" ::: Vector LayerProperties)
     IO
     (FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result))
forall (m :: * -> *) a.
Monad m =>
m a -> ContT (Result, "properties" ::: Vector LayerProperties) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO (FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result))
 -> ContT
      (Result, "properties" ::: Vector LayerProperties)
      IO
      (FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result)))
-> IO (FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result))
-> ContT
     (Result, "properties" ::: Vector LayerProperties)
     IO
     (FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result))
forall a b. (a -> b) -> a -> b
$ forall a b. FunPtr a -> FunPtr b
castFunPtr @_ @(("pPropertyCount" ::: Ptr Word32) -> ("pProperties" ::: Ptr LayerProperties) -> IO Result) (FunPtr FN_vkVoidFunction
 -> FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result))
-> IO (FunPtr FN_vkVoidFunction)
-> IO (FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr Instance_T
-> ("pName" ::: Ptr CChar) -> IO (FunPtr FN_vkVoidFunction)
getInstanceProcAddr' Ptr Instance_T
forall a. Ptr a
nullPtr (Addr# -> "pName" ::: Ptr CChar
forall a. Addr# -> Ptr a
Ptr Addr#
"vkEnumerateInstanceLayerProperties"#)
  lift $ unless (vkEnumerateInstanceLayerPropertiesPtr /= nullFunPtr) $
    throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkEnumerateInstanceLayerProperties is null" Nothing Nothing
  let vkEnumerateInstanceLayerProperties' = FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result)
-> Ptr Word32 -> Ptr LayerProperties -> IO Result
mkVkEnumerateInstanceLayerProperties FunPtr (Ptr Word32 -> Ptr LayerProperties -> IO Result)
vkEnumerateInstanceLayerPropertiesPtr
  pPPropertyCount <- ContT $ bracket (callocBytes @Word32 4) free
  r <- lift $ traceAroundEvent "vkEnumerateInstanceLayerProperties" (vkEnumerateInstanceLayerProperties'
                                                                       (pPPropertyCount)
                                                                       (nullPtr))
  lift $ when (r < SUCCESS) (throwIO (VulkanException r))
  pPropertyCount <- lift $ peek @Word32 pPPropertyCount
  pPProperties <- ContT $ bracket (callocBytes @LayerProperties ((fromIntegral (pPropertyCount)) * 520)) free
  _ <- traverse (\Int
i -> ((() -> IO (Result, "properties" ::: Vector LayerProperties))
 -> IO (Result, "properties" ::: Vector LayerProperties))
-> ContT (Result, "properties" ::: Vector LayerProperties) IO ()
forall {k} (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((() -> IO (Result, "properties" ::: Vector LayerProperties))
  -> IO (Result, "properties" ::: Vector LayerProperties))
 -> ContT (Result, "properties" ::: Vector LayerProperties) IO ())
-> ((() -> IO (Result, "properties" ::: Vector LayerProperties))
    -> IO (Result, "properties" ::: Vector LayerProperties))
-> ContT (Result, "properties" ::: Vector LayerProperties) IO ()
forall a b. (a -> b) -> a -> b
$ Ptr LayerProperties
-> IO (Result, "properties" ::: Vector LayerProperties)
-> IO (Result, "properties" ::: Vector LayerProperties)
forall b. Ptr LayerProperties -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> IO b -> IO b
pokeZeroCStruct (Ptr LayerProperties
pPProperties Ptr LayerProperties -> Int -> Ptr LayerProperties
forall a. Ptr a -> Int -> Ptr a
`advancePtrBytes` (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
520) :: Ptr LayerProperties) (IO (Result, "properties" ::: Vector LayerProperties)
 -> IO (Result, "properties" ::: Vector LayerProperties))
-> ((() -> IO (Result, "properties" ::: Vector LayerProperties))
    -> IO (Result, "properties" ::: Vector LayerProperties))
-> (() -> IO (Result, "properties" ::: Vector LayerProperties))
-> IO (Result, "properties" ::: Vector LayerProperties)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((() -> IO (Result, "properties" ::: Vector LayerProperties))
-> () -> IO (Result, "properties" ::: Vector LayerProperties)
forall a b. (a -> b) -> a -> b
$ ())) [0..(fromIntegral (pPropertyCount)) - 1]
  r' <- lift $ traceAroundEvent "vkEnumerateInstanceLayerProperties" (vkEnumerateInstanceLayerProperties'
                                                                        (pPPropertyCount)
                                                                        ((pPProperties)))
  lift $ when (r' < SUCCESS) (throwIO (VulkanException r'))
  pPropertyCount' <- lift $ peek @Word32 pPPropertyCount
  pProperties' <- lift $ generateM (fromIntegral (pPropertyCount')) (\Int
i -> forall a. FromCStruct a => Ptr a -> IO a
peekCStruct @LayerProperties (((Ptr LayerProperties
pPProperties) Ptr LayerProperties -> Int -> Ptr LayerProperties
forall a. Ptr a -> Int -> Ptr a
`advancePtrBytes` (Int
520 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
i)) :: Ptr LayerProperties)))
  pure $ ((r'), pProperties')


foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkEnumerateDeviceLayerProperties
  :: FunPtr (Ptr PhysicalDevice_T -> Ptr Word32 -> Ptr LayerProperties -> IO Result) -> Ptr PhysicalDevice_T -> Ptr Word32 -> Ptr LayerProperties -> IO Result

-- | vkEnumerateDeviceLayerProperties - Returns properties of available
-- physical device layers
--
-- = Description
--
-- If @pProperties@ is @NULL@, then the number of layer properties
-- available is returned in @pPropertyCount@. Otherwise, @pPropertyCount@
-- /must/ point to a variable set by the application to the number of
-- elements in the @pProperties@ array, and on return the variable is
-- overwritten with the number of structures actually written to
-- @pProperties@. If @pPropertyCount@ is less than the number of layer
-- properties available, at most @pPropertyCount@ structures will be
-- written, and 'Vulkan.Core10.Enums.Result.INCOMPLETE' will be returned
-- instead of 'Vulkan.Core10.Enums.Result.SUCCESS', to indicate that not
-- all the available properties were returned.
--
-- The list of layers enumerated by 'enumerateDeviceLayerProperties' /must/
-- be exactly the sequence of layers enabled for the instance. The members
-- of 'LayerProperties' for each enumerated layer /must/ be the same as the
-- properties when the layer was enumerated by
-- 'enumerateInstanceLayerProperties'.
--
-- Due to platform details on Android, 'enumerateDeviceLayerProperties' may
-- be called with @physicalDevice@ equal to @NULL@ during layer discovery.
-- This behavior will only be observed by layer implementations, and not
-- the underlying Vulkan driver.
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter#
--     @physicalDevice@ /must/ be a valid
--     'Vulkan.Core10.Handles.PhysicalDevice' handle
--
-- -   #VUID-vkEnumerateDeviceLayerProperties-pPropertyCount-parameter#
--     @pPropertyCount@ /must/ be a valid pointer to a @uint32_t@ value
--
-- -   #VUID-vkEnumerateDeviceLayerProperties-pProperties-parameter# If the
--     value referenced by @pPropertyCount@ is not @0@, and @pProperties@
--     is not @NULL@, @pProperties@ /must/ be a valid pointer to an array
--     of @pPropertyCount@ 'LayerProperties' structures
--
-- == Return Codes
--
-- [<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-successcodes Success>]
--
--     -   'Vulkan.Core10.Enums.Result.INCOMPLETE'
--
--     -   'Vulkan.Core10.Enums.Result.SUCCESS'
--
-- [<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-errorcodes Failure>]
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_OUT_OF_DEVICE_MEMORY'
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_OUT_OF_HOST_MEMORY'
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_UNKNOWN'
--
--     -   'Vulkan.Core10.Enums.Result.ERROR_VALIDATION_FAILED'
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_VERSION_1_0 VK_VERSION_1_0>,
-- 'LayerProperties', 'Vulkan.Core10.Handles.PhysicalDevice'
enumerateDeviceLayerProperties :: forall io
                                . (MonadIO io)
                               => -- | @physicalDevice@ is the physical device that will be queried.
                                  PhysicalDevice
                               -> io (Result, ("properties" ::: Vector LayerProperties))
enumerateDeviceLayerProperties :: forall (io :: * -> *).
MonadIO io =>
PhysicalDevice
-> io (Result, "properties" ::: Vector LayerProperties)
enumerateDeviceLayerProperties PhysicalDevice
physicalDevice = IO (Result, "properties" ::: Vector LayerProperties)
-> io (Result, "properties" ::: Vector LayerProperties)
forall a. IO a -> io a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Result, "properties" ::: Vector LayerProperties)
 -> io (Result, "properties" ::: Vector LayerProperties))
-> (ContT
      (Result, "properties" ::: Vector LayerProperties)
      IO
      (Result, "properties" ::: Vector LayerProperties)
    -> IO (Result, "properties" ::: Vector LayerProperties))
-> ContT
     (Result, "properties" ::: Vector LayerProperties)
     IO
     (Result, "properties" ::: Vector LayerProperties)
-> io (Result, "properties" ::: Vector LayerProperties)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContT
  (Result, "properties" ::: Vector LayerProperties)
  IO
  (Result, "properties" ::: Vector LayerProperties)
-> IO (Result, "properties" ::: Vector LayerProperties)
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT
   (Result, "properties" ::: Vector LayerProperties)
   IO
   (Result, "properties" ::: Vector LayerProperties)
 -> io (Result, "properties" ::: Vector LayerProperties))
-> ContT
     (Result, "properties" ::: Vector LayerProperties)
     IO
     (Result, "properties" ::: Vector LayerProperties)
-> io (Result, "properties" ::: Vector LayerProperties)
forall a b. (a -> b) -> a -> b
$ do
  let vkEnumerateDeviceLayerPropertiesPtr :: FunPtr
  (Ptr PhysicalDevice_T
   -> Ptr Word32 -> Ptr LayerProperties -> IO Result)
vkEnumerateDeviceLayerPropertiesPtr = InstanceCmds
-> FunPtr
     (Ptr PhysicalDevice_T
      -> Ptr Word32 -> Ptr LayerProperties -> IO Result)
pVkEnumerateDeviceLayerProperties (case PhysicalDevice
physicalDevice of PhysicalDevice{InstanceCmds
instanceCmds :: InstanceCmds
instanceCmds :: PhysicalDevice -> InstanceCmds
instanceCmds} -> InstanceCmds
instanceCmds)
  FN_vkVoidFunction
-> ContT (Result, "properties" ::: Vector LayerProperties) IO ()
forall (m :: * -> *) a.
Monad m =>
m a -> ContT (Result, "properties" ::: Vector LayerProperties) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (FN_vkVoidFunction
 -> ContT (Result, "properties" ::: Vector LayerProperties) IO ())
-> FN_vkVoidFunction
-> ContT (Result, "properties" ::: Vector LayerProperties) IO ()
forall a b. (a -> b) -> a -> b
$ Bool -> FN_vkVoidFunction -> FN_vkVoidFunction
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (FunPtr
  (Ptr PhysicalDevice_T
   -> Ptr Word32 -> Ptr LayerProperties -> IO Result)
vkEnumerateDeviceLayerPropertiesPtr FunPtr
  (Ptr PhysicalDevice_T
   -> Ptr Word32 -> Ptr LayerProperties -> IO Result)
-> FunPtr
     (Ptr PhysicalDevice_T
      -> Ptr Word32 -> Ptr LayerProperties -> IO Result)
-> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr
  (Ptr PhysicalDevice_T
   -> Ptr Word32 -> Ptr LayerProperties -> IO Result)
forall a. FunPtr a
nullFunPtr) (FN_vkVoidFunction -> FN_vkVoidFunction)
-> FN_vkVoidFunction -> FN_vkVoidFunction
forall a b. (a -> b) -> a -> b
$
    IOException -> FN_vkVoidFunction
forall e a. (HasCallStack, Exception e) => e -> IO a
throwIO (IOException -> FN_vkVoidFunction)
-> IOException -> FN_vkVoidFunction
forall a b. (a -> b) -> a -> b
$ Maybe Handle
-> IOErrorType
-> String
-> String
-> Maybe CInt
-> Maybe String
-> IOException
IOError Maybe Handle
forall a. Maybe a
Nothing IOErrorType
InvalidArgument String
"" String
"The function pointer for vkEnumerateDeviceLayerProperties is null" Maybe CInt
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing
  let vkEnumerateDeviceLayerProperties' :: Ptr PhysicalDevice_T
-> Ptr Word32 -> Ptr LayerProperties -> IO Result
vkEnumerateDeviceLayerProperties' = FunPtr
  (Ptr PhysicalDevice_T
   -> Ptr Word32 -> Ptr LayerProperties -> IO Result)
-> Ptr PhysicalDevice_T
-> Ptr Word32
-> Ptr LayerProperties
-> IO Result
mkVkEnumerateDeviceLayerProperties FunPtr
  (Ptr PhysicalDevice_T
   -> Ptr Word32 -> Ptr LayerProperties -> IO Result)
vkEnumerateDeviceLayerPropertiesPtr
  let physicalDevice' :: Ptr PhysicalDevice_T
physicalDevice' = PhysicalDevice -> Ptr PhysicalDevice_T
physicalDeviceHandle (PhysicalDevice
physicalDevice)
  pPPropertyCount <- ((Ptr Word32
  -> IO (Result, "properties" ::: Vector LayerProperties))
 -> IO (Result, "properties" ::: Vector LayerProperties))
-> ContT
     (Result, "properties" ::: Vector LayerProperties) IO (Ptr Word32)
forall {k} (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((Ptr Word32
   -> IO (Result, "properties" ::: Vector LayerProperties))
  -> IO (Result, "properties" ::: Vector LayerProperties))
 -> ContT
      (Result, "properties" ::: Vector LayerProperties) IO (Ptr Word32))
-> ((Ptr Word32
     -> IO (Result, "properties" ::: Vector LayerProperties))
    -> IO (Result, "properties" ::: Vector LayerProperties))
-> ContT
     (Result, "properties" ::: Vector LayerProperties) IO (Ptr Word32)
forall a b. (a -> b) -> a -> b
$ IO (Ptr Word32)
-> (Ptr Word32 -> FN_vkVoidFunction)
-> (Ptr Word32
    -> IO (Result, "properties" ::: Vector LayerProperties))
-> IO (Result, "properties" ::: Vector LayerProperties)
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket (forall a. Int -> IO (Ptr a)
callocBytes @Word32 Int
4) Ptr Word32 -> FN_vkVoidFunction
forall a. Ptr a -> FN_vkVoidFunction
free
  r <- lift $ traceAroundEvent "vkEnumerateDeviceLayerProperties" (vkEnumerateDeviceLayerProperties'
                                                                     physicalDevice'
                                                                     (pPPropertyCount)
                                                                     (nullPtr))
  lift $ when (r < SUCCESS) (throwIO (VulkanException r))
  pPropertyCount <- lift $ peek @Word32 pPPropertyCount
  pPProperties <- ContT $ bracket (callocBytes @LayerProperties ((fromIntegral (pPropertyCount)) * 520)) free
  _ <- traverse (\Int
i -> ((() -> IO (Result, "properties" ::: Vector LayerProperties))
 -> IO (Result, "properties" ::: Vector LayerProperties))
-> ContT (Result, "properties" ::: Vector LayerProperties) IO ()
forall {k} (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((() -> IO (Result, "properties" ::: Vector LayerProperties))
  -> IO (Result, "properties" ::: Vector LayerProperties))
 -> ContT (Result, "properties" ::: Vector LayerProperties) IO ())
-> ((() -> IO (Result, "properties" ::: Vector LayerProperties))
    -> IO (Result, "properties" ::: Vector LayerProperties))
-> ContT (Result, "properties" ::: Vector LayerProperties) IO ()
forall a b. (a -> b) -> a -> b
$ Ptr LayerProperties
-> IO (Result, "properties" ::: Vector LayerProperties)
-> IO (Result, "properties" ::: Vector LayerProperties)
forall b. Ptr LayerProperties -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> IO b -> IO b
pokeZeroCStruct (Ptr LayerProperties
pPProperties Ptr LayerProperties -> Int -> Ptr LayerProperties
forall a. Ptr a -> Int -> Ptr a
`advancePtrBytes` (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
520) :: Ptr LayerProperties) (IO (Result, "properties" ::: Vector LayerProperties)
 -> IO (Result, "properties" ::: Vector LayerProperties))
-> ((() -> IO (Result, "properties" ::: Vector LayerProperties))
    -> IO (Result, "properties" ::: Vector LayerProperties))
-> (() -> IO (Result, "properties" ::: Vector LayerProperties))
-> IO (Result, "properties" ::: Vector LayerProperties)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((() -> IO (Result, "properties" ::: Vector LayerProperties))
-> () -> IO (Result, "properties" ::: Vector LayerProperties)
forall a b. (a -> b) -> a -> b
$ ())) [0..(fromIntegral (pPropertyCount)) - 1]
  r' <- lift $ traceAroundEvent "vkEnumerateDeviceLayerProperties" (vkEnumerateDeviceLayerProperties'
                                                                      physicalDevice'
                                                                      (pPPropertyCount)
                                                                      ((pPProperties)))
  lift $ when (r' < SUCCESS) (throwIO (VulkanException r'))
  pPropertyCount' <- lift $ peek @Word32 pPPropertyCount
  pProperties' <- lift $ generateM (fromIntegral (pPropertyCount')) (\Int
i -> forall a. FromCStruct a => Ptr a -> IO a
peekCStruct @LayerProperties (((Ptr LayerProperties
pPProperties) Ptr LayerProperties -> Int -> Ptr LayerProperties
forall a. Ptr a -> Int -> Ptr a
`advancePtrBytes` (Int
520 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
i)) :: Ptr LayerProperties)))
  pure $ ((r'), pProperties')


-- | VkLayerProperties - Structure specifying layer properties
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_VERSION_1_0 VK_VERSION_1_0>,
-- 'enumerateDeviceLayerProperties', 'enumerateInstanceLayerProperties'
data LayerProperties = LayerProperties
  { -- | @layerName@ is an array of
    -- 'Vulkan.Core10.APIConstants.MAX_EXTENSION_NAME_SIZE' @char@ containing a
    -- null-terminated UTF-8 string which is the name of the layer. Use this
    -- name in the @ppEnabledLayerNames@ array passed in the
    -- 'Vulkan.Core10.DeviceInitialization.InstanceCreateInfo' structure to
    -- enable this layer for an instance.
    LayerProperties -> ByteString
layerName :: ByteString
  , -- | @specVersion@ is the Vulkan version the layer was written to, encoded as
    -- described in
    -- <https://registry.khronos.org/vulkan/specs/latest/html/vkspec.html#extendingvulkan-coreversions-versionnumbers>.
    LayerProperties -> Word32
specVersion :: Word32
  , -- | @implementationVersion@ is the version of this layer. It is an integer,
    -- increasing with backward compatible changes.
    LayerProperties -> Word32
implementationVersion :: Word32
  , -- | @description@ is an array of
    -- 'Vulkan.Core10.APIConstants.MAX_DESCRIPTION_SIZE' @char@ containing a
    -- null-terminated UTF-8 string which provides additional details that
    -- /can/ be used by the application to identify the layer.
    LayerProperties -> ByteString
description :: ByteString
  }
  deriving (Typeable)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (LayerProperties)
#endif
deriving instance Show LayerProperties

instance ToCStruct LayerProperties where
  withCStruct :: forall b. LayerProperties -> (Ptr LayerProperties -> IO b) -> IO b
withCStruct LayerProperties
x Ptr LayerProperties -> IO b
f = Int -> (Ptr LayerProperties -> IO b) -> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
520 ((Ptr LayerProperties -> IO b) -> IO b)
-> (Ptr LayerProperties -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr LayerProperties
p -> Ptr LayerProperties -> LayerProperties -> IO b -> IO b
forall b. Ptr LayerProperties -> LayerProperties -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr LayerProperties
p LayerProperties
x (Ptr LayerProperties -> IO b
f Ptr LayerProperties
p)
  pokeCStruct :: forall b. Ptr LayerProperties -> LayerProperties -> IO b -> IO b
pokeCStruct Ptr LayerProperties
p LayerProperties{Word32
ByteString
layerName :: LayerProperties -> ByteString
specVersion :: LayerProperties -> Word32
implementationVersion :: LayerProperties -> Word32
description :: LayerProperties -> ByteString
layerName :: ByteString
specVersion :: Word32
implementationVersion :: Word32
description :: ByteString
..} IO b
f = do
    Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar)
-> ByteString -> FN_vkVoidFunction
forall (n :: Nat).
KnownNat n =>
Ptr (FixedArray n CChar) -> ByteString -> FN_vkVoidFunction
pokeFixedLengthNullTerminatedByteString ((Ptr LayerProperties
p Ptr LayerProperties
-> Int -> Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar))) (ByteString
layerName)
    Ptr Word32 -> Word32 -> FN_vkVoidFunction
forall a. Storable a => Ptr a -> a -> FN_vkVoidFunction
poke ((Ptr LayerProperties
p Ptr LayerProperties -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256 :: Ptr Word32)) (Word32
specVersion)
    Ptr Word32 -> Word32 -> FN_vkVoidFunction
forall a. Storable a => Ptr a -> a -> FN_vkVoidFunction
poke ((Ptr LayerProperties
p Ptr LayerProperties -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
260 :: Ptr Word32)) (Word32
implementationVersion)
    Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar)
-> ByteString -> FN_vkVoidFunction
forall (n :: Nat).
KnownNat n =>
Ptr (FixedArray n CChar) -> ByteString -> FN_vkVoidFunction
pokeFixedLengthNullTerminatedByteString ((Ptr LayerProperties
p Ptr LayerProperties
-> Int -> Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264 :: Ptr (FixedArray MAX_DESCRIPTION_SIZE CChar))) (ByteString
description)
    IO b
f
  cStructSize :: Int
cStructSize = Int
520
  cStructAlignment :: Int
cStructAlignment = Int
4
  pokeZeroCStruct :: forall b. Ptr LayerProperties -> IO b -> IO b
pokeZeroCStruct Ptr LayerProperties
p IO b
f = do
    Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar)
-> ByteString -> FN_vkVoidFunction
forall (n :: Nat).
KnownNat n =>
Ptr (FixedArray n CChar) -> ByteString -> FN_vkVoidFunction
pokeFixedLengthNullTerminatedByteString ((Ptr LayerProperties
p Ptr LayerProperties
-> Int -> Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar))) (ByteString
forall a. Monoid a => a
mempty)
    Ptr Word32 -> Word32 -> FN_vkVoidFunction
forall a. Storable a => Ptr a -> a -> FN_vkVoidFunction
poke ((Ptr LayerProperties
p Ptr LayerProperties -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256 :: Ptr Word32)) (Word32
forall a. Zero a => a
zero)
    Ptr Word32 -> Word32 -> FN_vkVoidFunction
forall a. Storable a => Ptr a -> a -> FN_vkVoidFunction
poke ((Ptr LayerProperties
p Ptr LayerProperties -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
260 :: Ptr Word32)) (Word32
forall a. Zero a => a
zero)
    Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar)
-> ByteString -> FN_vkVoidFunction
forall (n :: Nat).
KnownNat n =>
Ptr (FixedArray n CChar) -> ByteString -> FN_vkVoidFunction
pokeFixedLengthNullTerminatedByteString ((Ptr LayerProperties
p Ptr LayerProperties
-> Int -> Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264 :: Ptr (FixedArray MAX_DESCRIPTION_SIZE CChar))) (ByteString
forall a. Monoid a => a
mempty)
    IO b
f

instance FromCStruct LayerProperties where
  peekCStruct :: Ptr LayerProperties -> IO LayerProperties
peekCStruct Ptr LayerProperties
p = do
    layerName <- ("pName" ::: Ptr CChar) -> IO ByteString
packCString (Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar)
-> "pName" ::: Ptr CChar
forall a (n :: Nat). Ptr (FixedArray n a) -> Ptr a
lowerArrayPtr ((Ptr LayerProperties
p Ptr LayerProperties
-> Int -> Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar))))
    specVersion <- peek @Word32 ((p `plusPtr` 256 :: Ptr Word32))
    implementationVersion <- peek @Word32 ((p `plusPtr` 260 :: Ptr Word32))
    description <- packCString (lowerArrayPtr ((p `plusPtr` 264 :: Ptr (FixedArray MAX_DESCRIPTION_SIZE CChar))))
    pure $ LayerProperties
             layerName specVersion implementationVersion description

instance Storable LayerProperties where
  sizeOf :: LayerProperties -> Int
sizeOf ~LayerProperties
_ = Int
520
  alignment :: LayerProperties -> Int
alignment ~LayerProperties
_ = Int
4
  peek :: Ptr LayerProperties -> IO LayerProperties
peek = Ptr LayerProperties -> IO LayerProperties
forall a. FromCStruct a => Ptr a -> IO a
peekCStruct
  poke :: Ptr LayerProperties -> LayerProperties -> FN_vkVoidFunction
poke Ptr LayerProperties
ptr LayerProperties
poked = Ptr LayerProperties
-> LayerProperties -> FN_vkVoidFunction -> FN_vkVoidFunction
forall b. Ptr LayerProperties -> LayerProperties -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr LayerProperties
ptr LayerProperties
poked (() -> FN_vkVoidFunction
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())

instance Zero LayerProperties where
  zero :: LayerProperties
zero = ByteString -> Word32 -> Word32 -> ByteString -> LayerProperties
LayerProperties
           ByteString
forall a. Monoid a => a
mempty
           Word32
forall a. Zero a => a
zero
           Word32
forall a. Zero a => a
zero
           ByteString
forall a. Monoid a => a
mempty