{-# language CPP #-}
-- | = Name
--
-- VK_NVX_image_view_handle - device extension
--
-- = VK_NVX_image_view_handle
--
-- [__Name String__]
--     @VK_NVX_image_view_handle@
--
-- [__Extension Type__]
--     Device extension
--
-- [__Registered Extension Number__]
--     31
--
-- [__Revision__]
--     4
--
-- [__Ratification Status__]
--     Not ratified
--
-- [__Extension and Version Dependencies__]
--     None
--
-- [__Contact__]
--
--     -   Eric Werness
--         <https://github.com/KhronosGroup/Vulkan-Docs/issues/new?body=[VK_NVX_image_view_handle] @ewerness-nv%0A*Here describe the issue or question you have about the VK_NVX_image_view_handle extension* >
--
-- == Other Extension Metadata
--
-- [__Last Modified Date__]
--     2025-12-03
--
-- [__Contributors__]
--
--     -   Eric Werness, NVIDIA
--
--     -   Jeff Bolz, NVIDIA
--
--     -   Daniel Koch, NVIDIA
--
--     -   Liam Middlebrook, NVIDIA
--
--     -   Rodrigo Locatti, NVIDIA
--
-- == Description
--
-- This extension allows applications to query an opaque handle from an
-- image view for use as a sampled image or storage image. This provides no
-- direct functionality itself.
--
-- == New Commands
--
-- -   'getDeviceCombinedImageSamplerIndexNVX'
--
-- -   'getImageViewAddressNVX'
--
-- -   'getImageViewHandle64NVX'
--
-- -   'getImageViewHandleNVX'
--
-- == New Structures
--
-- -   'ImageViewAddressPropertiesNVX'
--
-- -   'ImageViewHandleInfoNVX'
--
-- == New Enum Constants
--
-- -   'NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME'
--
-- -   'NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION'
--
-- -   Extending 'Vulkan.Core10.Enums.StructureType.StructureType':
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX'
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX'
--
-- == Version History
--
-- -   Revision 4, 2025-12-03 (Rodrigo Locatti)
--
--     -   Add 'getDeviceCombinedImageSamplerIndexNVX'
--
-- -   Revision 3, 2024-11-04 (Liam Middlebrook)
--
--     -   Add 'getImageViewHandle64NVX'
--
-- -   Revision 2, 2020-04-03 (Piers Daniell)
--
--     -   Add 'getImageViewAddressNVX'
--
-- -   Revision 1, 2018-12-07 (Eric Werness)
--
--     -   Internal revisions
--
-- == See Also
--
-- No cross-references are available
--
-- == Document Notes
--
-- For more information, see the
-- <https://registry.khronos.org/vulkan/specs/latest/html/vkspec.html#VK_NVX_image_view_handle Vulkan Specification>.
--
-- This page is a generated document. Fixes and changes should be made to
-- the generator scripts, not directly.
module Vulkan.Extensions.VK_NVX_image_view_handle  ( getImageViewHandleNVX
                                                   , getImageViewHandle64NVX
                                                   , getImageViewAddressNVX
                                                   , getDeviceCombinedImageSamplerIndexNVX
                                                   , ImageViewHandleInfoNVX(..)
                                                   , ImageViewAddressPropertiesNVX(..)
                                                   , NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION
                                                   , pattern NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION
                                                   , NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME
                                                   , pattern NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME
                                                   ) where

import Vulkan.Internal.Utils (traceAroundEvent)
import Control.Monad (unless)
import Control.Monad.IO.Class (liftIO)
import Foreign.Marshal.Alloc (allocaBytes)
import GHC.Base (when)
import GHC.IO (throwIO)
import GHC.Ptr (nullFunPtr)
import Foreign.Ptr (nullPtr)
import Foreign.Ptr (plusPtr)
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.Cont (evalContT)
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.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 GHC.IO.Exception (IOErrorType(..))
import GHC.IO.Exception (IOException(..))
import Foreign.Ptr (FunPtr)
import Foreign.Ptr (Ptr)
import Data.Word (Word32)
import Data.Word (Word64)
import Data.Kind (Type)
import Control.Monad.Trans.Cont (ContT(..))
import Vulkan.NamedType ((:::))
import Vulkan.Core10.Enums.DescriptorType (DescriptorType)
import Vulkan.Core10.Handles (Device)
import Vulkan.Core10.Handles (Device(..))
import Vulkan.Core10.Handles (Device(Device))
import Vulkan.Core10.FundamentalTypes (DeviceAddress)
import Vulkan.Dynamic (DeviceCmds(pVkGetDeviceCombinedImageSamplerIndexNVX))
import Vulkan.Dynamic (DeviceCmds(pVkGetImageViewAddressNVX))
import Vulkan.Dynamic (DeviceCmds(pVkGetImageViewHandle64NVX))
import Vulkan.Dynamic (DeviceCmds(pVkGetImageViewHandleNVX))
import Vulkan.Core10.FundamentalTypes (DeviceSize)
import Vulkan.Core10.Handles (Device_T)
import Vulkan.Core10.Handles (ImageView)
import Vulkan.Core10.Handles (ImageView(..))
import Vulkan.Core10.Enums.Result (Result)
import Vulkan.Core10.Enums.Result (Result(..))
import Vulkan.Core10.Handles (Sampler)
import Vulkan.Core10.Enums.StructureType (StructureType)
import Vulkan.Exception (VulkanException(..))
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX))
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX))
import Vulkan.Core10.Enums.Result (Result(SUCCESS))
foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkGetImageViewHandleNVX
  :: FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32) -> Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32

-- | vkGetImageViewHandleNVX - Get the handle for an image view for a
-- specific descriptor type
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NVX_image_view_handle VK_NVX_image_view_handle>,
-- 'Vulkan.Core10.Handles.Device', 'ImageViewHandleInfoNVX'
getImageViewHandleNVX :: forall io
                       . (MonadIO io)
                      => -- | @device@ is the logical device that owns the image view.
                         --
                         -- #VUID-vkGetImageViewHandleNVX-device-parameter# @device@ /must/ be a
                         -- valid 'Vulkan.Core10.Handles.Device' handle
                         Device
                      -> -- | @pInfo@ describes the image view to query and type of handle.
                         --
                         -- #VUID-vkGetImageViewHandleNVX-pInfo-parameter# @pInfo@ /must/ be a valid
                         -- pointer to a valid 'ImageViewHandleInfoNVX' structure
                         ImageViewHandleInfoNVX
                      -> io (Word32)
getImageViewHandleNVX :: forall (io :: * -> *).
MonadIO io =>
Device -> ImageViewHandleInfoNVX -> io Word32
getImageViewHandleNVX Device
device ImageViewHandleInfoNVX
info = IO Word32 -> io Word32
forall a. IO a -> io a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> io Word32)
-> (ContT Word32 IO Word32 -> IO Word32)
-> ContT Word32 IO Word32
-> io Word32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContT Word32 IO Word32 -> IO Word32
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Word32 IO Word32 -> io Word32)
-> ContT Word32 IO Word32 -> io Word32
forall a b. (a -> b) -> a -> b
$ do
  let vkGetImageViewHandleNVXPtr :: FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32)
vkGetImageViewHandleNVXPtr = DeviceCmds
-> FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32)
pVkGetImageViewHandleNVX (case Device
device of Device{DeviceCmds
deviceCmds :: DeviceCmds
deviceCmds :: Device -> DeviceCmds
deviceCmds} -> DeviceCmds
deviceCmds)
  IO () -> ContT Word32 IO ()
forall (m :: * -> *) a. Monad m => m a -> ContT Word32 m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT Word32 IO ()) -> IO () -> ContT Word32 IO ()
forall a b. (a -> b) -> a -> b
$ Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32)
vkGetImageViewHandleNVXPtr FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32)
-> FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32)
-> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32)
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
    IOException -> IO ()
forall e a. (HasCallStack, Exception e) => e -> IO a
throwIO (IOException -> IO ()) -> IOException -> IO ()
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 vkGetImageViewHandleNVX is null" Maybe CInt
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing
  let vkGetImageViewHandleNVX' :: Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32
vkGetImageViewHandleNVX' = FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32)
-> Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32
mkVkGetImageViewHandleNVX FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word32)
vkGetImageViewHandleNVXPtr
  pInfo <- ((Ptr ImageViewHandleInfoNVX -> IO Word32) -> IO Word32)
-> ContT Word32 IO (Ptr ImageViewHandleInfoNVX)
forall {k} (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((Ptr ImageViewHandleInfoNVX -> IO Word32) -> IO Word32)
 -> ContT Word32 IO (Ptr ImageViewHandleInfoNVX))
-> ((Ptr ImageViewHandleInfoNVX -> IO Word32) -> IO Word32)
-> ContT Word32 IO (Ptr ImageViewHandleInfoNVX)
forall a b. (a -> b) -> a -> b
$ ImageViewHandleInfoNVX
-> (Ptr ImageViewHandleInfoNVX -> IO Word32) -> IO Word32
forall a b. ToCStruct a => a -> (Ptr a -> IO b) -> IO b
forall b.
ImageViewHandleInfoNVX
-> (Ptr ImageViewHandleInfoNVX -> IO b) -> IO b
withCStruct (ImageViewHandleInfoNVX
info)
  r <- lift $ traceAroundEvent "vkGetImageViewHandleNVX" (vkGetImageViewHandleNVX'
                                                            (deviceHandle (device))
                                                            pInfo)
  pure $ (r)


foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkGetImageViewHandle64NVX
  :: FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64) -> Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64

-- | vkGetImageViewHandle64NVX - Get the 64-bit handle for an image view for
-- a specific descriptor type
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NVX_image_view_handle VK_NVX_image_view_handle>,
-- 'Vulkan.Core10.Handles.Device', 'ImageViewHandleInfoNVX'
getImageViewHandle64NVX :: forall io
                         . (MonadIO io)
                        => -- | @device@ is the logical device that owns the image view.
                           --
                           -- #VUID-vkGetImageViewHandle64NVX-device-parameter# @device@ /must/ be a
                           -- valid 'Vulkan.Core10.Handles.Device' handle
                           Device
                        -> -- | @pInfo@ describes the image view to query and type of handle.
                           --
                           -- #VUID-vkGetImageViewHandle64NVX-pInfo-parameter# @pInfo@ /must/ be a
                           -- valid pointer to a valid 'ImageViewHandleInfoNVX' structure
                           ImageViewHandleInfoNVX
                        -> io (Word64)
getImageViewHandle64NVX :: forall (io :: * -> *).
MonadIO io =>
Device -> ImageViewHandleInfoNVX -> io Word64
getImageViewHandle64NVX Device
device ImageViewHandleInfoNVX
info = IO Word64 -> io Word64
forall a. IO a -> io a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> io Word64)
-> (ContT Word64 IO Word64 -> IO Word64)
-> ContT Word64 IO Word64
-> io Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContT Word64 IO Word64 -> IO Word64
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Word64 IO Word64 -> io Word64)
-> ContT Word64 IO Word64 -> io Word64
forall a b. (a -> b) -> a -> b
$ do
  let vkGetImageViewHandle64NVXPtr :: FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64)
vkGetImageViewHandle64NVXPtr = DeviceCmds
-> FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64)
pVkGetImageViewHandle64NVX (case Device
device of Device{DeviceCmds
deviceCmds :: Device -> DeviceCmds
deviceCmds :: DeviceCmds
deviceCmds} -> DeviceCmds
deviceCmds)
  IO () -> ContT Word64 IO ()
forall (m :: * -> *) a. Monad m => m a -> ContT Word64 m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT Word64 IO ()) -> IO () -> ContT Word64 IO ()
forall a b. (a -> b) -> a -> b
$ Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64)
vkGetImageViewHandle64NVXPtr FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64)
-> FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64)
-> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64)
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
    IOException -> IO ()
forall e a. (HasCallStack, Exception e) => e -> IO a
throwIO (IOException -> IO ()) -> IOException -> IO ()
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 vkGetImageViewHandle64NVX is null" Maybe CInt
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing
  let vkGetImageViewHandle64NVX' :: Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64
vkGetImageViewHandle64NVX' = FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64)
-> Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64
mkVkGetImageViewHandle64NVX FunPtr (Ptr Device_T -> Ptr ImageViewHandleInfoNVX -> IO Word64)
vkGetImageViewHandle64NVXPtr
  pInfo <- ((Ptr ImageViewHandleInfoNVX -> IO Word64) -> IO Word64)
-> ContT Word64 IO (Ptr ImageViewHandleInfoNVX)
forall {k} (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((Ptr ImageViewHandleInfoNVX -> IO Word64) -> IO Word64)
 -> ContT Word64 IO (Ptr ImageViewHandleInfoNVX))
-> ((Ptr ImageViewHandleInfoNVX -> IO Word64) -> IO Word64)
-> ContT Word64 IO (Ptr ImageViewHandleInfoNVX)
forall a b. (a -> b) -> a -> b
$ ImageViewHandleInfoNVX
-> (Ptr ImageViewHandleInfoNVX -> IO Word64) -> IO Word64
forall a b. ToCStruct a => a -> (Ptr a -> IO b) -> IO b
forall b.
ImageViewHandleInfoNVX
-> (Ptr ImageViewHandleInfoNVX -> IO b) -> IO b
withCStruct (ImageViewHandleInfoNVX
info)
  r <- lift $ traceAroundEvent "vkGetImageViewHandle64NVX" (vkGetImageViewHandle64NVX'
                                                              (deviceHandle (device))
                                                              pInfo)
  pure $ (r)


foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkGetImageViewAddressNVX
  :: FunPtr (Ptr Device_T -> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result) -> Ptr Device_T -> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result

-- | vkGetImageViewAddressNVX - Get the device address of an image view
--
-- == Return Codes
--
-- [<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#fundamentals-successcodes Success>]
--
--     -   '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_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_NVX_image_view_handle VK_NVX_image_view_handle>,
-- 'Vulkan.Core10.Handles.Device', 'Vulkan.Core10.Handles.ImageView',
-- 'ImageViewAddressPropertiesNVX'
getImageViewAddressNVX :: forall io
                        . (MonadIO io)
                       => -- | @device@ is the logical device that owns the image view.
                          --
                          -- #VUID-vkGetImageViewAddressNVX-device-parameter# @device@ /must/ be a
                          -- valid 'Vulkan.Core10.Handles.Device' handle
                          Device
                       -> -- | @imageView@ is a handle to the image view.
                          --
                          -- #VUID-vkGetImageViewAddressNVX-imageView-parameter# @imageView@ /must/
                          -- be a valid 'Vulkan.Core10.Handles.ImageView' handle
                          --
                          -- #VUID-vkGetImageViewAddressNVX-imageView-parent# @imageView@ /must/ have
                          -- been created, allocated, or retrieved from @device@
                          ImageView
                       -> io (ImageViewAddressPropertiesNVX)
getImageViewAddressNVX :: forall (io :: * -> *).
MonadIO io =>
Device -> ImageView -> io ImageViewAddressPropertiesNVX
getImageViewAddressNVX Device
device ImageView
imageView = IO ImageViewAddressPropertiesNVX
-> io ImageViewAddressPropertiesNVX
forall a. IO a -> io a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ImageViewAddressPropertiesNVX
 -> io ImageViewAddressPropertiesNVX)
-> (ContT
      ImageViewAddressPropertiesNVX IO ImageViewAddressPropertiesNVX
    -> IO ImageViewAddressPropertiesNVX)
-> ContT
     ImageViewAddressPropertiesNVX IO ImageViewAddressPropertiesNVX
-> io ImageViewAddressPropertiesNVX
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContT
  ImageViewAddressPropertiesNVX IO ImageViewAddressPropertiesNVX
-> IO ImageViewAddressPropertiesNVX
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT
   ImageViewAddressPropertiesNVX IO ImageViewAddressPropertiesNVX
 -> io ImageViewAddressPropertiesNVX)
-> ContT
     ImageViewAddressPropertiesNVX IO ImageViewAddressPropertiesNVX
-> io ImageViewAddressPropertiesNVX
forall a b. (a -> b) -> a -> b
$ do
  let vkGetImageViewAddressNVXPtr :: FunPtr
  (Ptr Device_T
   -> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result)
vkGetImageViewAddressNVXPtr = DeviceCmds
-> FunPtr
     (Ptr Device_T
      -> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result)
pVkGetImageViewAddressNVX (case Device
device of Device{DeviceCmds
deviceCmds :: Device -> DeviceCmds
deviceCmds :: DeviceCmds
deviceCmds} -> DeviceCmds
deviceCmds)
  IO () -> ContT ImageViewAddressPropertiesNVX IO ()
forall (m :: * -> *) a.
Monad m =>
m a -> ContT ImageViewAddressPropertiesNVX m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT ImageViewAddressPropertiesNVX IO ())
-> IO () -> ContT ImageViewAddressPropertiesNVX IO ()
forall a b. (a -> b) -> a -> b
$ Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (FunPtr
  (Ptr Device_T
   -> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result)
vkGetImageViewAddressNVXPtr FunPtr
  (Ptr Device_T
   -> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result)
-> FunPtr
     (Ptr Device_T
      -> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result)
-> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr
  (Ptr Device_T
   -> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result)
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
    IOException -> IO ()
forall e a. (HasCallStack, Exception e) => e -> IO a
throwIO (IOException -> IO ()) -> IOException -> IO ()
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 vkGetImageViewAddressNVX is null" Maybe CInt
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing
  let vkGetImageViewAddressNVX' :: Ptr Device_T
-> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result
vkGetImageViewAddressNVX' = FunPtr
  (Ptr Device_T
   -> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result)
-> Ptr Device_T
-> ImageView
-> Ptr ImageViewAddressPropertiesNVX
-> IO Result
mkVkGetImageViewAddressNVX FunPtr
  (Ptr Device_T
   -> ImageView -> Ptr ImageViewAddressPropertiesNVX -> IO Result)
vkGetImageViewAddressNVXPtr
  pPProperties <- ((Ptr ImageViewAddressPropertiesNVX
  -> IO ImageViewAddressPropertiesNVX)
 -> IO ImageViewAddressPropertiesNVX)
-> ContT
     ImageViewAddressPropertiesNVX
     IO
     (Ptr ImageViewAddressPropertiesNVX)
forall {k} (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (forall a b. ToCStruct a => (Ptr a -> IO b) -> IO b
withZeroCStruct @ImageViewAddressPropertiesNVX)
  r <- lift $ traceAroundEvent "vkGetImageViewAddressNVX" (vkGetImageViewAddressNVX'
                                                             (deviceHandle (device))
                                                             (imageView)
                                                             (pPProperties))
  lift $ when (r < SUCCESS) (throwIO (VulkanException r))
  pProperties <- lift $ peekCStruct @ImageViewAddressPropertiesNVX pPProperties
  pure $ (pProperties)


foreign import ccall
#if !defined(SAFE_FOREIGN_CALLS)
  unsafe
#endif
  "dynamic" mkVkGetDeviceCombinedImageSamplerIndexNVX
  :: FunPtr (Ptr Device_T -> Word64 -> Word64 -> IO Word64) -> Ptr Device_T -> Word64 -> Word64 -> IO Word64

-- | vkGetDeviceCombinedImageSamplerIndexNVX - Get the handle for an image
-- view and sampler index
--
-- = Description
--
-- Shaders take @imageViewIndex@ and @samplerIndex@, and multiply it by
-- 'Vulkan.Extensions.VK_EXT_descriptor_heap.PhysicalDeviceDescriptorHeapPropertiesEXT'::@imageDescriptorSize@
-- and
-- 'Vulkan.Extensions.VK_EXT_descriptor_heap.PhysicalDeviceDescriptorHeapPropertiesEXT'::@samplerDescriptorSize@
-- respectively to obtain the descriptor offset in bytes.
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NVX_image_view_handle VK_NVX_image_view_handle>,
-- 'Vulkan.Core10.Handles.Device'
getDeviceCombinedImageSamplerIndexNVX :: forall io
                                       . (MonadIO io)
                                      => -- | @device@ is the logical device that will use the result handle.
                                         --
                                         -- #VUID-vkGetDeviceCombinedImageSamplerIndexNVX-device-parameter# @device@
                                         -- /must/ be a valid 'Vulkan.Core10.Handles.Device' handle
                                         Device
                                      -> -- | @imageViewIndex@ is the index within the resource heap.
                                         ("imageViewIndex" ::: Word64)
                                      -> -- | @samplerIndex@ is the index within the sampler heap.
                                         ("samplerIndex" ::: Word64)
                                      -> io (Word64)
getDeviceCombinedImageSamplerIndexNVX :: forall (io :: * -> *).
MonadIO io =>
Device -> Word64 -> Word64 -> io Word64
getDeviceCombinedImageSamplerIndexNVX Device
device
                                        Word64
imageViewIndex
                                        Word64
samplerIndex = IO Word64 -> io Word64
forall a. IO a -> io a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> io Word64) -> IO Word64 -> io Word64
forall a b. (a -> b) -> a -> b
$ do
  let vkGetDeviceCombinedImageSamplerIndexNVXPtr :: FunPtr (Ptr Device_T -> Word64 -> Word64 -> IO Word64)
vkGetDeviceCombinedImageSamplerIndexNVXPtr = DeviceCmds
-> FunPtr (Ptr Device_T -> Word64 -> Word64 -> IO Word64)
pVkGetDeviceCombinedImageSamplerIndexNVX (case Device
device of Device{DeviceCmds
deviceCmds :: Device -> DeviceCmds
deviceCmds :: DeviceCmds
deviceCmds} -> DeviceCmds
deviceCmds)
  Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (FunPtr (Ptr Device_T -> Word64 -> Word64 -> IO Word64)
vkGetDeviceCombinedImageSamplerIndexNVXPtr FunPtr (Ptr Device_T -> Word64 -> Word64 -> IO Word64)
-> FunPtr (Ptr Device_T -> Word64 -> Word64 -> IO Word64) -> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr (Ptr Device_T -> Word64 -> Word64 -> IO Word64)
forall a. FunPtr a
nullFunPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
    IOException -> IO ()
forall e a. (HasCallStack, Exception e) => e -> IO a
throwIO (IOException -> IO ()) -> IOException -> IO ()
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 vkGetDeviceCombinedImageSamplerIndexNVX is null" Maybe CInt
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing
  let vkGetDeviceCombinedImageSamplerIndexNVX' :: Ptr Device_T -> Word64 -> Word64 -> IO Word64
vkGetDeviceCombinedImageSamplerIndexNVX' = FunPtr (Ptr Device_T -> Word64 -> Word64 -> IO Word64)
-> Ptr Device_T -> Word64 -> Word64 -> IO Word64
mkVkGetDeviceCombinedImageSamplerIndexNVX FunPtr (Ptr Device_T -> Word64 -> Word64 -> IO Word64)
vkGetDeviceCombinedImageSamplerIndexNVXPtr
  r <- String -> IO Word64 -> IO Word64
forall a. String -> IO a -> IO a
traceAroundEvent String
"vkGetDeviceCombinedImageSamplerIndexNVX" (Ptr Device_T -> Word64 -> Word64 -> IO Word64
vkGetDeviceCombinedImageSamplerIndexNVX'
                                                                     (Device -> Ptr Device_T
deviceHandle (Device
device))
                                                                     (Word64
imageViewIndex)
                                                                     (Word64
samplerIndex))
  pure $ (r)


-- | VkImageViewHandleInfoNVX - Structure specifying the image view for
-- handle queries
--
-- == Valid Usage
--
-- -   #VUID-VkImageViewHandleInfoNVX-descriptorType-02654#
--     @descriptorType@ /must/ be
--     'Vulkan.Core10.Enums.DescriptorType.DESCRIPTOR_TYPE_SAMPLED_IMAGE',
--     'Vulkan.Core10.Enums.DescriptorType.DESCRIPTOR_TYPE_STORAGE_IMAGE',
--     or
--     'Vulkan.Core10.Enums.DescriptorType.DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER'
--
-- -   #VUID-VkImageViewHandleInfoNVX-sampler-02655# @sampler@ /must/ be a
--     valid 'Vulkan.Core10.Handles.Sampler' if @descriptorType@ is
--     'Vulkan.Core10.Enums.DescriptorType.DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER'
--
-- -   #VUID-VkImageViewHandleInfoNVX-imageView-02656# If descriptorType is
--     'Vulkan.Core10.Enums.DescriptorType.DESCRIPTOR_TYPE_SAMPLED_IMAGE'
--     or
--     'Vulkan.Core10.Enums.DescriptorType.DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER',
--     the image that @imageView@ was created from /must/ have been created
--     with the
--     'Vulkan.Core10.Enums.ImageUsageFlagBits.IMAGE_USAGE_SAMPLED_BIT'
--     usage flag set
--
-- -   #VUID-VkImageViewHandleInfoNVX-imageView-02657# If descriptorType is
--     'Vulkan.Core10.Enums.DescriptorType.DESCRIPTOR_TYPE_STORAGE_IMAGE',
--     the image that @imageView@ was created from /must/ have been created
--     with the
--     'Vulkan.Core10.Enums.ImageUsageFlagBits.IMAGE_USAGE_STORAGE_BIT'
--     usage flag set
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-VkImageViewHandleInfoNVX-sType-sType# @sType@ /must/ be
--     'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX'
--
-- -   #VUID-VkImageViewHandleInfoNVX-pNext-pNext# @pNext@ /must/ be @NULL@
--
-- -   #VUID-VkImageViewHandleInfoNVX-imageView-parameter# @imageView@
--     /must/ be a valid 'Vulkan.Core10.Handles.ImageView' handle
--
-- -   #VUID-VkImageViewHandleInfoNVX-descriptorType-parameter#
--     @descriptorType@ /must/ be a valid
--     'Vulkan.Core10.Enums.DescriptorType.DescriptorType' value
--
-- -   #VUID-VkImageViewHandleInfoNVX-sampler-parameter# If @sampler@ is
--     not 'Vulkan.Core10.APIConstants.NULL_HANDLE', @sampler@ /must/ be a
--     valid 'Vulkan.Core10.Handles.Sampler' handle
--
-- -   #VUID-VkImageViewHandleInfoNVX-commonparent# Both of @imageView@,
--     and @sampler@ that are valid handles of non-ignored parameters
--     /must/ have been created, allocated, or retrieved from the same
--     'Vulkan.Core10.Handles.Device'
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NVX_image_view_handle VK_NVX_image_view_handle>,
-- 'Vulkan.Core10.Enums.DescriptorType.DescriptorType',
-- 'Vulkan.Core10.Handles.ImageView', 'Vulkan.Core10.Handles.Sampler',
-- 'Vulkan.Core10.Enums.StructureType.StructureType',
-- 'getImageViewHandle64NVX', 'getImageViewHandleNVX'
data ImageViewHandleInfoNVX = ImageViewHandleInfoNVX
  { -- | @imageView@ is the image view to query.
    ImageViewHandleInfoNVX -> ImageView
imageView :: ImageView
  , -- | @descriptorType@ is the type of descriptor for which to query a handle.
    ImageViewHandleInfoNVX -> DescriptorType
descriptorType :: DescriptorType
  , -- | @sampler@ is the sampler to combine with the image view when generating
    -- the handle.
    ImageViewHandleInfoNVX -> Sampler
sampler :: Sampler
  }
  deriving (Typeable, ImageViewHandleInfoNVX -> ImageViewHandleInfoNVX -> Bool
(ImageViewHandleInfoNVX -> ImageViewHandleInfoNVX -> Bool)
-> (ImageViewHandleInfoNVX -> ImageViewHandleInfoNVX -> Bool)
-> Eq ImageViewHandleInfoNVX
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImageViewHandleInfoNVX -> ImageViewHandleInfoNVX -> Bool
== :: ImageViewHandleInfoNVX -> ImageViewHandleInfoNVX -> Bool
$c/= :: ImageViewHandleInfoNVX -> ImageViewHandleInfoNVX -> Bool
/= :: ImageViewHandleInfoNVX -> ImageViewHandleInfoNVX -> Bool
Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (ImageViewHandleInfoNVX)
#endif
deriving instance Show ImageViewHandleInfoNVX

instance ToCStruct ImageViewHandleInfoNVX where
  withCStruct :: forall b.
ImageViewHandleInfoNVX
-> (Ptr ImageViewHandleInfoNVX -> IO b) -> IO b
withCStruct ImageViewHandleInfoNVX
x Ptr ImageViewHandleInfoNVX -> IO b
f = Int -> (Ptr ImageViewHandleInfoNVX -> IO b) -> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
40 ((Ptr ImageViewHandleInfoNVX -> IO b) -> IO b)
-> (Ptr ImageViewHandleInfoNVX -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr ImageViewHandleInfoNVX
p -> Ptr ImageViewHandleInfoNVX
-> ImageViewHandleInfoNVX -> IO b -> IO b
forall b.
Ptr ImageViewHandleInfoNVX
-> ImageViewHandleInfoNVX -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr ImageViewHandleInfoNVX
p ImageViewHandleInfoNVX
x (Ptr ImageViewHandleInfoNVX -> IO b
f Ptr ImageViewHandleInfoNVX
p)
  pokeCStruct :: forall b.
Ptr ImageViewHandleInfoNVX
-> ImageViewHandleInfoNVX -> IO b -> IO b
pokeCStruct Ptr ImageViewHandleInfoNVX
p ImageViewHandleInfoNVX{DescriptorType
Sampler
ImageView
imageView :: ImageViewHandleInfoNVX -> ImageView
descriptorType :: ImageViewHandleInfoNVX -> DescriptorType
sampler :: ImageViewHandleInfoNVX -> Sampler
imageView :: ImageView
descriptorType :: DescriptorType
sampler :: Sampler
..} IO b
f = do
    Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewHandleInfoNVX
p Ptr ImageViewHandleInfoNVX -> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX)
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewHandleInfoNVX
p Ptr ImageViewHandleInfoNVX -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    Ptr ImageView -> ImageView -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewHandleInfoNVX
p Ptr ImageViewHandleInfoNVX -> Int -> Ptr ImageView
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr ImageView)) (ImageView
imageView)
    Ptr DescriptorType -> DescriptorType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewHandleInfoNVX
p Ptr ImageViewHandleInfoNVX -> Int -> Ptr DescriptorType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr DescriptorType)) (DescriptorType
descriptorType)
    Ptr Sampler -> Sampler -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewHandleInfoNVX
p Ptr ImageViewHandleInfoNVX -> Int -> Ptr Sampler
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32 :: Ptr Sampler)) (Sampler
sampler)
    IO b
f
  cStructSize :: Int
cStructSize = Int
40
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: forall b. Ptr ImageViewHandleInfoNVX -> IO b -> IO b
pokeZeroCStruct Ptr ImageViewHandleInfoNVX
p IO b
f = do
    Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewHandleInfoNVX
p Ptr ImageViewHandleInfoNVX -> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX)
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewHandleInfoNVX
p Ptr ImageViewHandleInfoNVX -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    Ptr ImageView -> ImageView -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewHandleInfoNVX
p Ptr ImageViewHandleInfoNVX -> Int -> Ptr ImageView
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr ImageView)) (ImageView
forall a. Zero a => a
zero)
    Ptr DescriptorType -> DescriptorType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewHandleInfoNVX
p Ptr ImageViewHandleInfoNVX -> Int -> Ptr DescriptorType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr DescriptorType)) (DescriptorType
forall a. Zero a => a
zero)
    IO b
f

instance FromCStruct ImageViewHandleInfoNVX where
  peekCStruct :: Ptr ImageViewHandleInfoNVX -> IO ImageViewHandleInfoNVX
peekCStruct Ptr ImageViewHandleInfoNVX
p = do
    imageView <- forall a. Storable a => Ptr a -> IO a
peek @ImageView ((Ptr ImageViewHandleInfoNVX
p Ptr ImageViewHandleInfoNVX -> Int -> Ptr ImageView
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr ImageView))
    descriptorType <- peek @DescriptorType ((p `plusPtr` 24 :: Ptr DescriptorType))
    sampler <- peek @Sampler ((p `plusPtr` 32 :: Ptr Sampler))
    pure $ ImageViewHandleInfoNVX
             imageView descriptorType sampler

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

instance Zero ImageViewHandleInfoNVX where
  zero :: ImageViewHandleInfoNVX
zero = ImageView -> DescriptorType -> Sampler -> ImageViewHandleInfoNVX
ImageViewHandleInfoNVX
           ImageView
forall a. Zero a => a
zero
           DescriptorType
forall a. Zero a => a
zero
           Sampler
forall a. Zero a => a
zero


-- | VkImageViewAddressPropertiesNVX - Structure specifying the image view
-- for handle queries
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NVX_image_view_handle VK_NVX_image_view_handle>,
-- 'Vulkan.Core10.FundamentalTypes.DeviceAddress',
-- 'Vulkan.Core10.FundamentalTypes.DeviceSize',
-- 'Vulkan.Core10.Enums.StructureType.StructureType',
-- 'getImageViewAddressNVX'
data ImageViewAddressPropertiesNVX = ImageViewAddressPropertiesNVX
  { -- | @deviceAddress@ is the device address of the image view.
    ImageViewAddressPropertiesNVX -> Word64
deviceAddress :: DeviceAddress
  , -- | @size@ is the size in bytes of the image view device memory.
    ImageViewAddressPropertiesNVX -> Word64
size :: DeviceSize
  }
  deriving (Typeable, ImageViewAddressPropertiesNVX
-> ImageViewAddressPropertiesNVX -> Bool
(ImageViewAddressPropertiesNVX
 -> ImageViewAddressPropertiesNVX -> Bool)
-> (ImageViewAddressPropertiesNVX
    -> ImageViewAddressPropertiesNVX -> Bool)
-> Eq ImageViewAddressPropertiesNVX
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImageViewAddressPropertiesNVX
-> ImageViewAddressPropertiesNVX -> Bool
== :: ImageViewAddressPropertiesNVX
-> ImageViewAddressPropertiesNVX -> Bool
$c/= :: ImageViewAddressPropertiesNVX
-> ImageViewAddressPropertiesNVX -> Bool
/= :: ImageViewAddressPropertiesNVX
-> ImageViewAddressPropertiesNVX -> Bool
Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (ImageViewAddressPropertiesNVX)
#endif
deriving instance Show ImageViewAddressPropertiesNVX

instance ToCStruct ImageViewAddressPropertiesNVX where
  withCStruct :: forall b.
ImageViewAddressPropertiesNVX
-> (Ptr ImageViewAddressPropertiesNVX -> IO b) -> IO b
withCStruct ImageViewAddressPropertiesNVX
x Ptr ImageViewAddressPropertiesNVX -> IO b
f = Int -> (Ptr ImageViewAddressPropertiesNVX -> IO b) -> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
32 ((Ptr ImageViewAddressPropertiesNVX -> IO b) -> IO b)
-> (Ptr ImageViewAddressPropertiesNVX -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr ImageViewAddressPropertiesNVX
p -> Ptr ImageViewAddressPropertiesNVX
-> ImageViewAddressPropertiesNVX -> IO b -> IO b
forall b.
Ptr ImageViewAddressPropertiesNVX
-> ImageViewAddressPropertiesNVX -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr ImageViewAddressPropertiesNVX
p ImageViewAddressPropertiesNVX
x (Ptr ImageViewAddressPropertiesNVX -> IO b
f Ptr ImageViewAddressPropertiesNVX
p)
  pokeCStruct :: forall b.
Ptr ImageViewAddressPropertiesNVX
-> ImageViewAddressPropertiesNVX -> IO b -> IO b
pokeCStruct Ptr ImageViewAddressPropertiesNVX
p ImageViewAddressPropertiesNVX{Word64
deviceAddress :: ImageViewAddressPropertiesNVX -> Word64
size :: ImageViewAddressPropertiesNVX -> Word64
deviceAddress :: Word64
size :: Word64
..} IO b
f = do
    Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewAddressPropertiesNVX
p Ptr ImageViewAddressPropertiesNVX -> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX)
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewAddressPropertiesNVX
p Ptr ImageViewAddressPropertiesNVX -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewAddressPropertiesNVX
p Ptr ImageViewAddressPropertiesNVX -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr DeviceAddress)) (Word64
deviceAddress)
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewAddressPropertiesNVX
p Ptr ImageViewAddressPropertiesNVX -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr DeviceSize)) (Word64
size)
    IO b
f
  cStructSize :: Int
cStructSize = Int
32
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: forall b. Ptr ImageViewAddressPropertiesNVX -> IO b -> IO b
pokeZeroCStruct Ptr ImageViewAddressPropertiesNVX
p IO b
f = do
    Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewAddressPropertiesNVX
p Ptr ImageViewAddressPropertiesNVX -> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX)
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewAddressPropertiesNVX
p Ptr ImageViewAddressPropertiesNVX -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewAddressPropertiesNVX
p Ptr ImageViewAddressPropertiesNVX -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr DeviceAddress)) (Word64
forall a. Zero a => a
zero)
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr ImageViewAddressPropertiesNVX
p Ptr ImageViewAddressPropertiesNVX -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr DeviceSize)) (Word64
forall a. Zero a => a
zero)
    IO b
f

instance FromCStruct ImageViewAddressPropertiesNVX where
  peekCStruct :: Ptr ImageViewAddressPropertiesNVX
-> IO ImageViewAddressPropertiesNVX
peekCStruct Ptr ImageViewAddressPropertiesNVX
p = do
    deviceAddress <- forall a. Storable a => Ptr a -> IO a
peek @DeviceAddress ((Ptr ImageViewAddressPropertiesNVX
p Ptr ImageViewAddressPropertiesNVX -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr DeviceAddress))
    size <- peek @DeviceSize ((p `plusPtr` 24 :: Ptr DeviceSize))
    pure $ ImageViewAddressPropertiesNVX
             deviceAddress size

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

instance Zero ImageViewAddressPropertiesNVX where
  zero :: ImageViewAddressPropertiesNVX
zero = Word64 -> Word64 -> ImageViewAddressPropertiesNVX
ImageViewAddressPropertiesNVX
           Word64
forall a. Zero a => a
zero
           Word64
forall a. Zero a => a
zero


type NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION = 4

-- No documentation found for TopLevel "VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION"
pattern NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION :: forall a . Integral a => a
pattern $mNVX_IMAGE_VIEW_HANDLE_SPEC_VERSION :: forall {r} {a}.
Integral a =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bNVX_IMAGE_VIEW_HANDLE_SPEC_VERSION :: forall a. Integral a => a
NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION = 4


type NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME = "VK_NVX_image_view_handle"

-- No documentation found for TopLevel "VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME"
pattern NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME :: forall a . (Eq a, IsString a) => a
pattern $mNVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
$bNVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a
NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME = "VK_NVX_image_view_handle"