{-# language CPP #-}
-- | = Name
--
-- VK_EXT_shader_atomic_float - device extension
--
-- == VK_EXT_shader_atomic_float
--
-- [__Name String__]
--     @VK_EXT_shader_atomic_float@
--
-- [__Extension Type__]
--     Device extension
--
-- [__Registered Extension Number__]
--     261
--
-- [__Revision__]
--     1
--
-- [__Ratification Status__]
--     Not ratified
--
-- [__Extension and Version Dependencies__]
--     <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_KHR_get_physical_device_properties2 VK_KHR_get_physical_device_properties2>
--     or
--     <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#versions-1.1 Version 1.1>
--
-- [__Contact__]
--
--     -   Vikram Kushwaha
--         <https://github.com/KhronosGroup/Vulkan-Docs/issues/new?body=[VK_EXT_shader_atomic_float] @vkushwaha-nv%0A*Here describe the issue or question you have about the VK_EXT_shader_atomic_float extension* >
--
-- == Other Extension Metadata
--
-- [__Last Modified Date__]
--     2020-07-15
--
-- [__IP Status__]
--     No known IP claims.
--
-- [__Interactions and External Dependencies__]
--
--     -   This extension requires
--         <https://htmlpreview.github.io/?https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/EXT/SPV_EXT_shader_atomic_float_add.html SPV_EXT_shader_atomic_float_add>
--
--     -   This extension provides API support for
--         <https://github.com/KhronosGroup/GLSL/blob/master/extensions/ext/GLSL_EXT_shader_atomic_float.txt GL_EXT_shader_atomic_float>
--
-- [__Contributors__]
--
--     -   Vikram Kushwaha, NVIDIA
--
--     -   Jeff Bolz, NVIDIA
--
-- == Description
--
-- This extension allows a shader to contain floating-point atomic
-- operations on buffer, workgroup, and image memory. It also advertises
-- the SPIR-V @AtomicFloat32AddEXT@ and @AtomicFloat64AddEXT@ capabilities
-- that allows atomic addition on floating-points numbers. The supported
-- operations include @OpAtomicFAddEXT@, @OpAtomicExchange@, @OpAtomicLoad@
-- and @OpAtomicStore@.
--
-- == New Structures
--
-- -   Extending
--     'Vulkan.Core11.Promoted_From_VK_KHR_get_physical_device_properties2.PhysicalDeviceFeatures2',
--     'Vulkan.Core10.Device.DeviceCreateInfo':
--
--     -   'PhysicalDeviceShaderAtomicFloatFeaturesEXT'
--
-- == New Enum Constants
--
-- -   'EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME'
--
-- -   'EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION'
--
-- -   Extending 'Vulkan.Core10.Enums.StructureType.StructureType':
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT'
--
-- == New SPIR-V Capabilities
--
-- -   <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#spirvenv-capabilities-table-AtomicFloat32AddEXT AtomicFloat32AddEXT>
--
-- -   <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#spirvenv-capabilities-table-AtomicFloat64AddEXT AtomicFloat64AddEXT>
--
-- == Version History
--
-- -   Revision 1, 2020-07-15 (Vikram Kushwaha)
--
--     -   Internal revisions
--
-- == See Also
--
-- 'PhysicalDeviceShaderAtomicFloatFeaturesEXT'
--
-- == Document Notes
--
-- For more information, see the
-- <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VK_EXT_shader_atomic_float Vulkan Specification>
--
-- This page is a generated document. Fixes and changes should be made to
-- the generator scripts, not directly.
module Vulkan.Extensions.VK_EXT_shader_atomic_float  ( PhysicalDeviceShaderAtomicFloatFeaturesEXT(..)
                                                     , EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION
                                                     , pattern EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION
                                                     , EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME
                                                     , pattern EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME
                                                     ) where

import Foreign.Marshal.Alloc (allocaBytes)
import Foreign.Ptr (nullPtr)
import Foreign.Ptr (plusPtr)
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.Kind (Type)
import Vulkan.Core10.FundamentalTypes (bool32ToBool)
import Vulkan.Core10.FundamentalTypes (boolToBool32)
import Vulkan.Core10.FundamentalTypes (Bool32)
import Vulkan.Core10.Enums.StructureType (StructureType)
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT))
-- | VkPhysicalDeviceShaderAtomicFloatFeaturesEXT - Structure describing
-- features supported by VK_EXT_shader_atomic_float
--
-- = Members
--
-- This structure describes the following features:
--
-- = Description
--
-- If the 'PhysicalDeviceShaderAtomicFloatFeaturesEXT' structure is
-- included in the @pNext@ chain of the
-- 'Vulkan.Core11.Promoted_From_VK_KHR_get_physical_device_properties2.PhysicalDeviceFeatures2'
-- structure passed to
-- 'Vulkan.Core11.Promoted_From_VK_KHR_get_physical_device_properties2.getPhysicalDeviceFeatures2',
-- it is filled in to indicate whether each corresponding feature is
-- supported. 'PhysicalDeviceShaderAtomicFloatFeaturesEXT' /can/ also be
-- used in the @pNext@ chain of 'Vulkan.Core10.Device.DeviceCreateInfo' to
-- selectively enable these features.
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_EXT_shader_atomic_float VK_EXT_shader_atomic_float>,
-- 'Vulkan.Core10.FundamentalTypes.Bool32',
-- 'Vulkan.Core10.Enums.StructureType.StructureType'
data PhysicalDeviceShaderAtomicFloatFeaturesEXT = PhysicalDeviceShaderAtomicFloatFeaturesEXT
  { -- | #features-shaderBufferFloat32Atomics# @shaderBufferFloat32Atomics@
    -- indicates whether shaders /can/ perform 32-bit floating-point load,
    -- store and exchange atomic operations on storage buffers.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
shaderBufferFloat32Atomics :: Bool
  , -- | #features-shaderBufferFloat32AtomicAdd# @shaderBufferFloat32AtomicAdd@
    -- indicates whether shaders /can/ perform 32-bit floating-point add atomic
    -- operations on storage buffers.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
shaderBufferFloat32AtomicAdd :: Bool
  , -- | #features-shaderBufferFloat64Atomics# @shaderBufferFloat64Atomics@
    -- indicates whether shaders /can/ perform 64-bit floating-point load,
    -- store and exchange atomic operations on storage buffers.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
shaderBufferFloat64Atomics :: Bool
  , -- | #features-shaderBufferFloat64AtomicAdd# @shaderBufferFloat64AtomicAdd@
    -- indicates whether shaders /can/ perform 64-bit floating-point add atomic
    -- operations on storage buffers.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
shaderBufferFloat64AtomicAdd :: Bool
  , -- | #features-shaderSharedFloat32Atomics# @shaderSharedFloat32Atomics@
    -- indicates whether shaders /can/ perform 32-bit floating-point load,
    -- store and exchange atomic operations on shared and payload memory.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
shaderSharedFloat32Atomics :: Bool
  , -- | #features-shaderSharedFloat32AtomicAdd# @shaderSharedFloat32AtomicAdd@
    -- indicates whether shaders /can/ perform 32-bit floating-point add atomic
    -- operations on shared and payload memory.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
shaderSharedFloat32AtomicAdd :: Bool
  , -- | #features-shaderSharedFloat64Atomics# @shaderSharedFloat64Atomics@
    -- indicates whether shaders /can/ perform 64-bit floating-point load,
    -- store and exchange atomic operations on shared and payload memory.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
shaderSharedFloat64Atomics :: Bool
  , -- | #features-shaderSharedFloat64AtomicAdd# @shaderSharedFloat64AtomicAdd@
    -- indicates whether shaders /can/ perform 64-bit floating-point add atomic
    -- operations on shared and payload memory.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
shaderSharedFloat64AtomicAdd :: Bool
  , -- | #features-shaderImageFloat32Atomics# @shaderImageFloat32Atomics@
    -- indicates whether shaders /can/ perform 32-bit floating-point load,
    -- store and exchange atomic image operations.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
shaderImageFloat32Atomics :: Bool
  , -- | #features-shaderImageFloat32AtomicAdd# @shaderImageFloat32AtomicAdd@
    -- indicates whether shaders /can/ perform 32-bit floating-point add atomic
    -- image operations.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
shaderImageFloat32AtomicAdd :: Bool
  , -- | #features-sparseImageFloat32Atomics# @sparseImageFloat32Atomics@
    -- indicates whether 32-bit floating-point load, store and exchange atomic
    -- operations /can/ be used on sparse images.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
sparseImageFloat32Atomics :: Bool
  , -- | #features-sparseImageFloat32AtomicAdd# @sparseImageFloat32AtomicAdd@
    -- indicates whether 32-bit floating-point add atomic operations /can/ be
    -- used on sparse images.
    PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
sparseImageFloat32AtomicAdd :: Bool
  }
  deriving (Typeable, PhysicalDeviceShaderAtomicFloatFeaturesEXT
-> PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PhysicalDeviceShaderAtomicFloatFeaturesEXT
-> PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$c/= :: PhysicalDeviceShaderAtomicFloatFeaturesEXT
-> PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
== :: PhysicalDeviceShaderAtomicFloatFeaturesEXT
-> PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$c== :: PhysicalDeviceShaderAtomicFloatFeaturesEXT
-> PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (PhysicalDeviceShaderAtomicFloatFeaturesEXT)
#endif
deriving instance Show PhysicalDeviceShaderAtomicFloatFeaturesEXT

instance ToCStruct PhysicalDeviceShaderAtomicFloatFeaturesEXT where
  withCStruct :: forall b.
PhysicalDeviceShaderAtomicFloatFeaturesEXT
-> (Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT -> IO b) -> IO b
withCStruct PhysicalDeviceShaderAtomicFloatFeaturesEXT
x Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT -> IO b
f = forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
64 forall a b. (a -> b) -> a -> b
$ \Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p -> forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p PhysicalDeviceShaderAtomicFloatFeaturesEXT
x (Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT -> IO b
f Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p)
  pokeCStruct :: forall b.
Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
-> PhysicalDeviceShaderAtomicFloatFeaturesEXT -> IO b -> IO b
pokeCStruct Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p PhysicalDeviceShaderAtomicFloatFeaturesEXT{Bool
sparseImageFloat32AtomicAdd :: Bool
sparseImageFloat32Atomics :: Bool
shaderImageFloat32AtomicAdd :: Bool
shaderImageFloat32Atomics :: Bool
shaderSharedFloat64AtomicAdd :: Bool
shaderSharedFloat64Atomics :: Bool
shaderSharedFloat32AtomicAdd :: Bool
shaderSharedFloat32Atomics :: Bool
shaderBufferFloat64AtomicAdd :: Bool
shaderBufferFloat64Atomics :: Bool
shaderBufferFloat32AtomicAdd :: Bool
shaderBufferFloat32Atomics :: Bool
$sel:sparseImageFloat32AtomicAdd:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:sparseImageFloat32Atomics:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:shaderImageFloat32AtomicAdd:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:shaderImageFloat32Atomics:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:shaderSharedFloat64AtomicAdd:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:shaderSharedFloat64Atomics:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:shaderSharedFloat32AtomicAdd:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:shaderSharedFloat32Atomics:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:shaderBufferFloat64AtomicAdd:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:shaderBufferFloat64Atomics:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:shaderBufferFloat32AtomicAdd:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
$sel:shaderBufferFloat32Atomics:PhysicalDeviceShaderAtomicFloatFeaturesEXT :: PhysicalDeviceShaderAtomicFloatFeaturesEXT -> Bool
..} IO b
f = do
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT)
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (forall a. Ptr a
nullPtr)
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
shaderBufferFloat32Atomics))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
shaderBufferFloat32AtomicAdd))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
shaderBufferFloat64Atomics))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
shaderBufferFloat64AtomicAdd))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
shaderSharedFloat32Atomics))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
shaderSharedFloat32AtomicAdd))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
shaderSharedFloat64Atomics))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
shaderSharedFloat64AtomicAdd))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
shaderImageFloat32Atomics))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
52 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
shaderImageFloat32AtomicAdd))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
sparseImageFloat32Atomics))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
sparseImageFloat32AtomicAdd))
    IO b
f
  cStructSize :: Int
cStructSize = Int
64
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: forall b.
Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT -> IO b -> IO b
pokeZeroCStruct Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p IO b
f = do
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT)
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (forall a. Ptr a
nullPtr)
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
52 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    IO b
f

instance FromCStruct PhysicalDeviceShaderAtomicFloatFeaturesEXT where
  peekCStruct :: Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
-> IO PhysicalDeviceShaderAtomicFloatFeaturesEXT
peekCStruct Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p = do
    Bool32
shaderBufferFloat32Atomics <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr Bool32))
    Bool32
shaderBufferFloat32AtomicAdd <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr Bool32))
    Bool32
shaderBufferFloat64Atomics <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr Bool32))
    Bool32
shaderBufferFloat64AtomicAdd <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28 :: Ptr Bool32))
    Bool32
shaderSharedFloat32Atomics <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32 :: Ptr Bool32))
    Bool32
shaderSharedFloat32AtomicAdd <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36 :: Ptr Bool32))
    Bool32
shaderSharedFloat64Atomics <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40 :: Ptr Bool32))
    Bool32
shaderSharedFloat64AtomicAdd <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44 :: Ptr Bool32))
    Bool32
shaderImageFloat32Atomics <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48 :: Ptr Bool32))
    Bool32
shaderImageFloat32AtomicAdd <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
52 :: Ptr Bool32))
    Bool32
sparseImageFloat32Atomics <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56 :: Ptr Bool32))
    Bool32
sparseImageFloat32AtomicAdd <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceShaderAtomicFloatFeaturesEXT
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60 :: Ptr Bool32))
    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> PhysicalDeviceShaderAtomicFloatFeaturesEXT
PhysicalDeviceShaderAtomicFloatFeaturesEXT
             (Bool32 -> Bool
bool32ToBool Bool32
shaderBufferFloat32Atomics)
             (Bool32 -> Bool
bool32ToBool Bool32
shaderBufferFloat32AtomicAdd)
             (Bool32 -> Bool
bool32ToBool Bool32
shaderBufferFloat64Atomics)
             (Bool32 -> Bool
bool32ToBool Bool32
shaderBufferFloat64AtomicAdd)
             (Bool32 -> Bool
bool32ToBool Bool32
shaderSharedFloat32Atomics)
             (Bool32 -> Bool
bool32ToBool Bool32
shaderSharedFloat32AtomicAdd)
             (Bool32 -> Bool
bool32ToBool Bool32
shaderSharedFloat64Atomics)
             (Bool32 -> Bool
bool32ToBool Bool32
shaderSharedFloat64AtomicAdd)
             (Bool32 -> Bool
bool32ToBool Bool32
shaderImageFloat32Atomics)
             (Bool32 -> Bool
bool32ToBool Bool32
shaderImageFloat32AtomicAdd)
             (Bool32 -> Bool
bool32ToBool Bool32
sparseImageFloat32Atomics)
             (Bool32 -> Bool
bool32ToBool Bool32
sparseImageFloat32AtomicAdd)

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

instance Zero PhysicalDeviceShaderAtomicFloatFeaturesEXT where
  zero :: PhysicalDeviceShaderAtomicFloatFeaturesEXT
zero = Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> PhysicalDeviceShaderAtomicFloatFeaturesEXT
PhysicalDeviceShaderAtomicFloatFeaturesEXT
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero


type EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION = 1

-- No documentation found for TopLevel "VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION"
pattern EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION :: forall a . Integral a => a
pattern $bEXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION :: forall a. Integral a => a
$mEXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION :: forall {r} {a}.
Integral a =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION = 1


type EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME = "VK_EXT_shader_atomic_float"

-- No documentation found for TopLevel "VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME"
pattern EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME :: forall a . (Eq a, IsString a) => a
pattern $bEXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a
$mEXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME = "VK_EXT_shader_atomic_float"