{-# language CPP #-}
-- | = Name
--
-- VK_NV_ray_tracing_motion_blur - device extension
--
-- == VK_NV_ray_tracing_motion_blur
--
-- [__Name String__]
--     @VK_NV_ray_tracing_motion_blur@
--
-- [__Extension Type__]
--     Device extension
--
-- [__Registered Extension Number__]
--     328
--
-- [__Revision__]
--     1
--
-- [__Extension and Version Dependencies__]
--
--     -   Requires Vulkan 1.0
--
--     -   Requires @VK_KHR_ray_tracing_pipeline@
--
-- [__Contact__]
--
--     -   Eric Werness
--
-- == Other Extension Metadata
--
-- [__Last Modified Date__]
--     2021-06-16
--
-- [__Interactions and External Dependencies__]
--
--     -   This extension requires
--         <https://htmlpreview.github.io/?https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/NV/SPV_NV_ray_tracing_motion_blur.html SPV_NV_ray_tracing_motion_blur>
--
--     -   This extension provides API support for
--         <https://github.com/KhronosGroup/GLSL/blob/master/extensions/nv/GLSL_NV_ray_tracing_motion_blur.txt GL_NV_ray_tracing_motion_blur>
--
-- [__Contributors__]
--
--     -   Eric Werness, NVIDIA
--
--     -   Ashwin Lele, NVIDIA
--
-- == Description
--
-- Ray tracing support in the API provides an efficient mechanism to
-- intersect rays against static geometry, but rendering algorithms often
-- want to support motion, which is more efficiently supported with
-- motion-specific algorithms. This extension adds a set of mechanisms to
-- support fast tracing of moving geometry:
--
-- -   A ray pipeline trace call which takes a time parameter
--
-- -   Flags to enable motion support in an acceleration structure
--
-- -   Support for time-varying vertex positions in a geometry
--
-- -   Motion instances to move existing instances over time
--
-- The motion represented here is parameterized across a normalized
-- timestep between 0.0 and 1.0. A motion trace using @OpTraceRayMotionNV@
-- provides a time within that normalized range to be used when
-- intersecting that ray with geometry. The geometry can be provided with
-- motion by a combination of adding a second vertex position for time of
-- 1.0 using 'AccelerationStructureGeometryMotionTrianglesDataNV' and
-- providing multiple transforms in the instance using
-- 'AccelerationStructureMotionInstanceNV'.
--
-- == New Structures
--
-- -   'AccelerationStructureMatrixMotionInstanceNV'
--
-- -   'AccelerationStructureMotionInstanceNV'
--
-- -   'AccelerationStructureSRTMotionInstanceNV'
--
-- -   'SRTDataNV'
--
-- -   Extending
--     'Vulkan.Extensions.VK_KHR_acceleration_structure.AccelerationStructureCreateInfoKHR':
--
--     -   'AccelerationStructureMotionInfoNV'
--
-- -   Extending
--     'Vulkan.Extensions.VK_KHR_acceleration_structure.AccelerationStructureGeometryTrianglesDataKHR':
--
--     -   'AccelerationStructureGeometryMotionTrianglesDataNV'
--
-- -   Extending
--     'Vulkan.Core11.Promoted_From_VK_KHR_get_physical_device_properties2.PhysicalDeviceFeatures2',
--     'Vulkan.Core10.Device.DeviceCreateInfo':
--
--     -   'PhysicalDeviceRayTracingMotionBlurFeaturesNV'
--
-- == New Unions
--
-- -   'AccelerationStructureMotionInstanceDataNV'
--
-- == New Enums
--
-- -   'AccelerationStructureMotionInstanceTypeNV'
--
-- == New Bitmasks
--
-- -   'AccelerationStructureMotionInfoFlagsNV'
--
-- -   'AccelerationStructureMotionInstanceFlagsNV'
--
-- == New Enum Constants
--
-- -   'NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME'
--
-- -   'NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION'
--
-- -   Extending
--     'Vulkan.Extensions.VK_KHR_acceleration_structure.AccelerationStructureCreateFlagBitsKHR':
--
--     -   'Vulkan.Extensions.VK_KHR_acceleration_structure.ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV'
--
-- -   Extending
--     'Vulkan.Extensions.VK_KHR_acceleration_structure.BuildAccelerationStructureFlagBitsKHR':
--
--     -   'Vulkan.Extensions.VK_KHR_acceleration_structure.BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV'
--
-- -   Extending
--     'Vulkan.Core10.Enums.PipelineCreateFlagBits.PipelineCreateFlagBits':
--
--     -   'Vulkan.Core10.Enums.PipelineCreateFlagBits.PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV'
--
-- -   Extending 'Vulkan.Core10.Enums.StructureType.StructureType':
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV'
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV'
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV'
--
-- == Issues
--
-- (1) What size is VkAccelerationStructureMotionInstanceNV?
--
-- -   Added a note on the structure size and made the stride explicit in
--     the language.
--
-- (2) Allow arrayOfPointers for motion TLAS?
--
-- -   Yes, with a packed encoding to minimize the amount of data sent for
--     metadata.
--
-- == Version History
--
-- -   Revision 1, 2020-06-16 (Eric Werness, Ashwin Lele)
--
--     -   Initial external release
--
-- == See Also
--
-- 'AccelerationStructureGeometryMotionTrianglesDataNV',
-- 'AccelerationStructureMatrixMotionInstanceNV',
-- 'AccelerationStructureMotionInfoFlagsNV',
-- 'AccelerationStructureMotionInfoNV',
-- 'AccelerationStructureMotionInstanceDataNV',
-- 'AccelerationStructureMotionInstanceFlagsNV',
-- 'AccelerationStructureMotionInstanceNV',
-- 'AccelerationStructureMotionInstanceTypeNV',
-- 'AccelerationStructureSRTMotionInstanceNV',
-- 'PhysicalDeviceRayTracingMotionBlurFeaturesNV', 'SRTDataNV'
--
-- == Document Notes
--
-- For more information, see the
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_ray_tracing_motion_blur Vulkan Specification>
--
-- This page is a generated document. Fixes and changes should be made to
-- the generator scripts, not directly.
module Vulkan.Extensions.VK_NV_ray_tracing_motion_blur  ( PhysicalDeviceRayTracingMotionBlurFeaturesNV(..)
                                                        , AccelerationStructureGeometryMotionTrianglesDataNV(..)
                                                        , AccelerationStructureMotionInfoNV(..)
                                                        , SRTDataNV(..)
                                                        , AccelerationStructureSRTMotionInstanceNV(..)
                                                        , AccelerationStructureMatrixMotionInstanceNV(..)
                                                        , AccelerationStructureMotionInstanceNV(..)
                                                        , AccelerationStructureMotionInstanceDataNV(..)
                                                        , AccelerationStructureMotionInfoFlagsNV(..)
                                                        , AccelerationStructureMotionInstanceFlagsNV(..)
                                                        , AccelerationStructureMotionInstanceTypeNV( ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV
                                                                                                   , ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV
                                                                                                   , ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV
                                                                                                   , ..
                                                                                                   )
                                                        , NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION
                                                        , pattern NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION
                                                        , NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME
                                                        , pattern NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME
                                                        , TransformMatrixKHR(..)
                                                        , AccelerationStructureInstanceKHR(..)
                                                        , DeviceOrHostAddressConstKHR(..)
                                                        , GeometryInstanceFlagBitsKHR(..)
                                                        , GeometryInstanceFlagsKHR
                                                        , BuildAccelerationStructureFlagBitsKHR(..)
                                                        , BuildAccelerationStructureFlagsKHR
                                                        , AccelerationStructureCreateFlagBitsKHR(..)
                                                        , AccelerationStructureCreateFlagsKHR
                                                        ) where

import Vulkan.Internal.Utils (enumReadPrec)
import Vulkan.Internal.Utils (enumShowsPrec)
import Control.Exception.Base (bracket)
import Data.Bits ((.&.))
import Data.Bits ((.|.))
import Data.Bits (shiftL)
import Data.Bits (shiftR)
import Foreign.Marshal.Alloc (allocaBytes)
import Foreign.Marshal.Alloc (callocBytes)
import Foreign.Marshal.Alloc (free)
import GHC.Ptr (castPtr)
import Foreign.Ptr (nullPtr)
import Foreign.Ptr (plusPtr)
import GHC.Show (showString)
import GHC.Show (showsPrec)
import Numeric (showHex)
import Data.Coerce (coerce)
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.Cont (evalContT)
import Control.Monad.Trans.Cont (runContT)
import Vulkan.CStruct (FromCStruct)
import Vulkan.CStruct (FromCStruct(..))
import Vulkan.CStruct (ToCStruct)
import Vulkan.CStruct (ToCStruct(..))
import Vulkan.Zero (Zero)
import Vulkan.Zero (Zero(..))
import Data.Bits (Bits)
import Data.Bits (FiniteBits)
import Data.String (IsString)
import Data.Typeable (Typeable)
import Foreign.C.Types (CFloat)
import Foreign.C.Types (CFloat(..))
import Foreign.C.Types (CFloat(CFloat))
import Foreign.Storable (Storable)
import Foreign.Storable (Storable(peek))
import Foreign.Storable (Storable(poke))
import qualified Foreign.Storable (Storable(..))
import GHC.Generics (Generic)
import Data.Int (Int32)
import Foreign.Ptr (Ptr)
import GHC.Read (Read(readPrec))
import GHC.Show (Show(showsPrec))
import Data.Word (Word32)
import Data.Word (Word64)
import Data.Kind (Type)
import Control.Monad.Trans.Cont (ContT(..))
import Vulkan.Core10.FundamentalTypes (bool32ToBool)
import Vulkan.Core10.FundamentalTypes (boolToBool32)
import Vulkan.Extensions.VK_KHR_acceleration_structure (AccelerationStructureInstanceKHR)
import Vulkan.Core10.FundamentalTypes (Bool32)
import Vulkan.Extensions.VK_KHR_acceleration_structure (DeviceOrHostAddressConstKHR)
import Vulkan.Core10.FundamentalTypes (Flags)
import Vulkan.Extensions.VK_KHR_acceleration_structure (GeometryInstanceFlagsKHR)
import Vulkan.Core10.Enums.StructureType (StructureType)
import Vulkan.Extensions.VK_KHR_acceleration_structure (TransformMatrixKHR)
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV))
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV))
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV))
import Vulkan.Extensions.VK_KHR_acceleration_structure (AccelerationStructureCreateFlagBitsKHR(..))
import Vulkan.Extensions.VK_KHR_acceleration_structure (AccelerationStructureCreateFlagsKHR)
import Vulkan.Extensions.VK_KHR_acceleration_structure (AccelerationStructureInstanceKHR(..))
import Vulkan.Extensions.VK_KHR_acceleration_structure (BuildAccelerationStructureFlagBitsKHR(..))
import Vulkan.Extensions.VK_KHR_acceleration_structure (BuildAccelerationStructureFlagsKHR)
import Vulkan.Extensions.VK_KHR_acceleration_structure (DeviceOrHostAddressConstKHR(..))
import Vulkan.Extensions.VK_KHR_acceleration_structure (GeometryInstanceFlagBitsKHR(..))
import Vulkan.Extensions.VK_KHR_acceleration_structure (GeometryInstanceFlagsKHR)
import Vulkan.Extensions.VK_KHR_acceleration_structure (TransformMatrixKHR(..))
-- | VkPhysicalDeviceRayTracingMotionBlurFeaturesNV - Structure describing
-- the ray tracing motion blur features that can be supported by an
-- implementation
--
-- = Members
--
-- This structure describes the following feature:
--
-- = Description
--
-- If the 'PhysicalDeviceRayTracingMotionBlurFeaturesNV' 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. 'PhysicalDeviceRayTracingMotionBlurFeaturesNV' /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_NV_ray_tracing_motion_blur VK_NV_ray_tracing_motion_blur>,
-- 'Vulkan.Core10.FundamentalTypes.Bool32',
-- 'Vulkan.Core10.Enums.StructureType.StructureType'
data PhysicalDeviceRayTracingMotionBlurFeaturesNV = PhysicalDeviceRayTracingMotionBlurFeaturesNV
  { -- | #features-rayTracingMotionBlur# @rayTracingMotionBlur@ indicates whether
    -- the implementation supports the motion blur feature.
    PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool
rayTracingMotionBlur :: Bool
  , -- | #features-rayTracingMotionBlurPipelineTraceRaysIndirect#
    -- @rayTracingMotionBlurPipelineTraceRaysIndirect@ indicates whether the
    -- implementation supports indirect ray tracing commands with the motion
    -- blur feature enabled.
    PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool
rayTracingMotionBlurPipelineTraceRaysIndirect :: Bool
  }
  deriving (Typeable, PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool
(PhysicalDeviceRayTracingMotionBlurFeaturesNV
 -> PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool)
-> (PhysicalDeviceRayTracingMotionBlurFeaturesNV
    -> PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool)
-> Eq PhysicalDeviceRayTracingMotionBlurFeaturesNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool
$c/= :: PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool
== :: PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool
$c== :: PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool
Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (PhysicalDeviceRayTracingMotionBlurFeaturesNV)
#endif
deriving instance Show PhysicalDeviceRayTracingMotionBlurFeaturesNV

instance ToCStruct PhysicalDeviceRayTracingMotionBlurFeaturesNV where
  withCStruct :: PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> (Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV -> IO b)
-> IO b
withCStruct PhysicalDeviceRayTracingMotionBlurFeaturesNV
x Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV -> IO b
f = Int
-> (Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV -> IO b)
-> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
24 ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV -> IO b)
 -> IO b)
-> (Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV -> IO b)
-> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p -> Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> PhysicalDeviceRayTracingMotionBlurFeaturesNV -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p PhysicalDeviceRayTracingMotionBlurFeaturesNV
x (Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV -> IO b
f Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p)
  pokeCStruct :: Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> PhysicalDeviceRayTracingMotionBlurFeaturesNV -> IO b -> IO b
pokeCStruct Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p PhysicalDeviceRayTracingMotionBlurFeaturesNV{Bool
rayTracingMotionBlurPipelineTraceRaysIndirect :: Bool
rayTracingMotionBlur :: Bool
$sel:rayTracingMotionBlurPipelineTraceRaysIndirect:PhysicalDeviceRayTracingMotionBlurFeaturesNV :: PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool
$sel:rayTracingMotionBlur:PhysicalDeviceRayTracingMotionBlurFeaturesNV :: PhysicalDeviceRayTracingMotionBlurFeaturesNV -> Bool
..} IO b
f = do
    Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV)
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    Ptr Bool32 -> Bool32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> Int -> Ptr Bool32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
rayTracingMotionBlur))
    Ptr Bool32 -> Bool32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> Int -> Ptr Bool32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
rayTracingMotionBlurPipelineTraceRaysIndirect))
    IO b
f
  cStructSize :: Int
cStructSize = Int
24
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV -> IO b -> IO b
pokeZeroCStruct Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p IO b
f = do
    Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV)
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    Ptr Bool32 -> Bool32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> Int -> Ptr Bool32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
forall a. Zero a => a
zero))
    Ptr Bool32 -> Bool32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> Int -> Ptr Bool32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
forall a. Zero a => a
zero))
    IO b
f

instance FromCStruct PhysicalDeviceRayTracingMotionBlurFeaturesNV where
  peekCStruct :: Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> IO PhysicalDeviceRayTracingMotionBlurFeaturesNV
peekCStruct Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p = do
    Bool32
rayTracingMotionBlur <- Ptr Bool32 -> IO Bool32
forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> Int -> Ptr Bool32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr Bool32))
    Bool32
rayTracingMotionBlurPipelineTraceRaysIndirect <- Ptr Bool32 -> IO Bool32
forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
p Ptr PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> Int -> Ptr Bool32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr Bool32))
    PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> IO PhysicalDeviceRayTracingMotionBlurFeaturesNV
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PhysicalDeviceRayTracingMotionBlurFeaturesNV
 -> IO PhysicalDeviceRayTracingMotionBlurFeaturesNV)
-> PhysicalDeviceRayTracingMotionBlurFeaturesNV
-> IO PhysicalDeviceRayTracingMotionBlurFeaturesNV
forall a b. (a -> b) -> a -> b
$ Bool -> Bool -> PhysicalDeviceRayTracingMotionBlurFeaturesNV
PhysicalDeviceRayTracingMotionBlurFeaturesNV
             (Bool32 -> Bool
bool32ToBool Bool32
rayTracingMotionBlur) (Bool32 -> Bool
bool32ToBool Bool32
rayTracingMotionBlurPipelineTraceRaysIndirect)

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

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


-- | VkAccelerationStructureGeometryMotionTrianglesDataNV - Structure
-- specifying vertex motion in a bottom-level acceleration structure
--
-- = Description
--
-- If 'AccelerationStructureGeometryMotionTrianglesDataNV' is included in
-- the @pNext@ chain of a
-- 'Vulkan.Extensions.VK_KHR_acceleration_structure.AccelerationStructureGeometryTrianglesDataKHR'
-- structure, the basic vertex positions are used for the position of the
-- triangles in the geometry at time 0.0 and the @vertexData@ in
-- 'AccelerationStructureGeometryMotionTrianglesDataNV' is used for the
-- vertex positions at time 1.0, with positions linearly interpolated at
-- intermediate times.
--
-- Indexing for 'AccelerationStructureGeometryMotionTrianglesDataNV'
-- @vertexData@ is equivalent to the basic vertex position data.
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_ray_tracing_motion_blur VK_NV_ray_tracing_motion_blur>,
-- 'Vulkan.Extensions.VK_KHR_acceleration_structure.DeviceOrHostAddressConstKHR',
-- 'Vulkan.Core10.Enums.StructureType.StructureType'
data AccelerationStructureGeometryMotionTrianglesDataNV = AccelerationStructureGeometryMotionTrianglesDataNV
  { -- | @vertexData@ is a pointer to vertex data for this geometry at time 1.0
    AccelerationStructureGeometryMotionTrianglesDataNV
-> DeviceOrHostAddressConstKHR
vertexData :: DeviceOrHostAddressConstKHR }
  deriving (Typeable)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (AccelerationStructureGeometryMotionTrianglesDataNV)
#endif
deriving instance Show AccelerationStructureGeometryMotionTrianglesDataNV

instance ToCStruct AccelerationStructureGeometryMotionTrianglesDataNV where
  withCStruct :: AccelerationStructureGeometryMotionTrianglesDataNV
-> (Ptr AccelerationStructureGeometryMotionTrianglesDataNV -> IO b)
-> IO b
withCStruct AccelerationStructureGeometryMotionTrianglesDataNV
x Ptr AccelerationStructureGeometryMotionTrianglesDataNV -> IO b
f = Int
-> (Ptr AccelerationStructureGeometryMotionTrianglesDataNV -> IO b)
-> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
24 ((Ptr AccelerationStructureGeometryMotionTrianglesDataNV -> IO b)
 -> IO b)
-> (Ptr AccelerationStructureGeometryMotionTrianglesDataNV -> IO b)
-> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p -> Ptr AccelerationStructureGeometryMotionTrianglesDataNV
-> AccelerationStructureGeometryMotionTrianglesDataNV
-> IO b
-> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p AccelerationStructureGeometryMotionTrianglesDataNV
x (Ptr AccelerationStructureGeometryMotionTrianglesDataNV -> IO b
f Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p)
  pokeCStruct :: Ptr AccelerationStructureGeometryMotionTrianglesDataNV
-> AccelerationStructureGeometryMotionTrianglesDataNV
-> IO b
-> IO b
pokeCStruct Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p AccelerationStructureGeometryMotionTrianglesDataNV{DeviceOrHostAddressConstKHR
vertexData :: DeviceOrHostAddressConstKHR
$sel:vertexData:AccelerationStructureGeometryMotionTrianglesDataNV :: AccelerationStructureGeometryMotionTrianglesDataNV
-> DeviceOrHostAddressConstKHR
..} IO b
f = ContT b IO b -> IO b
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT b IO b -> IO b) -> ContT b IO b -> IO b
forall a b. (a -> b) -> a -> b
$ do
    IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p Ptr AccelerationStructureGeometryMotionTrianglesDataNV
-> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV)
    IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p Ptr AccelerationStructureGeometryMotionTrianglesDataNV
-> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    ((() -> IO b) -> IO b) -> ContT b IO ()
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((() -> IO b) -> IO b) -> ContT b IO ())
-> ((() -> IO b) -> IO b) -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr DeviceOrHostAddressConstKHR
-> DeviceOrHostAddressConstKHR -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct ((Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p Ptr AccelerationStructureGeometryMotionTrianglesDataNV
-> Int -> Ptr DeviceOrHostAddressConstKHR
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr DeviceOrHostAddressConstKHR)) (DeviceOrHostAddressConstKHR
vertexData) (IO b -> IO b) -> ((() -> IO b) -> IO b) -> (() -> IO b) -> IO b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((() -> IO b) -> () -> IO b
forall a b. (a -> b) -> a -> b
$ ())
    IO b -> ContT b IO b
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO b -> ContT b IO b) -> IO b -> ContT b IO b
forall a b. (a -> b) -> a -> b
$ IO b
f
  cStructSize :: Int
cStructSize = Int
24
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: Ptr AccelerationStructureGeometryMotionTrianglesDataNV
-> IO b -> IO b
pokeZeroCStruct Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p IO b
f = ContT b IO b -> IO b
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT b IO b -> IO b) -> ContT b IO b -> IO b
forall a b. (a -> b) -> a -> b
$ do
    IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p Ptr AccelerationStructureGeometryMotionTrianglesDataNV
-> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV)
    IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p Ptr AccelerationStructureGeometryMotionTrianglesDataNV
-> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    ((() -> IO b) -> IO b) -> ContT b IO ()
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((() -> IO b) -> IO b) -> ContT b IO ())
-> ((() -> IO b) -> IO b) -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr DeviceOrHostAddressConstKHR
-> DeviceOrHostAddressConstKHR -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct ((Ptr AccelerationStructureGeometryMotionTrianglesDataNV
p Ptr AccelerationStructureGeometryMotionTrianglesDataNV
-> Int -> Ptr DeviceOrHostAddressConstKHR
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr DeviceOrHostAddressConstKHR)) (DeviceOrHostAddressConstKHR
forall a. Zero a => a
zero) (IO b -> IO b) -> ((() -> IO b) -> IO b) -> (() -> IO b) -> IO b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((() -> IO b) -> () -> IO b
forall a b. (a -> b) -> a -> b
$ ())
    IO b -> ContT b IO b
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO b -> ContT b IO b) -> IO b -> ContT b IO b
forall a b. (a -> b) -> a -> b
$ IO b
f

instance Zero AccelerationStructureGeometryMotionTrianglesDataNV where
  zero :: AccelerationStructureGeometryMotionTrianglesDataNV
zero = DeviceOrHostAddressConstKHR
-> AccelerationStructureGeometryMotionTrianglesDataNV
AccelerationStructureGeometryMotionTrianglesDataNV
           DeviceOrHostAddressConstKHR
forall a. Zero a => a
zero


-- | VkAccelerationStructureMotionInfoNV - Structure specifying the
-- parameters of a newly created acceleration structure object
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_ray_tracing_motion_blur VK_NV_ray_tracing_motion_blur>,
-- 'AccelerationStructureMotionInfoFlagsNV',
-- 'Vulkan.Core10.Enums.StructureType.StructureType'
data AccelerationStructureMotionInfoNV = AccelerationStructureMotionInfoNV
  { -- | @maxInstances@ is the maximum number of instances that /may/ be used in
    -- the motion top-level acceleration structure.
    AccelerationStructureMotionInfoNV -> Word32
maxInstances :: Word32
  , -- | @flags@ is 0 and reserved for future use.
    --
    -- #VUID-VkAccelerationStructureMotionInfoNV-flags-zerobitmask# @flags@
    -- /must/ be @0@
    AccelerationStructureMotionInfoNV
-> AccelerationStructureMotionInfoFlagsNV
flags :: AccelerationStructureMotionInfoFlagsNV
  }
  deriving (Typeable, AccelerationStructureMotionInfoNV
-> AccelerationStructureMotionInfoNV -> Bool
(AccelerationStructureMotionInfoNV
 -> AccelerationStructureMotionInfoNV -> Bool)
-> (AccelerationStructureMotionInfoNV
    -> AccelerationStructureMotionInfoNV -> Bool)
-> Eq AccelerationStructureMotionInfoNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccelerationStructureMotionInfoNV
-> AccelerationStructureMotionInfoNV -> Bool
$c/= :: AccelerationStructureMotionInfoNV
-> AccelerationStructureMotionInfoNV -> Bool
== :: AccelerationStructureMotionInfoNV
-> AccelerationStructureMotionInfoNV -> Bool
$c== :: AccelerationStructureMotionInfoNV
-> AccelerationStructureMotionInfoNV -> Bool
Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (AccelerationStructureMotionInfoNV)
#endif
deriving instance Show AccelerationStructureMotionInfoNV

instance ToCStruct AccelerationStructureMotionInfoNV where
  withCStruct :: AccelerationStructureMotionInfoNV
-> (Ptr AccelerationStructureMotionInfoNV -> IO b) -> IO b
withCStruct AccelerationStructureMotionInfoNV
x Ptr AccelerationStructureMotionInfoNV -> IO b
f = Int -> (Ptr AccelerationStructureMotionInfoNV -> IO b) -> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
24 ((Ptr AccelerationStructureMotionInfoNV -> IO b) -> IO b)
-> (Ptr AccelerationStructureMotionInfoNV -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr AccelerationStructureMotionInfoNV
p -> Ptr AccelerationStructureMotionInfoNV
-> AccelerationStructureMotionInfoNV -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr AccelerationStructureMotionInfoNV
p AccelerationStructureMotionInfoNV
x (Ptr AccelerationStructureMotionInfoNV -> IO b
f Ptr AccelerationStructureMotionInfoNV
p)
  pokeCStruct :: Ptr AccelerationStructureMotionInfoNV
-> AccelerationStructureMotionInfoNV -> IO b -> IO b
pokeCStruct Ptr AccelerationStructureMotionInfoNV
p AccelerationStructureMotionInfoNV{Word32
AccelerationStructureMotionInfoFlagsNV
flags :: AccelerationStructureMotionInfoFlagsNV
maxInstances :: Word32
$sel:flags:AccelerationStructureMotionInfoNV :: AccelerationStructureMotionInfoNV
-> AccelerationStructureMotionInfoFlagsNV
$sel:maxInstances:AccelerationStructureMotionInfoNV :: AccelerationStructureMotionInfoNV -> Word32
..} IO b
f = do
    Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMotionInfoNV
p Ptr AccelerationStructureMotionInfoNV -> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV)
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMotionInfoNV
p Ptr AccelerationStructureMotionInfoNV -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMotionInfoNV
p Ptr AccelerationStructureMotionInfoNV -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr Word32)) (Word32
maxInstances)
    Ptr AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMotionInfoNV
p Ptr AccelerationStructureMotionInfoNV
-> Int -> Ptr AccelerationStructureMotionInfoFlagsNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr AccelerationStructureMotionInfoFlagsNV)) (AccelerationStructureMotionInfoFlagsNV
flags)
    IO b
f
  cStructSize :: Int
cStructSize = Int
24
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: Ptr AccelerationStructureMotionInfoNV -> IO b -> IO b
pokeZeroCStruct Ptr AccelerationStructureMotionInfoNV
p IO b
f = do
    Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMotionInfoNV
p Ptr AccelerationStructureMotionInfoNV -> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV)
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMotionInfoNV
p Ptr AccelerationStructureMotionInfoNV -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMotionInfoNV
p Ptr AccelerationStructureMotionInfoNV -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr Word32)) (Word32
forall a. Zero a => a
zero)
    IO b
f

instance FromCStruct AccelerationStructureMotionInfoNV where
  peekCStruct :: Ptr AccelerationStructureMotionInfoNV
-> IO AccelerationStructureMotionInfoNV
peekCStruct Ptr AccelerationStructureMotionInfoNV
p = do
    Word32
maxInstances <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek @Word32 ((Ptr AccelerationStructureMotionInfoNV
p Ptr AccelerationStructureMotionInfoNV -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr Word32))
    AccelerationStructureMotionInfoFlagsNV
flags <- Ptr AccelerationStructureMotionInfoFlagsNV
-> IO AccelerationStructureMotionInfoFlagsNV
forall a. Storable a => Ptr a -> IO a
peek @AccelerationStructureMotionInfoFlagsNV ((Ptr AccelerationStructureMotionInfoNV
p Ptr AccelerationStructureMotionInfoNV
-> Int -> Ptr AccelerationStructureMotionInfoFlagsNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr AccelerationStructureMotionInfoFlagsNV))
    AccelerationStructureMotionInfoNV
-> IO AccelerationStructureMotionInfoNV
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccelerationStructureMotionInfoNV
 -> IO AccelerationStructureMotionInfoNV)
-> AccelerationStructureMotionInfoNV
-> IO AccelerationStructureMotionInfoNV
forall a b. (a -> b) -> a -> b
$ Word32
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoNV
AccelerationStructureMotionInfoNV
             Word32
maxInstances AccelerationStructureMotionInfoFlagsNV
flags

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

instance Zero AccelerationStructureMotionInfoNV where
  zero :: AccelerationStructureMotionInfoNV
zero = Word32
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoNV
AccelerationStructureMotionInfoNV
           Word32
forall a. Zero a => a
zero
           AccelerationStructureMotionInfoFlagsNV
forall a. Zero a => a
zero


-- | VkSRTDataNV - Structure specifying a transform in SRT decomposition
--
-- = Description
--
-- This transform decomposition consists of three elements. The first is a
-- matrix S, consisting of a scale, shear, and translation, usually used to
-- define the pivot point of the following rotation. This matrix is
-- constructed from the parameters above by:
--
-- \[S =
-- \left(
--     \begin{matrix}
--         sx & a  & b  & pvx \\
--         0  & sy & c  & pvy \\
--         0  & 0  & sz & pvz
--     \end{matrix}
-- \right)\]
--
-- The rotation quaternion is defined as:
--
-- -   @R@ = [ @qx@, @qy@, @qz@, @qw@ ]
--
-- This is a rotation around a conceptual normalized axis [ ax, ay, az ] of
-- amount @theta@ such that:
--
-- -   [ @qx@, @qy@, @qz@ ] = sin(@theta@\/2) × [ @ax@, @ay@, @az@ ]
--
-- and
--
-- -   @qw@ = cos(@theta@\/2)
--
-- Finally, the transform has a translation T constructed from the
-- parameters above by:
--
-- \[T =
-- \left(
--     \begin{matrix}
--         1 & 0 & 0 & tx \\
--         0 & 1 & 0 & ty \\
--         0 & 0 & 1 & tz
--     \end{matrix}
-- \right)\]
--
-- The effective derived transform is then given by
--
-- -   @T@ × @R@ × @S@
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_ray_tracing_motion_blur VK_NV_ray_tracing_motion_blur>,
-- 'AccelerationStructureSRTMotionInstanceNV'
data SRTDataNV = SRTDataNV
  { -- | @sx@ is the x component of the scale of the transform
    SRTDataNV -> Float
sx :: Float
  , -- | @a@ is one component of the shear for the transform
    SRTDataNV -> Float
a :: Float
  , -- | @b@ is one component of the shear for the transform
    SRTDataNV -> Float
b :: Float
  , -- | @pvx@ is the x component of the pivot point of the transform
    SRTDataNV -> Float
pvx :: Float
  , -- | @sy@ is the y component of the scale of the transform
    SRTDataNV -> Float
sy :: Float
  , -- | @c@ is one component of the shear for the transform
    SRTDataNV -> Float
c :: Float
  , -- | @pvy@ is the y component of the pivot point of the transform
    SRTDataNV -> Float
pvy :: Float
  , -- | @sz@ is the z component of the scale of the transform
    SRTDataNV -> Float
sz :: Float
  , -- | @pvz@ is the z component of the pivot point of the transform
    SRTDataNV -> Float
pvz :: Float
  , -- | @qx@ is the x component of the rotation quaternion
    SRTDataNV -> Float
qx :: Float
  , -- | @qy@ is the y component of the rotation quaternion
    SRTDataNV -> Float
qy :: Float
  , -- | @qz@ is the z component of the rotation quaternion
    SRTDataNV -> Float
qz :: Float
  , -- | @qw@ is the w component of the rotation quaternion
    SRTDataNV -> Float
qw :: Float
  , -- | @tx@ is the x component of the post-rotation translation
    SRTDataNV -> Float
tx :: Float
  , -- | @ty@ is the y component of the post-rotation translation
    SRTDataNV -> Float
ty :: Float
  , -- | @tz@ is the z component of the post-rotation translation
    SRTDataNV -> Float
tz :: Float
  }
  deriving (Typeable, SRTDataNV -> SRTDataNV -> Bool
(SRTDataNV -> SRTDataNV -> Bool)
-> (SRTDataNV -> SRTDataNV -> Bool) -> Eq SRTDataNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SRTDataNV -> SRTDataNV -> Bool
$c/= :: SRTDataNV -> SRTDataNV -> Bool
== :: SRTDataNV -> SRTDataNV -> Bool
$c== :: SRTDataNV -> SRTDataNV -> Bool
Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (SRTDataNV)
#endif
deriving instance Show SRTDataNV

instance ToCStruct SRTDataNV where
  withCStruct :: SRTDataNV -> (Ptr SRTDataNV -> IO b) -> IO b
withCStruct SRTDataNV
x Ptr SRTDataNV -> IO b
f = Int -> (Ptr SRTDataNV -> IO b) -> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
64 ((Ptr SRTDataNV -> IO b) -> IO b)
-> (Ptr SRTDataNV -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr SRTDataNV
p -> Ptr SRTDataNV -> SRTDataNV -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr SRTDataNV
p SRTDataNV
x (Ptr SRTDataNV -> IO b
f Ptr SRTDataNV
p)
  pokeCStruct :: Ptr SRTDataNV -> SRTDataNV -> IO b -> IO b
pokeCStruct Ptr SRTDataNV
p SRTDataNV{Float
tz :: Float
ty :: Float
tx :: Float
qw :: Float
qz :: Float
qy :: Float
qx :: Float
pvz :: Float
sz :: Float
pvy :: Float
c :: Float
sy :: Float
pvx :: Float
b :: Float
a :: Float
sx :: Float
$sel:tz:SRTDataNV :: SRTDataNV -> Float
$sel:ty:SRTDataNV :: SRTDataNV -> Float
$sel:tx:SRTDataNV :: SRTDataNV -> Float
$sel:qw:SRTDataNV :: SRTDataNV -> Float
$sel:qz:SRTDataNV :: SRTDataNV -> Float
$sel:qy:SRTDataNV :: SRTDataNV -> Float
$sel:qx:SRTDataNV :: SRTDataNV -> Float
$sel:pvz:SRTDataNV :: SRTDataNV -> Float
$sel:sz:SRTDataNV :: SRTDataNV -> Float
$sel:pvy:SRTDataNV :: SRTDataNV -> Float
$sel:c:SRTDataNV :: SRTDataNV -> Float
$sel:sy:SRTDataNV :: SRTDataNV -> Float
$sel:pvx:SRTDataNV :: SRTDataNV -> Float
$sel:b:SRTDataNV :: SRTDataNV -> Float
$sel:a:SRTDataNV :: SRTDataNV -> Float
$sel:sx:SRTDataNV :: SRTDataNV -> Float
..} IO b
f = do
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
sx))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
a))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
b))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
pvx))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
sy))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
c))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
pvy))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
sz))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
pvz))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
qx))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
qy))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
qz))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
qw))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
52 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
tx))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
ty))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
tz))
    IO b
f
  cStructSize :: Int
cStructSize = Int
64
  cStructAlignment :: Int
cStructAlignment = Int
4
  pokeZeroCStruct :: Ptr SRTDataNV -> IO b -> IO b
pokeZeroCStruct Ptr SRTDataNV
p IO b
f = do
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
52 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60 :: Ptr CFloat)) (Float -> CFloat
CFloat (Float
forall a. Zero a => a
zero))
    IO b
f

instance FromCStruct SRTDataNV where
  peekCStruct :: Ptr SRTDataNV -> IO SRTDataNV
peekCStruct Ptr SRTDataNV
p = do
    CFloat
sx <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr CFloat))
    CFloat
a <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4 :: Ptr CFloat))
    CFloat
b <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr CFloat))
    CFloat
pvx <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12 :: Ptr CFloat))
    CFloat
sy <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr CFloat))
    CFloat
c <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr CFloat))
    CFloat
pvy <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr CFloat))
    CFloat
sz <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28 :: Ptr CFloat))
    CFloat
pvz <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32 :: Ptr CFloat))
    CFloat
qx <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36 :: Ptr CFloat))
    CFloat
qy <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40 :: Ptr CFloat))
    CFloat
qz <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44 :: Ptr CFloat))
    CFloat
qw <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48 :: Ptr CFloat))
    CFloat
tx <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
52 :: Ptr CFloat))
    CFloat
ty <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56 :: Ptr CFloat))
    CFloat
tz <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr SRTDataNV
p Ptr SRTDataNV -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60 :: Ptr CFloat))
    SRTDataNV -> IO SRTDataNV
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SRTDataNV -> IO SRTDataNV) -> SRTDataNV -> IO SRTDataNV
forall a b. (a -> b) -> a -> b
$ Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> SRTDataNV
SRTDataNV
             (CFloat -> Float
coerce @CFloat @Float CFloat
sx) (CFloat -> Float
coerce @CFloat @Float CFloat
a) (CFloat -> Float
coerce @CFloat @Float CFloat
b) (CFloat -> Float
coerce @CFloat @Float CFloat
pvx) (CFloat -> Float
coerce @CFloat @Float CFloat
sy) (CFloat -> Float
coerce @CFloat @Float CFloat
c) (CFloat -> Float
coerce @CFloat @Float CFloat
pvy) (CFloat -> Float
coerce @CFloat @Float CFloat
sz) (CFloat -> Float
coerce @CFloat @Float CFloat
pvz) (CFloat -> Float
coerce @CFloat @Float CFloat
qx) (CFloat -> Float
coerce @CFloat @Float CFloat
qy) (CFloat -> Float
coerce @CFloat @Float CFloat
qz) (CFloat -> Float
coerce @CFloat @Float CFloat
qw) (CFloat -> Float
coerce @CFloat @Float CFloat
tx) (CFloat -> Float
coerce @CFloat @Float CFloat
ty) (CFloat -> Float
coerce @CFloat @Float CFloat
tz)

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

instance Zero SRTDataNV where
  zero :: SRTDataNV
zero = Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> Float
-> SRTDataNV
SRTDataNV
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero
           Float
forall a. Zero a => a
zero


-- | VkAccelerationStructureSRTMotionInstanceNV - Structure specifying a
-- single acceleration structure SRT motion instance for building into an
-- acceleration structure geometry
--
-- = Description
--
-- The C language specification does not define the ordering of bit-fields,
-- but in practice, this struct produces the correct layout with existing
-- compilers. The intended bit pattern is for the following:
--
-- If a compiler produces code that diverges from that pattern,
-- applications /must/ employ another method to set values according to the
-- correct bit pattern.
--
-- The transform for a SRT motion instance at a point in time is derived
-- from component-wise linear interpolation of the two SRT transforms. That
-- is, for a @time@ in [0,1] the resulting transform is
--
-- -   @transformT0@ × (1 - @time@) + @transformT1@ × @time@
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_ray_tracing_motion_blur VK_NV_ray_tracing_motion_blur>,
-- 'AccelerationStructureMotionInstanceDataNV',
-- 'Vulkan.Extensions.VK_KHR_acceleration_structure.GeometryInstanceFlagsKHR',
-- 'SRTDataNV'
data AccelerationStructureSRTMotionInstanceNV = AccelerationStructureSRTMotionInstanceNV
  { -- | @transformT0@ is a 'SRTDataNV' structure describing a transformation to
    -- be applied to the acceleration structure at time 0.
    AccelerationStructureSRTMotionInstanceNV -> SRTDataNV
transformT0 :: SRTDataNV
  , -- | @transformT1@ is a 'SRTDataNV' structure describing a transformation to
    -- be applied to the acceleration structure at time 1.
    AccelerationStructureSRTMotionInstanceNV -> SRTDataNV
transformT1 :: SRTDataNV
  , -- | @instanceCustomIndex@ is a 24-bit user-specified index value accessible
    -- to ray shaders in the @InstanceCustomIndexKHR@ built-in.
    --
    -- @instanceCustomIndex@ and @mask@ occupy the same memory as if a single
    -- @uint32_t@ was specified in their place
    --
    -- -   @instanceCustomIndex@ occupies the 24 least significant bits of that
    --     memory
    --
    -- -   @mask@ occupies the 8 most significant bits of that memory
    AccelerationStructureSRTMotionInstanceNV -> Word32
instanceCustomIndex :: Word32
  , -- | @mask@ is an 8-bit visibility mask for the geometry. The instance /may/
    -- only be hit if @Cull Mask & instance.mask != 0@
    AccelerationStructureSRTMotionInstanceNV -> Word32
mask :: Word32
  , -- | @instanceShaderBindingTableRecordOffset@ is a 24-bit offset used in
    -- calculating the hit shader binding table index.
    --
    -- @instanceShaderBindingTableRecordOffset@ and @flags@ occupy the same
    -- memory as if a single @uint32_t@ was specified in their place
    --
    -- -   @instanceShaderBindingTableRecordOffset@ occupies the 24 least
    --     significant bits of that memory
    --
    -- -   @flags@ occupies the 8 most significant bits of that memory
    AccelerationStructureSRTMotionInstanceNV -> Word32
instanceShaderBindingTableRecordOffset :: Word32
  , -- | @flags@ is an 8-bit mask of
    -- 'Vulkan.Extensions.VK_KHR_acceleration_structure.GeometryInstanceFlagBitsKHR'
    -- values to apply to this instance.
    --
    -- #VUID-VkAccelerationStructureSRTMotionInstanceNV-flags-parameter#
    -- @flags@ /must/ be a valid combination of
    -- 'Vulkan.Extensions.VK_KHR_acceleration_structure.GeometryInstanceFlagBitsKHR'
    -- values
    AccelerationStructureSRTMotionInstanceNV
-> GeometryInstanceFlagsKHR
flags :: GeometryInstanceFlagsKHR
  , -- | @accelerationStructureReference@ is either:
    --
    -- -   a device address containing the value obtained from
    --     'Vulkan.Extensions.VK_KHR_acceleration_structure.getAccelerationStructureDeviceAddressKHR'
    --     or
    --     'Vulkan.Extensions.VK_NV_ray_tracing.getAccelerationStructureHandleNV'
    --     (used by device operations which reference acceleration structures)
    --     or,
    --
    -- -   a 'Vulkan.Extensions.Handles.AccelerationStructureKHR' object (used
    --     by host operations which reference acceleration structures).
    AccelerationStructureSRTMotionInstanceNV -> Word64
accelerationStructureReference :: Word64
  }
  deriving (Typeable)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (AccelerationStructureSRTMotionInstanceNV)
#endif
deriving instance Show AccelerationStructureSRTMotionInstanceNV

instance ToCStruct AccelerationStructureSRTMotionInstanceNV where
  withCStruct :: AccelerationStructureSRTMotionInstanceNV
-> (Ptr AccelerationStructureSRTMotionInstanceNV -> IO b) -> IO b
withCStruct AccelerationStructureSRTMotionInstanceNV
x Ptr AccelerationStructureSRTMotionInstanceNV -> IO b
f = Int
-> (Ptr AccelerationStructureSRTMotionInstanceNV -> IO b) -> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
144 ((Ptr AccelerationStructureSRTMotionInstanceNV -> IO b) -> IO b)
-> (Ptr AccelerationStructureSRTMotionInstanceNV -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr AccelerationStructureSRTMotionInstanceNV
p -> Ptr AccelerationStructureSRTMotionInstanceNV
-> AccelerationStructureSRTMotionInstanceNV -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr AccelerationStructureSRTMotionInstanceNV
p AccelerationStructureSRTMotionInstanceNV
x (Ptr AccelerationStructureSRTMotionInstanceNV -> IO b
f Ptr AccelerationStructureSRTMotionInstanceNV
p)
  pokeCStruct :: Ptr AccelerationStructureSRTMotionInstanceNV
-> AccelerationStructureSRTMotionInstanceNV -> IO b -> IO b
pokeCStruct Ptr AccelerationStructureSRTMotionInstanceNV
p AccelerationStructureSRTMotionInstanceNV{Word32
Word64
GeometryInstanceFlagsKHR
SRTDataNV
accelerationStructureReference :: Word64
flags :: GeometryInstanceFlagsKHR
instanceShaderBindingTableRecordOffset :: Word32
mask :: Word32
instanceCustomIndex :: Word32
transformT1 :: SRTDataNV
transformT0 :: SRTDataNV
$sel:accelerationStructureReference:AccelerationStructureSRTMotionInstanceNV :: AccelerationStructureSRTMotionInstanceNV -> Word64
$sel:flags:AccelerationStructureSRTMotionInstanceNV :: AccelerationStructureSRTMotionInstanceNV
-> GeometryInstanceFlagsKHR
$sel:instanceShaderBindingTableRecordOffset:AccelerationStructureSRTMotionInstanceNV :: AccelerationStructureSRTMotionInstanceNV -> Word32
$sel:mask:AccelerationStructureSRTMotionInstanceNV :: AccelerationStructureSRTMotionInstanceNV -> Word32
$sel:instanceCustomIndex:AccelerationStructureSRTMotionInstanceNV :: AccelerationStructureSRTMotionInstanceNV -> Word32
$sel:transformT1:AccelerationStructureSRTMotionInstanceNV :: AccelerationStructureSRTMotionInstanceNV -> SRTDataNV
$sel:transformT0:AccelerationStructureSRTMotionInstanceNV :: AccelerationStructureSRTMotionInstanceNV -> SRTDataNV
..} IO b
f = do
    Ptr SRTDataNV -> SRTDataNV -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV
-> Int -> Ptr SRTDataNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr SRTDataNV)) (SRTDataNV
transformT0)
    Ptr SRTDataNV -> SRTDataNV -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV
-> Int -> Ptr SRTDataNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64 :: Ptr SRTDataNV)) (SRTDataNV
transformT1)
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
128 :: Ptr Word32)) (((Word32 -> Word32
coerce @_ @Word32 (Word32
mask)) Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24) Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. (Word32
instanceCustomIndex))
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
132 :: Ptr Word32)) (((GeometryInstanceFlagsKHR -> Word32
coerce @_ @Word32 (GeometryInstanceFlagsKHR
flags)) Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24) Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. (Word32
instanceShaderBindingTableRecordOffset))
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136 :: Ptr Word64)) (Word64
accelerationStructureReference)
    IO b
f
  cStructSize :: Int
cStructSize = Int
144
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: Ptr AccelerationStructureSRTMotionInstanceNV -> IO b -> IO b
pokeZeroCStruct Ptr AccelerationStructureSRTMotionInstanceNV
p IO b
f = do
    Ptr SRTDataNV -> SRTDataNV -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV
-> Int -> Ptr SRTDataNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr SRTDataNV)) (SRTDataNV
forall a. Zero a => a
zero)
    Ptr SRTDataNV -> SRTDataNV -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV
-> Int -> Ptr SRTDataNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64 :: Ptr SRTDataNV)) (SRTDataNV
forall a. Zero a => a
zero)
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136 :: Ptr Word64)) (Word64
forall a. Zero a => a
zero)
    IO b
f

instance FromCStruct AccelerationStructureSRTMotionInstanceNV where
  peekCStruct :: Ptr AccelerationStructureSRTMotionInstanceNV
-> IO AccelerationStructureSRTMotionInstanceNV
peekCStruct Ptr AccelerationStructureSRTMotionInstanceNV
p = do
    SRTDataNV
transformT0 <- Ptr SRTDataNV -> IO SRTDataNV
forall a. FromCStruct a => Ptr a -> IO a
peekCStruct @SRTDataNV ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV
-> Int -> Ptr SRTDataNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr SRTDataNV))
    SRTDataNV
transformT1 <- Ptr SRTDataNV -> IO SRTDataNV
forall a. FromCStruct a => Ptr a -> IO a
peekCStruct @SRTDataNV ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV
-> Int -> Ptr SRTDataNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64 :: Ptr SRTDataNV))
    Word32
instanceCustomIndex <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek @Word32 ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
128 :: Ptr Word32))
    let instanceCustomIndex' :: Word32
instanceCustomIndex' = ((Word32
instanceCustomIndex Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32 -> Word32
coerce @Word32 Word32
0xffffff))
    Word32
mask <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek @Word32 ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
128 :: Ptr Word32))
    let mask' :: Word32
mask' = ((((Word32
mask Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
24)) Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32 -> Word32
coerce @Word32 Word32
0xff))
    Word32
instanceShaderBindingTableRecordOffset <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek @Word32 ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
132 :: Ptr Word32))
    let instanceShaderBindingTableRecordOffset' :: Word32
instanceShaderBindingTableRecordOffset' = ((Word32
instanceShaderBindingTableRecordOffset Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32 -> Word32
coerce @Word32 Word32
0xffffff))
    GeometryInstanceFlagsKHR
flags <- Ptr GeometryInstanceFlagsKHR -> IO GeometryInstanceFlagsKHR
forall a. Storable a => Ptr a -> IO a
peek @GeometryInstanceFlagsKHR ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV
-> Int -> Ptr GeometryInstanceFlagsKHR
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
132 :: Ptr GeometryInstanceFlagsKHR))
    let flags' :: GeometryInstanceFlagsKHR
flags' = ((((GeometryInstanceFlagsKHR
flags GeometryInstanceFlagsKHR -> Int -> GeometryInstanceFlagsKHR
forall a. Bits a => a -> Int -> a
`shiftR` Int
24)) GeometryInstanceFlagsKHR
-> GeometryInstanceFlagsKHR -> GeometryInstanceFlagsKHR
forall a. Bits a => a -> a -> a
.&. Word32 -> GeometryInstanceFlagsKHR
coerce @Word32 Word32
0xff))
    Word64
accelerationStructureReference <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek @Word64 ((Ptr AccelerationStructureSRTMotionInstanceNV
p Ptr AccelerationStructureSRTMotionInstanceNV -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136 :: Ptr Word64))
    AccelerationStructureSRTMotionInstanceNV
-> IO AccelerationStructureSRTMotionInstanceNV
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccelerationStructureSRTMotionInstanceNV
 -> IO AccelerationStructureSRTMotionInstanceNV)
-> AccelerationStructureSRTMotionInstanceNV
-> IO AccelerationStructureSRTMotionInstanceNV
forall a b. (a -> b) -> a -> b
$ SRTDataNV
-> SRTDataNV
-> Word32
-> Word32
-> Word32
-> GeometryInstanceFlagsKHR
-> Word64
-> AccelerationStructureSRTMotionInstanceNV
AccelerationStructureSRTMotionInstanceNV
             SRTDataNV
transformT0 SRTDataNV
transformT1 Word32
instanceCustomIndex' Word32
mask' Word32
instanceShaderBindingTableRecordOffset' GeometryInstanceFlagsKHR
flags' Word64
accelerationStructureReference

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

instance Zero AccelerationStructureSRTMotionInstanceNV where
  zero :: AccelerationStructureSRTMotionInstanceNV
zero = SRTDataNV
-> SRTDataNV
-> Word32
-> Word32
-> Word32
-> GeometryInstanceFlagsKHR
-> Word64
-> AccelerationStructureSRTMotionInstanceNV
AccelerationStructureSRTMotionInstanceNV
           SRTDataNV
forall a. Zero a => a
zero
           SRTDataNV
forall a. Zero a => a
zero
           Word32
forall a. Zero a => a
zero
           Word32
forall a. Zero a => a
zero
           Word32
forall a. Zero a => a
zero
           GeometryInstanceFlagsKHR
forall a. Zero a => a
zero
           Word64
forall a. Zero a => a
zero


-- | VkAccelerationStructureMatrixMotionInstanceNV - Structure specifying a
-- single acceleration structure matrix motion instance for building into
-- an acceleration structure geometry
--
-- = Description
--
-- The C language specification does not define the ordering of bit-fields,
-- but in practice, this struct produces the correct layout with existing
-- compilers. The intended bit pattern is for the following:
--
-- If a compiler produces code that diverges from that pattern,
-- applications /must/ employ another method to set values according to the
-- correct bit pattern.
--
-- The transform for a matrix motion instance at a point in time is derived
-- by component-wise linear interpolation of the two transforms. That is,
-- for a @time@ in [0,1] the resulting transform is
--
-- -   @transformT0@ × (1 - @time@) + @transformT1@ × @time@
--
-- == Valid Usage (Implicit)
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_ray_tracing_motion_blur VK_NV_ray_tracing_motion_blur>,
-- 'AccelerationStructureMotionInstanceDataNV',
-- 'Vulkan.Extensions.VK_KHR_acceleration_structure.GeometryInstanceFlagsKHR',
-- 'Vulkan.Extensions.VK_KHR_acceleration_structure.TransformMatrixKHR'
data AccelerationStructureMatrixMotionInstanceNV = AccelerationStructureMatrixMotionInstanceNV
  { -- | @transformT0@ is a
    -- 'Vulkan.Extensions.VK_KHR_acceleration_structure.TransformMatrixKHR'
    -- structure describing a transformation to be applied to the acceleration
    -- structure at time 0.
    AccelerationStructureMatrixMotionInstanceNV -> TransformMatrixKHR
transformT0 :: TransformMatrixKHR
  , -- | @transformT1@ is a
    -- 'Vulkan.Extensions.VK_KHR_acceleration_structure.TransformMatrixKHR'
    -- structure describing a transformation to be applied to the acceleration
    -- structure at time 1.
    AccelerationStructureMatrixMotionInstanceNV -> TransformMatrixKHR
transformT1 :: TransformMatrixKHR
  , -- | @instanceCustomIndex@ is a 24-bit user-specified index value accessible
    -- to ray shaders in the @InstanceCustomIndexKHR@ built-in.
    --
    -- @instanceCustomIndex@ and @mask@ occupy the same memory as if a single
    -- @uint32_t@ was specified in their place
    --
    -- -   @instanceCustomIndex@ occupies the 24 least significant bits of that
    --     memory
    --
    -- -   @mask@ occupies the 8 most significant bits of that memory
    AccelerationStructureMatrixMotionInstanceNV -> Word32
instanceCustomIndex :: Word32
  , -- | @mask@ is an 8-bit visibility mask for the geometry. The instance /may/
    -- only be hit if @Cull Mask & instance.mask != 0@
    AccelerationStructureMatrixMotionInstanceNV -> Word32
mask :: Word32
  , -- | @instanceShaderBindingTableRecordOffset@ is a 24-bit offset used in
    -- calculating the hit shader binding table index.
    --
    -- @instanceShaderBindingTableRecordOffset@ and @flags@ occupy the same
    -- memory as if a single @uint32_t@ was specified in their place
    --
    -- -   @instanceShaderBindingTableRecordOffset@ occupies the 24 least
    --     significant bits of that memory
    --
    -- -   @flags@ occupies the 8 most significant bits of that memory
    AccelerationStructureMatrixMotionInstanceNV -> Word32
instanceShaderBindingTableRecordOffset :: Word32
  , -- | @flags@ is an 8-bit mask of
    -- 'Vulkan.Extensions.VK_KHR_acceleration_structure.GeometryInstanceFlagBitsKHR'
    -- values to apply to this instance.
    --
    -- #VUID-VkAccelerationStructureMatrixMotionInstanceNV-flags-parameter#
    -- @flags@ /must/ be a valid combination of
    -- 'Vulkan.Extensions.VK_KHR_acceleration_structure.GeometryInstanceFlagBitsKHR'
    -- values
    AccelerationStructureMatrixMotionInstanceNV
-> GeometryInstanceFlagsKHR
flags :: GeometryInstanceFlagsKHR
  , -- | @accelerationStructureReference@ is either:
    --
    -- -   a device address containing the value obtained from
    --     'Vulkan.Extensions.VK_KHR_acceleration_structure.getAccelerationStructureDeviceAddressKHR'
    --     or
    --     'Vulkan.Extensions.VK_NV_ray_tracing.getAccelerationStructureHandleNV'
    --     (used by device operations which reference acceleration structures)
    --     or,
    --
    -- -   a 'Vulkan.Extensions.Handles.AccelerationStructureKHR' object (used
    --     by host operations which reference acceleration structures).
    AccelerationStructureMatrixMotionInstanceNV -> Word64
accelerationStructureReference :: Word64
  }
  deriving (Typeable)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (AccelerationStructureMatrixMotionInstanceNV)
#endif
deriving instance Show AccelerationStructureMatrixMotionInstanceNV

instance ToCStruct AccelerationStructureMatrixMotionInstanceNV where
  withCStruct :: AccelerationStructureMatrixMotionInstanceNV
-> (Ptr AccelerationStructureMatrixMotionInstanceNV -> IO b)
-> IO b
withCStruct AccelerationStructureMatrixMotionInstanceNV
x Ptr AccelerationStructureMatrixMotionInstanceNV -> IO b
f = Int
-> (Ptr AccelerationStructureMatrixMotionInstanceNV -> IO b)
-> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
112 ((Ptr AccelerationStructureMatrixMotionInstanceNV -> IO b) -> IO b)
-> (Ptr AccelerationStructureMatrixMotionInstanceNV -> IO b)
-> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr AccelerationStructureMatrixMotionInstanceNV
p -> Ptr AccelerationStructureMatrixMotionInstanceNV
-> AccelerationStructureMatrixMotionInstanceNV -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr AccelerationStructureMatrixMotionInstanceNV
p AccelerationStructureMatrixMotionInstanceNV
x (Ptr AccelerationStructureMatrixMotionInstanceNV -> IO b
f Ptr AccelerationStructureMatrixMotionInstanceNV
p)
  pokeCStruct :: Ptr AccelerationStructureMatrixMotionInstanceNV
-> AccelerationStructureMatrixMotionInstanceNV -> IO b -> IO b
pokeCStruct Ptr AccelerationStructureMatrixMotionInstanceNV
p AccelerationStructureMatrixMotionInstanceNV{Word32
Word64
GeometryInstanceFlagsKHR
TransformMatrixKHR
accelerationStructureReference :: Word64
flags :: GeometryInstanceFlagsKHR
instanceShaderBindingTableRecordOffset :: Word32
mask :: Word32
instanceCustomIndex :: Word32
transformT1 :: TransformMatrixKHR
transformT0 :: TransformMatrixKHR
$sel:accelerationStructureReference:AccelerationStructureMatrixMotionInstanceNV :: AccelerationStructureMatrixMotionInstanceNV -> Word64
$sel:flags:AccelerationStructureMatrixMotionInstanceNV :: AccelerationStructureMatrixMotionInstanceNV
-> GeometryInstanceFlagsKHR
$sel:instanceShaderBindingTableRecordOffset:AccelerationStructureMatrixMotionInstanceNV :: AccelerationStructureMatrixMotionInstanceNV -> Word32
$sel:mask:AccelerationStructureMatrixMotionInstanceNV :: AccelerationStructureMatrixMotionInstanceNV -> Word32
$sel:instanceCustomIndex:AccelerationStructureMatrixMotionInstanceNV :: AccelerationStructureMatrixMotionInstanceNV -> Word32
$sel:transformT1:AccelerationStructureMatrixMotionInstanceNV :: AccelerationStructureMatrixMotionInstanceNV -> TransformMatrixKHR
$sel:transformT0:AccelerationStructureMatrixMotionInstanceNV :: AccelerationStructureMatrixMotionInstanceNV -> TransformMatrixKHR
..} IO b
f = do
    Ptr TransformMatrixKHR -> TransformMatrixKHR -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr TransformMatrixKHR
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr TransformMatrixKHR)) (TransformMatrixKHR
transformT0)
    Ptr TransformMatrixKHR -> TransformMatrixKHR -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr TransformMatrixKHR
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48 :: Ptr TransformMatrixKHR)) (TransformMatrixKHR
transformT1)
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96 :: Ptr Word32)) (((Word32 -> Word32
coerce @_ @Word32 (Word32
mask)) Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24) Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. (Word32
instanceCustomIndex))
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
100 :: Ptr Word32)) (((GeometryInstanceFlagsKHR -> Word32
coerce @_ @Word32 (GeometryInstanceFlagsKHR
flags)) Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftL` Int
24) Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.|. (Word32
instanceShaderBindingTableRecordOffset))
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
104 :: Ptr Word64)) (Word64
accelerationStructureReference)
    IO b
f
  cStructSize :: Int
cStructSize = Int
112
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: Ptr AccelerationStructureMatrixMotionInstanceNV -> IO b -> IO b
pokeZeroCStruct Ptr AccelerationStructureMatrixMotionInstanceNV
p IO b
f = do
    Ptr TransformMatrixKHR -> TransformMatrixKHR -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr TransformMatrixKHR
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr TransformMatrixKHR)) (TransformMatrixKHR
forall a. Zero a => a
zero)
    Ptr TransformMatrixKHR -> TransformMatrixKHR -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr TransformMatrixKHR
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48 :: Ptr TransformMatrixKHR)) (TransformMatrixKHR
forall a. Zero a => a
zero)
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
104 :: Ptr Word64)) (Word64
forall a. Zero a => a
zero)
    IO b
f

instance FromCStruct AccelerationStructureMatrixMotionInstanceNV where
  peekCStruct :: Ptr AccelerationStructureMatrixMotionInstanceNV
-> IO AccelerationStructureMatrixMotionInstanceNV
peekCStruct Ptr AccelerationStructureMatrixMotionInstanceNV
p = do
    TransformMatrixKHR
transformT0 <- Ptr TransformMatrixKHR -> IO TransformMatrixKHR
forall a. FromCStruct a => Ptr a -> IO a
peekCStruct @TransformMatrixKHR ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr TransformMatrixKHR
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr TransformMatrixKHR))
    TransformMatrixKHR
transformT1 <- Ptr TransformMatrixKHR -> IO TransformMatrixKHR
forall a. FromCStruct a => Ptr a -> IO a
peekCStruct @TransformMatrixKHR ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr TransformMatrixKHR
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48 :: Ptr TransformMatrixKHR))
    Word32
instanceCustomIndex <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek @Word32 ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96 :: Ptr Word32))
    let instanceCustomIndex' :: Word32
instanceCustomIndex' = ((Word32
instanceCustomIndex Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32 -> Word32
coerce @Word32 Word32
0xffffff))
    Word32
mask <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek @Word32 ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96 :: Ptr Word32))
    let mask' :: Word32
mask' = ((((Word32
mask Word32 -> Int -> Word32
forall a. Bits a => a -> Int -> a
`shiftR` Int
24)) Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32 -> Word32
coerce @Word32 Word32
0xff))
    Word32
instanceShaderBindingTableRecordOffset <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek @Word32 ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
100 :: Ptr Word32))
    let instanceShaderBindingTableRecordOffset' :: Word32
instanceShaderBindingTableRecordOffset' = ((Word32
instanceShaderBindingTableRecordOffset Word32 -> Word32 -> Word32
forall a. Bits a => a -> a -> a
.&. Word32 -> Word32
coerce @Word32 Word32
0xffffff))
    GeometryInstanceFlagsKHR
flags <- Ptr GeometryInstanceFlagsKHR -> IO GeometryInstanceFlagsKHR
forall a. Storable a => Ptr a -> IO a
peek @GeometryInstanceFlagsKHR ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr GeometryInstanceFlagsKHR
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
100 :: Ptr GeometryInstanceFlagsKHR))
    let flags' :: GeometryInstanceFlagsKHR
flags' = ((((GeometryInstanceFlagsKHR
flags GeometryInstanceFlagsKHR -> Int -> GeometryInstanceFlagsKHR
forall a. Bits a => a -> Int -> a
`shiftR` Int
24)) GeometryInstanceFlagsKHR
-> GeometryInstanceFlagsKHR -> GeometryInstanceFlagsKHR
forall a. Bits a => a -> a -> a
.&. Word32 -> GeometryInstanceFlagsKHR
coerce @Word32 Word32
0xff))
    Word64
accelerationStructureReference <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek @Word64 ((Ptr AccelerationStructureMatrixMotionInstanceNV
p Ptr AccelerationStructureMatrixMotionInstanceNV
-> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
104 :: Ptr Word64))
    AccelerationStructureMatrixMotionInstanceNV
-> IO AccelerationStructureMatrixMotionInstanceNV
forall (f :: * -> *) a. Applicative f => a -> f a
pure (AccelerationStructureMatrixMotionInstanceNV
 -> IO AccelerationStructureMatrixMotionInstanceNV)
-> AccelerationStructureMatrixMotionInstanceNV
-> IO AccelerationStructureMatrixMotionInstanceNV
forall a b. (a -> b) -> a -> b
$ TransformMatrixKHR
-> TransformMatrixKHR
-> Word32
-> Word32
-> Word32
-> GeometryInstanceFlagsKHR
-> Word64
-> AccelerationStructureMatrixMotionInstanceNV
AccelerationStructureMatrixMotionInstanceNV
             TransformMatrixKHR
transformT0 TransformMatrixKHR
transformT1 Word32
instanceCustomIndex' Word32
mask' Word32
instanceShaderBindingTableRecordOffset' GeometryInstanceFlagsKHR
flags' Word64
accelerationStructureReference

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

instance Zero AccelerationStructureMatrixMotionInstanceNV where
  zero :: AccelerationStructureMatrixMotionInstanceNV
zero = TransformMatrixKHR
-> TransformMatrixKHR
-> Word32
-> Word32
-> Word32
-> GeometryInstanceFlagsKHR
-> Word64
-> AccelerationStructureMatrixMotionInstanceNV
AccelerationStructureMatrixMotionInstanceNV
           TransformMatrixKHR
forall a. Zero a => a
zero
           TransformMatrixKHR
forall a. Zero a => a
zero
           Word32
forall a. Zero a => a
zero
           Word32
forall a. Zero a => a
zero
           Word32
forall a. Zero a => a
zero
           GeometryInstanceFlagsKHR
forall a. Zero a => a
zero
           Word64
forall a. Zero a => a
zero


-- | VkAccelerationStructureMotionInstanceNV - Structure specifying a single
-- acceleration structure motion instance for building into an acceleration
-- structure geometry
--
-- = Description
--
-- Note
--
-- If writing this other than with a standard C compiler, note that the
-- final structure should be 152 bytes in size.
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-VkAccelerationStructureMotionInstanceNV-type-parameter# @type@
--     /must/ be a valid 'AccelerationStructureMotionInstanceTypeNV' value
--
-- -   #VUID-VkAccelerationStructureMotionInstanceNV-flags-zerobitmask#
--     @flags@ /must/ be @0@
--
-- -   #VUID-VkAccelerationStructureMotionInstanceNV-staticInstance-parameter#
--     If @type@ is
--     'ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV', the
--     @staticInstance@ member of @data@ /must/ be a valid
--     'Vulkan.Extensions.VK_KHR_acceleration_structure.AccelerationStructureInstanceKHR'
--     structure
--
-- -   #VUID-VkAccelerationStructureMotionInstanceNV-matrixMotionInstance-parameter#
--     If @type@ is
--     'ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV', the
--     @matrixMotionInstance@ member of @data@ /must/ be a valid
--     'AccelerationStructureMatrixMotionInstanceNV' structure
--
-- -   #VUID-VkAccelerationStructureMotionInstanceNV-srtMotionInstance-parameter#
--     If @type@ is
--     'ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV', the
--     @srtMotionInstance@ member of @data@ /must/ be a valid
--     'AccelerationStructureSRTMotionInstanceNV' structure
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_ray_tracing_motion_blur VK_NV_ray_tracing_motion_blur>,
-- 'AccelerationStructureMotionInstanceDataNV',
-- 'AccelerationStructureMotionInstanceFlagsNV',
-- 'AccelerationStructureMotionInstanceTypeNV'
data AccelerationStructureMotionInstanceNV = AccelerationStructureMotionInstanceNV
  { -- | @type@ is a 'AccelerationStructureMotionInstanceTypeNV' enumerant
    -- identifying which type of motion instance this is and which type of the
    -- union is valid.
    AccelerationStructureMotionInstanceNV
-> AccelerationStructureMotionInstanceTypeNV
type' :: AccelerationStructureMotionInstanceTypeNV
  , -- | @flags@ is currently unused, but is required to keep natural alignment
    -- of @data@.
    AccelerationStructureMotionInstanceNV
-> AccelerationStructureMotionInstanceFlagsNV
flags :: AccelerationStructureMotionInstanceFlagsNV
  , -- | @data@ is a 'AccelerationStructureMotionInstanceDataNV' containing
    -- motion instance data for this instance.
    AccelerationStructureMotionInstanceNV
-> AccelerationStructureMotionInstanceDataNV
data' :: AccelerationStructureMotionInstanceDataNV
  }
  deriving (Typeable)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (AccelerationStructureMotionInstanceNV)
#endif
deriving instance Show AccelerationStructureMotionInstanceNV

instance ToCStruct AccelerationStructureMotionInstanceNV where
  withCStruct :: AccelerationStructureMotionInstanceNV
-> (Ptr AccelerationStructureMotionInstanceNV -> IO b) -> IO b
withCStruct AccelerationStructureMotionInstanceNV
x Ptr AccelerationStructureMotionInstanceNV -> IO b
f = Int -> (Ptr AccelerationStructureMotionInstanceNV -> IO b) -> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
152 ((Ptr AccelerationStructureMotionInstanceNV -> IO b) -> IO b)
-> (Ptr AccelerationStructureMotionInstanceNV -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr AccelerationStructureMotionInstanceNV
p -> Ptr AccelerationStructureMotionInstanceNV
-> AccelerationStructureMotionInstanceNV -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr AccelerationStructureMotionInstanceNV
p AccelerationStructureMotionInstanceNV
x (Ptr AccelerationStructureMotionInstanceNV -> IO b
f Ptr AccelerationStructureMotionInstanceNV
p)
  pokeCStruct :: Ptr AccelerationStructureMotionInstanceNV
-> AccelerationStructureMotionInstanceNV -> IO b -> IO b
pokeCStruct Ptr AccelerationStructureMotionInstanceNV
p AccelerationStructureMotionInstanceNV{AccelerationStructureMotionInstanceTypeNV
AccelerationStructureMotionInstanceFlagsNV
AccelerationStructureMotionInstanceDataNV
data' :: AccelerationStructureMotionInstanceDataNV
flags :: AccelerationStructureMotionInstanceFlagsNV
type' :: AccelerationStructureMotionInstanceTypeNV
$sel:data':AccelerationStructureMotionInstanceNV :: AccelerationStructureMotionInstanceNV
-> AccelerationStructureMotionInstanceDataNV
$sel:flags:AccelerationStructureMotionInstanceNV :: AccelerationStructureMotionInstanceNV
-> AccelerationStructureMotionInstanceFlagsNV
$sel:type':AccelerationStructureMotionInstanceNV :: AccelerationStructureMotionInstanceNV
-> AccelerationStructureMotionInstanceTypeNV
..} IO b
f = ContT b IO b -> IO b
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT b IO b -> IO b) -> ContT b IO b -> IO b
forall a b. (a -> b) -> a -> b
$ do
    IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMotionInstanceNV
p Ptr AccelerationStructureMotionInstanceNV
-> Int -> Ptr AccelerationStructureMotionInstanceTypeNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr AccelerationStructureMotionInstanceTypeNV)) (AccelerationStructureMotionInstanceTypeNV
type')
    IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMotionInstanceNV
p Ptr AccelerationStructureMotionInstanceNV
-> Int -> Ptr AccelerationStructureMotionInstanceFlagsNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4 :: Ptr AccelerationStructureMotionInstanceFlagsNV)) (AccelerationStructureMotionInstanceFlagsNV
flags)
    ((() -> IO b) -> IO b) -> ContT b IO ()
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((() -> IO b) -> IO b) -> ContT b IO ())
-> ((() -> IO b) -> IO b) -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr AccelerationStructureMotionInstanceDataNV
-> AccelerationStructureMotionInstanceDataNV -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct ((Ptr AccelerationStructureMotionInstanceNV
p Ptr AccelerationStructureMotionInstanceNV
-> Int -> Ptr AccelerationStructureMotionInstanceDataNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr AccelerationStructureMotionInstanceDataNV)) (AccelerationStructureMotionInstanceDataNV
data') (IO b -> IO b) -> ((() -> IO b) -> IO b) -> (() -> IO b) -> IO b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((() -> IO b) -> () -> IO b
forall a b. (a -> b) -> a -> b
$ ())
    IO b -> ContT b IO b
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO b -> ContT b IO b) -> IO b -> ContT b IO b
forall a b. (a -> b) -> a -> b
$ IO b
f
  cStructSize :: Int
cStructSize = Int
152
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: Ptr AccelerationStructureMotionInstanceNV -> IO b -> IO b
pokeZeroCStruct Ptr AccelerationStructureMotionInstanceNV
p IO b
f = ContT b IO b -> IO b
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT b IO b -> IO b) -> ContT b IO b -> IO b
forall a b. (a -> b) -> a -> b
$ do
    IO () -> ContT b IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT b IO ()) -> IO () -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr AccelerationStructureMotionInstanceNV
p Ptr AccelerationStructureMotionInstanceNV
-> Int -> Ptr AccelerationStructureMotionInstanceTypeNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr AccelerationStructureMotionInstanceTypeNV)) (AccelerationStructureMotionInstanceTypeNV
forall a. Zero a => a
zero)
    ((() -> IO b) -> IO b) -> ContT b IO ()
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((() -> IO b) -> IO b) -> ContT b IO ())
-> ((() -> IO b) -> IO b) -> ContT b IO ()
forall a b. (a -> b) -> a -> b
$ Ptr AccelerationStructureMotionInstanceDataNV
-> AccelerationStructureMotionInstanceDataNV -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct ((Ptr AccelerationStructureMotionInstanceNV
p Ptr AccelerationStructureMotionInstanceNV
-> Int -> Ptr AccelerationStructureMotionInstanceDataNV
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr AccelerationStructureMotionInstanceDataNV)) (AccelerationStructureMotionInstanceDataNV
forall a. Zero a => a
zero) (IO b -> IO b) -> ((() -> IO b) -> IO b) -> (() -> IO b) -> IO b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((() -> IO b) -> () -> IO b
forall a b. (a -> b) -> a -> b
$ ())
    IO b -> ContT b IO b
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO b -> ContT b IO b) -> IO b -> ContT b IO b
forall a b. (a -> b) -> a -> b
$ IO b
f

instance Zero AccelerationStructureMotionInstanceNV where
  zero :: AccelerationStructureMotionInstanceNV
zero = AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceDataNV
-> AccelerationStructureMotionInstanceNV
AccelerationStructureMotionInstanceNV
           AccelerationStructureMotionInstanceTypeNV
forall a. Zero a => a
zero
           AccelerationStructureMotionInstanceFlagsNV
forall a. Zero a => a
zero
           AccelerationStructureMotionInstanceDataNV
forall a. Zero a => a
zero


data AccelerationStructureMotionInstanceDataNV
  = StaticInstance AccelerationStructureInstanceKHR
  | MatrixMotionInstance AccelerationStructureMatrixMotionInstanceNV
  | SrtMotionInstance AccelerationStructureSRTMotionInstanceNV
  deriving (Int -> AccelerationStructureMotionInstanceDataNV -> ShowS
[AccelerationStructureMotionInstanceDataNV] -> ShowS
AccelerationStructureMotionInstanceDataNV -> String
(Int -> AccelerationStructureMotionInstanceDataNV -> ShowS)
-> (AccelerationStructureMotionInstanceDataNV -> String)
-> ([AccelerationStructureMotionInstanceDataNV] -> ShowS)
-> Show AccelerationStructureMotionInstanceDataNV
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccelerationStructureMotionInstanceDataNV] -> ShowS
$cshowList :: [AccelerationStructureMotionInstanceDataNV] -> ShowS
show :: AccelerationStructureMotionInstanceDataNV -> String
$cshow :: AccelerationStructureMotionInstanceDataNV -> String
showsPrec :: Int -> AccelerationStructureMotionInstanceDataNV -> ShowS
$cshowsPrec :: Int -> AccelerationStructureMotionInstanceDataNV -> ShowS
Show)

instance ToCStruct AccelerationStructureMotionInstanceDataNV where
  withCStruct :: AccelerationStructureMotionInstanceDataNV
-> (Ptr AccelerationStructureMotionInstanceDataNV -> IO b) -> IO b
withCStruct AccelerationStructureMotionInstanceDataNV
x Ptr AccelerationStructureMotionInstanceDataNV -> IO b
f = Int
-> (Ptr AccelerationStructureMotionInstanceDataNV -> IO b) -> IO b
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
144 ((Ptr AccelerationStructureMotionInstanceDataNV -> IO b) -> IO b)
-> (Ptr AccelerationStructureMotionInstanceDataNV -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr AccelerationStructureMotionInstanceDataNV
p -> Ptr AccelerationStructureMotionInstanceDataNV
-> AccelerationStructureMotionInstanceDataNV -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr AccelerationStructureMotionInstanceDataNV
p AccelerationStructureMotionInstanceDataNV
x (Ptr AccelerationStructureMotionInstanceDataNV -> IO b
f Ptr AccelerationStructureMotionInstanceDataNV
p)
  pokeCStruct :: Ptr AccelerationStructureMotionInstanceDataNV -> AccelerationStructureMotionInstanceDataNV -> IO a -> IO a
  pokeCStruct :: Ptr AccelerationStructureMotionInstanceDataNV
-> AccelerationStructureMotionInstanceDataNV -> IO a -> IO a
pokeCStruct Ptr AccelerationStructureMotionInstanceDataNV
p = (((() -> IO a) -> IO a) -> (IO a -> () -> IO a) -> IO a -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> () -> IO a
forall a b. a -> b -> a
const) (((() -> IO a) -> IO a) -> IO a -> IO a)
-> (AccelerationStructureMotionInstanceDataNV
    -> (() -> IO a) -> IO a)
-> AccelerationStructureMotionInstanceDataNV
-> IO a
-> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContT a IO () -> (() -> IO a) -> IO a
forall k (r :: k) (m :: k -> *) a. ContT r m a -> (a -> m r) -> m r
runContT (ContT a IO () -> (() -> IO a) -> IO a)
-> (AccelerationStructureMotionInstanceDataNV -> ContT a IO ())
-> AccelerationStructureMotionInstanceDataNV
-> (() -> IO a)
-> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  \case
    StaticInstance AccelerationStructureInstanceKHR
v -> IO () -> ContT a IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT a IO ()) -> IO () -> ContT a IO ()
forall a b. (a -> b) -> a -> b
$ Ptr AccelerationStructureInstanceKHR
-> AccelerationStructureInstanceKHR -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AccelerationStructureMotionInstanceDataNV
-> Ptr AccelerationStructureInstanceKHR
forall a b. Ptr a -> Ptr b
castPtr @_ @AccelerationStructureInstanceKHR Ptr AccelerationStructureMotionInstanceDataNV
p) (AccelerationStructureInstanceKHR
v)
    MatrixMotionInstance AccelerationStructureMatrixMotionInstanceNV
v -> IO () -> ContT a IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT a IO ()) -> IO () -> ContT a IO ()
forall a b. (a -> b) -> a -> b
$ Ptr AccelerationStructureMatrixMotionInstanceNV
-> AccelerationStructureMatrixMotionInstanceNV -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AccelerationStructureMotionInstanceDataNV
-> Ptr AccelerationStructureMatrixMotionInstanceNV
forall a b. Ptr a -> Ptr b
castPtr @_ @AccelerationStructureMatrixMotionInstanceNV Ptr AccelerationStructureMotionInstanceDataNV
p) (AccelerationStructureMatrixMotionInstanceNV
v)
    SrtMotionInstance AccelerationStructureSRTMotionInstanceNV
v -> IO () -> ContT a IO ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> ContT a IO ()) -> IO () -> ContT a IO ()
forall a b. (a -> b) -> a -> b
$ Ptr AccelerationStructureSRTMotionInstanceNV
-> AccelerationStructureSRTMotionInstanceNV -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AccelerationStructureMotionInstanceDataNV
-> Ptr AccelerationStructureSRTMotionInstanceNV
forall a b. Ptr a -> Ptr b
castPtr @_ @AccelerationStructureSRTMotionInstanceNV Ptr AccelerationStructureMotionInstanceDataNV
p) (AccelerationStructureSRTMotionInstanceNV
v)
  pokeZeroCStruct :: Ptr AccelerationStructureMotionInstanceDataNV -> IO b -> IO b
  pokeZeroCStruct :: Ptr AccelerationStructureMotionInstanceDataNV -> IO b -> IO b
pokeZeroCStruct Ptr AccelerationStructureMotionInstanceDataNV
_ IO b
f = IO b
f
  cStructSize :: Int
cStructSize = Int
144
  cStructAlignment :: Int
cStructAlignment = Int
8

instance Zero AccelerationStructureMotionInstanceDataNV where
  zero :: AccelerationStructureMotionInstanceDataNV
zero = AccelerationStructureSRTMotionInstanceNV
-> AccelerationStructureMotionInstanceDataNV
SrtMotionInstance AccelerationStructureSRTMotionInstanceNV
forall a. Zero a => a
zero


-- | VkAccelerationStructureMotionInfoFlagsNV - Reserved for future use
--
-- = Description
--
-- 'AccelerationStructureMotionInfoFlagsNV' is a bitmask type for setting a
-- mask, but is currently reserved for future use.
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_ray_tracing_motion_blur VK_NV_ray_tracing_motion_blur>,
-- 'AccelerationStructureMotionInfoNV'
newtype AccelerationStructureMotionInfoFlagsNV = AccelerationStructureMotionInfoFlagsNV Flags
  deriving newtype (AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
(AccelerationStructureMotionInfoFlagsNV
 -> AccelerationStructureMotionInfoFlagsNV -> Bool)
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV -> Bool)
-> Eq AccelerationStructureMotionInfoFlagsNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
$c/= :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
== :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
$c== :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
Eq, Eq AccelerationStructureMotionInfoFlagsNV
Eq AccelerationStructureMotionInfoFlagsNV
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV -> Ordering)
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV -> Bool)
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV -> Bool)
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV -> Bool)
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV -> Bool)
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV)
-> Ord AccelerationStructureMotionInfoFlagsNV
AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Ordering
AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
$cmin :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
max :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
$cmax :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
>= :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
$c>= :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
> :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
$c> :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
<= :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
$c<= :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
< :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
$c< :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Bool
compare :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Ordering
$ccompare :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> Ordering
$cp1Ord :: Eq AccelerationStructureMotionInfoFlagsNV
Ord, Ptr b -> Int -> IO AccelerationStructureMotionInfoFlagsNV
Ptr b -> Int -> AccelerationStructureMotionInfoFlagsNV -> IO ()
Ptr AccelerationStructureMotionInfoFlagsNV
-> IO AccelerationStructureMotionInfoFlagsNV
Ptr AccelerationStructureMotionInfoFlagsNV
-> Int -> IO AccelerationStructureMotionInfoFlagsNV
Ptr AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV -> IO ()
Ptr AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> IO ()
AccelerationStructureMotionInfoFlagsNV -> Int
(AccelerationStructureMotionInfoFlagsNV -> Int)
-> (AccelerationStructureMotionInfoFlagsNV -> Int)
-> (Ptr AccelerationStructureMotionInfoFlagsNV
    -> Int -> IO AccelerationStructureMotionInfoFlagsNV)
-> (Ptr AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV -> IO ())
-> (forall b.
    Ptr b -> Int -> IO AccelerationStructureMotionInfoFlagsNV)
-> (forall b.
    Ptr b -> Int -> AccelerationStructureMotionInfoFlagsNV -> IO ())
-> (Ptr AccelerationStructureMotionInfoFlagsNV
    -> IO AccelerationStructureMotionInfoFlagsNV)
-> (Ptr AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV -> IO ())
-> Storable AccelerationStructureMotionInfoFlagsNV
forall b. Ptr b -> Int -> IO AccelerationStructureMotionInfoFlagsNV
forall b.
Ptr b -> Int -> AccelerationStructureMotionInfoFlagsNV -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> IO ()
$cpoke :: Ptr AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV -> IO ()
peek :: Ptr AccelerationStructureMotionInfoFlagsNV
-> IO AccelerationStructureMotionInfoFlagsNV
$cpeek :: Ptr AccelerationStructureMotionInfoFlagsNV
-> IO AccelerationStructureMotionInfoFlagsNV
pokeByteOff :: Ptr b -> Int -> AccelerationStructureMotionInfoFlagsNV -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> AccelerationStructureMotionInfoFlagsNV -> IO ()
peekByteOff :: Ptr b -> Int -> IO AccelerationStructureMotionInfoFlagsNV
$cpeekByteOff :: forall b. Ptr b -> Int -> IO AccelerationStructureMotionInfoFlagsNV
pokeElemOff :: Ptr AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV -> IO ()
$cpokeElemOff :: Ptr AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV -> IO ()
peekElemOff :: Ptr AccelerationStructureMotionInfoFlagsNV
-> Int -> IO AccelerationStructureMotionInfoFlagsNV
$cpeekElemOff :: Ptr AccelerationStructureMotionInfoFlagsNV
-> Int -> IO AccelerationStructureMotionInfoFlagsNV
alignment :: AccelerationStructureMotionInfoFlagsNV -> Int
$calignment :: AccelerationStructureMotionInfoFlagsNV -> Int
sizeOf :: AccelerationStructureMotionInfoFlagsNV -> Int
$csizeOf :: AccelerationStructureMotionInfoFlagsNV -> Int
Storable, AccelerationStructureMotionInfoFlagsNV
AccelerationStructureMotionInfoFlagsNV
-> Zero AccelerationStructureMotionInfoFlagsNV
forall a. a -> Zero a
zero :: AccelerationStructureMotionInfoFlagsNV
$czero :: AccelerationStructureMotionInfoFlagsNV
Zero, Eq AccelerationStructureMotionInfoFlagsNV
AccelerationStructureMotionInfoFlagsNV
Eq AccelerationStructureMotionInfoFlagsNV
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> AccelerationStructureMotionInfoFlagsNV
-> (Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV -> Int -> Bool)
-> (AccelerationStructureMotionInfoFlagsNV -> Maybe Int)
-> (AccelerationStructureMotionInfoFlagsNV -> Int)
-> (AccelerationStructureMotionInfoFlagsNV -> Bool)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV
    -> Int -> AccelerationStructureMotionInfoFlagsNV)
-> (AccelerationStructureMotionInfoFlagsNV -> Int)
-> Bits AccelerationStructureMotionInfoFlagsNV
Int -> AccelerationStructureMotionInfoFlagsNV
AccelerationStructureMotionInfoFlagsNV -> Bool
AccelerationStructureMotionInfoFlagsNV -> Int
AccelerationStructureMotionInfoFlagsNV -> Maybe Int
AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
AccelerationStructureMotionInfoFlagsNV -> Int -> Bool
AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: AccelerationStructureMotionInfoFlagsNV -> Int
$cpopCount :: AccelerationStructureMotionInfoFlagsNV -> Int
rotateR :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$crotateR :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
rotateL :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$crotateL :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
unsafeShiftR :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$cunsafeShiftR :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
shiftR :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$cshiftR :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
unsafeShiftL :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$cunsafeShiftL :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
shiftL :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$cshiftL :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
isSigned :: AccelerationStructureMotionInfoFlagsNV -> Bool
$cisSigned :: AccelerationStructureMotionInfoFlagsNV -> Bool
bitSize :: AccelerationStructureMotionInfoFlagsNV -> Int
$cbitSize :: AccelerationStructureMotionInfoFlagsNV -> Int
bitSizeMaybe :: AccelerationStructureMotionInfoFlagsNV -> Maybe Int
$cbitSizeMaybe :: AccelerationStructureMotionInfoFlagsNV -> Maybe Int
testBit :: AccelerationStructureMotionInfoFlagsNV -> Int -> Bool
$ctestBit :: AccelerationStructureMotionInfoFlagsNV -> Int -> Bool
complementBit :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$ccomplementBit :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
clearBit :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$cclearBit :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
setBit :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$csetBit :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
bit :: Int -> AccelerationStructureMotionInfoFlagsNV
$cbit :: Int -> AccelerationStructureMotionInfoFlagsNV
zeroBits :: AccelerationStructureMotionInfoFlagsNV
$czeroBits :: AccelerationStructureMotionInfoFlagsNV
rotate :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$crotate :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
shift :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
$cshift :: AccelerationStructureMotionInfoFlagsNV
-> Int -> AccelerationStructureMotionInfoFlagsNV
complement :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
$ccomplement :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
xor :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
$cxor :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
.|. :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
$c.|. :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
.&. :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
$c.&. :: AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
-> AccelerationStructureMotionInfoFlagsNV
$cp1Bits :: Eq AccelerationStructureMotionInfoFlagsNV
Bits, Bits AccelerationStructureMotionInfoFlagsNV
Bits AccelerationStructureMotionInfoFlagsNV
-> (AccelerationStructureMotionInfoFlagsNV -> Int)
-> (AccelerationStructureMotionInfoFlagsNV -> Int)
-> (AccelerationStructureMotionInfoFlagsNV -> Int)
-> FiniteBits AccelerationStructureMotionInfoFlagsNV
AccelerationStructureMotionInfoFlagsNV -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: AccelerationStructureMotionInfoFlagsNV -> Int
$ccountTrailingZeros :: AccelerationStructureMotionInfoFlagsNV -> Int
countLeadingZeros :: AccelerationStructureMotionInfoFlagsNV -> Int
$ccountLeadingZeros :: AccelerationStructureMotionInfoFlagsNV -> Int
finiteBitSize :: AccelerationStructureMotionInfoFlagsNV -> Int
$cfiniteBitSize :: AccelerationStructureMotionInfoFlagsNV -> Int
$cp1FiniteBits :: Bits AccelerationStructureMotionInfoFlagsNV
FiniteBits)



conNameAccelerationStructureMotionInfoFlagsNV :: String
conNameAccelerationStructureMotionInfoFlagsNV :: String
conNameAccelerationStructureMotionInfoFlagsNV = String
"AccelerationStructureMotionInfoFlagsNV"

enumPrefixAccelerationStructureMotionInfoFlagsNV :: String
enumPrefixAccelerationStructureMotionInfoFlagsNV :: String
enumPrefixAccelerationStructureMotionInfoFlagsNV = String
""

showTableAccelerationStructureMotionInfoFlagsNV :: [(AccelerationStructureMotionInfoFlagsNV, String)]
showTableAccelerationStructureMotionInfoFlagsNV :: [(AccelerationStructureMotionInfoFlagsNV, String)]
showTableAccelerationStructureMotionInfoFlagsNV = []

instance Show AccelerationStructureMotionInfoFlagsNV where
  showsPrec :: Int -> AccelerationStructureMotionInfoFlagsNV -> ShowS
showsPrec = String
-> [(AccelerationStructureMotionInfoFlagsNV, String)]
-> String
-> (AccelerationStructureMotionInfoFlagsNV -> Word32)
-> (Word32 -> ShowS)
-> Int
-> AccelerationStructureMotionInfoFlagsNV
-> ShowS
forall a i.
Eq a =>
String
-> [(a, String)]
-> String
-> (a -> i)
-> (i -> ShowS)
-> Int
-> a
-> ShowS
enumShowsPrec String
enumPrefixAccelerationStructureMotionInfoFlagsNV
                            [(AccelerationStructureMotionInfoFlagsNV, String)]
showTableAccelerationStructureMotionInfoFlagsNV
                            String
conNameAccelerationStructureMotionInfoFlagsNV
                            (\(AccelerationStructureMotionInfoFlagsNV Word32
x) -> Word32
x)
                            (\Word32
x -> String -> ShowS
showString String
"0x" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> ShowS
forall a. (Integral a, Show a) => a -> ShowS
showHex Word32
x)

instance Read AccelerationStructureMotionInfoFlagsNV where
  readPrec :: ReadPrec AccelerationStructureMotionInfoFlagsNV
readPrec = String
-> [(AccelerationStructureMotionInfoFlagsNV, String)]
-> String
-> (Word32 -> AccelerationStructureMotionInfoFlagsNV)
-> ReadPrec AccelerationStructureMotionInfoFlagsNV
forall i a.
Read i =>
String -> [(a, String)] -> String -> (i -> a) -> ReadPrec a
enumReadPrec String
enumPrefixAccelerationStructureMotionInfoFlagsNV
                          [(AccelerationStructureMotionInfoFlagsNV, String)]
showTableAccelerationStructureMotionInfoFlagsNV
                          String
conNameAccelerationStructureMotionInfoFlagsNV
                          Word32 -> AccelerationStructureMotionInfoFlagsNV
AccelerationStructureMotionInfoFlagsNV


-- | VkAccelerationStructureMotionInstanceFlagsNV - Reserved for future use
--
-- = Description
--
-- 'AccelerationStructureMotionInstanceFlagsNV' is a bitmask type for
-- setting a mask, but is currently reserved for future use.
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_ray_tracing_motion_blur VK_NV_ray_tracing_motion_blur>,
-- 'AccelerationStructureMotionInstanceNV'
newtype AccelerationStructureMotionInstanceFlagsNV = AccelerationStructureMotionInstanceFlagsNV Flags
  deriving newtype (AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
(AccelerationStructureMotionInstanceFlagsNV
 -> AccelerationStructureMotionInstanceFlagsNV -> Bool)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV -> Bool)
-> Eq AccelerationStructureMotionInstanceFlagsNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
$c/= :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
== :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
$c== :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
Eq, Eq AccelerationStructureMotionInstanceFlagsNV
Eq AccelerationStructureMotionInstanceFlagsNV
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV -> Ordering)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV -> Bool)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV -> Bool)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV -> Bool)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV -> Bool)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV)
-> Ord AccelerationStructureMotionInstanceFlagsNV
AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Ordering
AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
$cmin :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
max :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
$cmax :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
>= :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
$c>= :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
> :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
$c> :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
<= :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
$c<= :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
< :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
$c< :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Bool
compare :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Ordering
$ccompare :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> Ordering
$cp1Ord :: Eq AccelerationStructureMotionInstanceFlagsNV
Ord, Ptr b -> Int -> IO AccelerationStructureMotionInstanceFlagsNV
Ptr b -> Int -> AccelerationStructureMotionInstanceFlagsNV -> IO ()
Ptr AccelerationStructureMotionInstanceFlagsNV
-> IO AccelerationStructureMotionInstanceFlagsNV
Ptr AccelerationStructureMotionInstanceFlagsNV
-> Int -> IO AccelerationStructureMotionInstanceFlagsNV
Ptr AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV -> IO ()
Ptr AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> IO ()
AccelerationStructureMotionInstanceFlagsNV -> Int
(AccelerationStructureMotionInstanceFlagsNV -> Int)
-> (AccelerationStructureMotionInstanceFlagsNV -> Int)
-> (Ptr AccelerationStructureMotionInstanceFlagsNV
    -> Int -> IO AccelerationStructureMotionInstanceFlagsNV)
-> (Ptr AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV -> IO ())
-> (forall b.
    Ptr b -> Int -> IO AccelerationStructureMotionInstanceFlagsNV)
-> (forall b.
    Ptr b
    -> Int -> AccelerationStructureMotionInstanceFlagsNV -> IO ())
-> (Ptr AccelerationStructureMotionInstanceFlagsNV
    -> IO AccelerationStructureMotionInstanceFlagsNV)
-> (Ptr AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV -> IO ())
-> Storable AccelerationStructureMotionInstanceFlagsNV
forall b.
Ptr b -> Int -> IO AccelerationStructureMotionInstanceFlagsNV
forall b.
Ptr b -> Int -> AccelerationStructureMotionInstanceFlagsNV -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> IO ()
$cpoke :: Ptr AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV -> IO ()
peek :: Ptr AccelerationStructureMotionInstanceFlagsNV
-> IO AccelerationStructureMotionInstanceFlagsNV
$cpeek :: Ptr AccelerationStructureMotionInstanceFlagsNV
-> IO AccelerationStructureMotionInstanceFlagsNV
pokeByteOff :: Ptr b -> Int -> AccelerationStructureMotionInstanceFlagsNV -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> AccelerationStructureMotionInstanceFlagsNV -> IO ()
peekByteOff :: Ptr b -> Int -> IO AccelerationStructureMotionInstanceFlagsNV
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO AccelerationStructureMotionInstanceFlagsNV
pokeElemOff :: Ptr AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV -> IO ()
$cpokeElemOff :: Ptr AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV -> IO ()
peekElemOff :: Ptr AccelerationStructureMotionInstanceFlagsNV
-> Int -> IO AccelerationStructureMotionInstanceFlagsNV
$cpeekElemOff :: Ptr AccelerationStructureMotionInstanceFlagsNV
-> Int -> IO AccelerationStructureMotionInstanceFlagsNV
alignment :: AccelerationStructureMotionInstanceFlagsNV -> Int
$calignment :: AccelerationStructureMotionInstanceFlagsNV -> Int
sizeOf :: AccelerationStructureMotionInstanceFlagsNV -> Int
$csizeOf :: AccelerationStructureMotionInstanceFlagsNV -> Int
Storable, AccelerationStructureMotionInstanceFlagsNV
AccelerationStructureMotionInstanceFlagsNV
-> Zero AccelerationStructureMotionInstanceFlagsNV
forall a. a -> Zero a
zero :: AccelerationStructureMotionInstanceFlagsNV
$czero :: AccelerationStructureMotionInstanceFlagsNV
Zero, Eq AccelerationStructureMotionInstanceFlagsNV
AccelerationStructureMotionInstanceFlagsNV
Eq AccelerationStructureMotionInstanceFlagsNV
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> AccelerationStructureMotionInstanceFlagsNV
-> (Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV -> Int -> Bool)
-> (AccelerationStructureMotionInstanceFlagsNV -> Maybe Int)
-> (AccelerationStructureMotionInstanceFlagsNV -> Int)
-> (AccelerationStructureMotionInstanceFlagsNV -> Bool)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV
    -> Int -> AccelerationStructureMotionInstanceFlagsNV)
-> (AccelerationStructureMotionInstanceFlagsNV -> Int)
-> Bits AccelerationStructureMotionInstanceFlagsNV
Int -> AccelerationStructureMotionInstanceFlagsNV
AccelerationStructureMotionInstanceFlagsNV -> Bool
AccelerationStructureMotionInstanceFlagsNV -> Int
AccelerationStructureMotionInstanceFlagsNV -> Maybe Int
AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
AccelerationStructureMotionInstanceFlagsNV -> Int -> Bool
AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: AccelerationStructureMotionInstanceFlagsNV -> Int
$cpopCount :: AccelerationStructureMotionInstanceFlagsNV -> Int
rotateR :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$crotateR :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
rotateL :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$crotateL :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
unsafeShiftR :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$cunsafeShiftR :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
shiftR :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$cshiftR :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
unsafeShiftL :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$cunsafeShiftL :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
shiftL :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$cshiftL :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
isSigned :: AccelerationStructureMotionInstanceFlagsNV -> Bool
$cisSigned :: AccelerationStructureMotionInstanceFlagsNV -> Bool
bitSize :: AccelerationStructureMotionInstanceFlagsNV -> Int
$cbitSize :: AccelerationStructureMotionInstanceFlagsNV -> Int
bitSizeMaybe :: AccelerationStructureMotionInstanceFlagsNV -> Maybe Int
$cbitSizeMaybe :: AccelerationStructureMotionInstanceFlagsNV -> Maybe Int
testBit :: AccelerationStructureMotionInstanceFlagsNV -> Int -> Bool
$ctestBit :: AccelerationStructureMotionInstanceFlagsNV -> Int -> Bool
complementBit :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$ccomplementBit :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
clearBit :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$cclearBit :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
setBit :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$csetBit :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
bit :: Int -> AccelerationStructureMotionInstanceFlagsNV
$cbit :: Int -> AccelerationStructureMotionInstanceFlagsNV
zeroBits :: AccelerationStructureMotionInstanceFlagsNV
$czeroBits :: AccelerationStructureMotionInstanceFlagsNV
rotate :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$crotate :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
shift :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
$cshift :: AccelerationStructureMotionInstanceFlagsNV
-> Int -> AccelerationStructureMotionInstanceFlagsNV
complement :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
$ccomplement :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
xor :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
$cxor :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
.|. :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
$c.|. :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
.&. :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
$c.&. :: AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
-> AccelerationStructureMotionInstanceFlagsNV
$cp1Bits :: Eq AccelerationStructureMotionInstanceFlagsNV
Bits, Bits AccelerationStructureMotionInstanceFlagsNV
Bits AccelerationStructureMotionInstanceFlagsNV
-> (AccelerationStructureMotionInstanceFlagsNV -> Int)
-> (AccelerationStructureMotionInstanceFlagsNV -> Int)
-> (AccelerationStructureMotionInstanceFlagsNV -> Int)
-> FiniteBits AccelerationStructureMotionInstanceFlagsNV
AccelerationStructureMotionInstanceFlagsNV -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: AccelerationStructureMotionInstanceFlagsNV -> Int
$ccountTrailingZeros :: AccelerationStructureMotionInstanceFlagsNV -> Int
countLeadingZeros :: AccelerationStructureMotionInstanceFlagsNV -> Int
$ccountLeadingZeros :: AccelerationStructureMotionInstanceFlagsNV -> Int
finiteBitSize :: AccelerationStructureMotionInstanceFlagsNV -> Int
$cfiniteBitSize :: AccelerationStructureMotionInstanceFlagsNV -> Int
$cp1FiniteBits :: Bits AccelerationStructureMotionInstanceFlagsNV
FiniteBits)



conNameAccelerationStructureMotionInstanceFlagsNV :: String
conNameAccelerationStructureMotionInstanceFlagsNV :: String
conNameAccelerationStructureMotionInstanceFlagsNV = String
"AccelerationStructureMotionInstanceFlagsNV"

enumPrefixAccelerationStructureMotionInstanceFlagsNV :: String
enumPrefixAccelerationStructureMotionInstanceFlagsNV :: String
enumPrefixAccelerationStructureMotionInstanceFlagsNV = String
""

showTableAccelerationStructureMotionInstanceFlagsNV :: [(AccelerationStructureMotionInstanceFlagsNV, String)]
showTableAccelerationStructureMotionInstanceFlagsNV :: [(AccelerationStructureMotionInstanceFlagsNV, String)]
showTableAccelerationStructureMotionInstanceFlagsNV = []

instance Show AccelerationStructureMotionInstanceFlagsNV where
  showsPrec :: Int -> AccelerationStructureMotionInstanceFlagsNV -> ShowS
showsPrec = String
-> [(AccelerationStructureMotionInstanceFlagsNV, String)]
-> String
-> (AccelerationStructureMotionInstanceFlagsNV -> Word32)
-> (Word32 -> ShowS)
-> Int
-> AccelerationStructureMotionInstanceFlagsNV
-> ShowS
forall a i.
Eq a =>
String
-> [(a, String)]
-> String
-> (a -> i)
-> (i -> ShowS)
-> Int
-> a
-> ShowS
enumShowsPrec String
enumPrefixAccelerationStructureMotionInstanceFlagsNV
                            [(AccelerationStructureMotionInstanceFlagsNV, String)]
showTableAccelerationStructureMotionInstanceFlagsNV
                            String
conNameAccelerationStructureMotionInstanceFlagsNV
                            (\(AccelerationStructureMotionInstanceFlagsNV Word32
x) -> Word32
x)
                            (\Word32
x -> String -> ShowS
showString String
"0x" ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> ShowS
forall a. (Integral a, Show a) => a -> ShowS
showHex Word32
x)

instance Read AccelerationStructureMotionInstanceFlagsNV where
  readPrec :: ReadPrec AccelerationStructureMotionInstanceFlagsNV
readPrec = String
-> [(AccelerationStructureMotionInstanceFlagsNV, String)]
-> String
-> (Word32 -> AccelerationStructureMotionInstanceFlagsNV)
-> ReadPrec AccelerationStructureMotionInstanceFlagsNV
forall i a.
Read i =>
String -> [(a, String)] -> String -> (i -> a) -> ReadPrec a
enumReadPrec String
enumPrefixAccelerationStructureMotionInstanceFlagsNV
                          [(AccelerationStructureMotionInstanceFlagsNV, String)]
showTableAccelerationStructureMotionInstanceFlagsNV
                          String
conNameAccelerationStructureMotionInstanceFlagsNV
                          Word32 -> AccelerationStructureMotionInstanceFlagsNV
AccelerationStructureMotionInstanceFlagsNV


-- | VkAccelerationStructureMotionInstanceTypeNV - Enum specifying a type of
-- acceleration structure motion instance data for building into an
-- acceleration structure geometry
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_ray_tracing_motion_blur VK_NV_ray_tracing_motion_blur>,
-- 'AccelerationStructureMotionInstanceNV'
newtype AccelerationStructureMotionInstanceTypeNV = AccelerationStructureMotionInstanceTypeNV Int32
  deriving newtype (AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
(AccelerationStructureMotionInstanceTypeNV
 -> AccelerationStructureMotionInstanceTypeNV -> Bool)
-> (AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV -> Bool)
-> Eq AccelerationStructureMotionInstanceTypeNV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
$c/= :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
== :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
$c== :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
Eq, Eq AccelerationStructureMotionInstanceTypeNV
Eq AccelerationStructureMotionInstanceTypeNV
-> (AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV -> Ordering)
-> (AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV -> Bool)
-> (AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV -> Bool)
-> (AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV -> Bool)
-> (AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV -> Bool)
-> (AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV)
-> (AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV)
-> Ord AccelerationStructureMotionInstanceTypeNV
AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Ordering
AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV
$cmin :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV
max :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV
$cmax :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV
>= :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
$c>= :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
> :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
$c> :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
<= :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
$c<= :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
< :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
$c< :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Bool
compare :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Ordering
$ccompare :: AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> Ordering
$cp1Ord :: Eq AccelerationStructureMotionInstanceTypeNV
Ord, Ptr b -> Int -> IO AccelerationStructureMotionInstanceTypeNV
Ptr b -> Int -> AccelerationStructureMotionInstanceTypeNV -> IO ()
Ptr AccelerationStructureMotionInstanceTypeNV
-> IO AccelerationStructureMotionInstanceTypeNV
Ptr AccelerationStructureMotionInstanceTypeNV
-> Int -> IO AccelerationStructureMotionInstanceTypeNV
Ptr AccelerationStructureMotionInstanceTypeNV
-> Int -> AccelerationStructureMotionInstanceTypeNV -> IO ()
Ptr AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> IO ()
AccelerationStructureMotionInstanceTypeNV -> Int
(AccelerationStructureMotionInstanceTypeNV -> Int)
-> (AccelerationStructureMotionInstanceTypeNV -> Int)
-> (Ptr AccelerationStructureMotionInstanceTypeNV
    -> Int -> IO AccelerationStructureMotionInstanceTypeNV)
-> (Ptr AccelerationStructureMotionInstanceTypeNV
    -> Int -> AccelerationStructureMotionInstanceTypeNV -> IO ())
-> (forall b.
    Ptr b -> Int -> IO AccelerationStructureMotionInstanceTypeNV)
-> (forall b.
    Ptr b -> Int -> AccelerationStructureMotionInstanceTypeNV -> IO ())
-> (Ptr AccelerationStructureMotionInstanceTypeNV
    -> IO AccelerationStructureMotionInstanceTypeNV)
-> (Ptr AccelerationStructureMotionInstanceTypeNV
    -> AccelerationStructureMotionInstanceTypeNV -> IO ())
-> Storable AccelerationStructureMotionInstanceTypeNV
forall b.
Ptr b -> Int -> IO AccelerationStructureMotionInstanceTypeNV
forall b.
Ptr b -> Int -> AccelerationStructureMotionInstanceTypeNV -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> IO ()
$cpoke :: Ptr AccelerationStructureMotionInstanceTypeNV
-> AccelerationStructureMotionInstanceTypeNV -> IO ()
peek :: Ptr AccelerationStructureMotionInstanceTypeNV
-> IO AccelerationStructureMotionInstanceTypeNV
$cpeek :: Ptr AccelerationStructureMotionInstanceTypeNV
-> IO AccelerationStructureMotionInstanceTypeNV
pokeByteOff :: Ptr b -> Int -> AccelerationStructureMotionInstanceTypeNV -> IO ()
$cpokeByteOff :: forall b.
Ptr b -> Int -> AccelerationStructureMotionInstanceTypeNV -> IO ()
peekByteOff :: Ptr b -> Int -> IO AccelerationStructureMotionInstanceTypeNV
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO AccelerationStructureMotionInstanceTypeNV
pokeElemOff :: Ptr AccelerationStructureMotionInstanceTypeNV
-> Int -> AccelerationStructureMotionInstanceTypeNV -> IO ()
$cpokeElemOff :: Ptr AccelerationStructureMotionInstanceTypeNV
-> Int -> AccelerationStructureMotionInstanceTypeNV -> IO ()
peekElemOff :: Ptr AccelerationStructureMotionInstanceTypeNV
-> Int -> IO AccelerationStructureMotionInstanceTypeNV
$cpeekElemOff :: Ptr AccelerationStructureMotionInstanceTypeNV
-> Int -> IO AccelerationStructureMotionInstanceTypeNV
alignment :: AccelerationStructureMotionInstanceTypeNV -> Int
$calignment :: AccelerationStructureMotionInstanceTypeNV -> Int
sizeOf :: AccelerationStructureMotionInstanceTypeNV -> Int
$csizeOf :: AccelerationStructureMotionInstanceTypeNV -> Int
Storable, AccelerationStructureMotionInstanceTypeNV
AccelerationStructureMotionInstanceTypeNV
-> Zero AccelerationStructureMotionInstanceTypeNV
forall a. a -> Zero a
zero :: AccelerationStructureMotionInstanceTypeNV
$czero :: AccelerationStructureMotionInstanceTypeNV
Zero)

-- | 'ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV' specifies that
-- the instance is a static instance with no instance motion.
pattern $bACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV :: AccelerationStructureMotionInstanceTypeNV
$mACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV :: forall r.
AccelerationStructureMotionInstanceTypeNV
-> (Void# -> r) -> (Void# -> r) -> r
ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV        = AccelerationStructureMotionInstanceTypeNV 0
-- | 'ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV' specifies
-- that the instance is a motion instance with motion specified by
-- interpolation between two matrices.
pattern $bACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV :: AccelerationStructureMotionInstanceTypeNV
$mACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV :: forall r.
AccelerationStructureMotionInstanceTypeNV
-> (Void# -> r) -> (Void# -> r) -> r
ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = AccelerationStructureMotionInstanceTypeNV 1
-- | 'ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV' specifies
-- that the instance is a motion instance with motion specified by
-- interpolation in the SRT decomposition.
pattern $bACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV :: AccelerationStructureMotionInstanceTypeNV
$mACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV :: forall r.
AccelerationStructureMotionInstanceTypeNV
-> (Void# -> r) -> (Void# -> r) -> r
ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV    = AccelerationStructureMotionInstanceTypeNV 2
{-# complete ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV,
             ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV,
             ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV :: AccelerationStructureMotionInstanceTypeNV #-}

conNameAccelerationStructureMotionInstanceTypeNV :: String
conNameAccelerationStructureMotionInstanceTypeNV :: String
conNameAccelerationStructureMotionInstanceTypeNV = String
"AccelerationStructureMotionInstanceTypeNV"

enumPrefixAccelerationStructureMotionInstanceTypeNV :: String
enumPrefixAccelerationStructureMotionInstanceTypeNV :: String
enumPrefixAccelerationStructureMotionInstanceTypeNV = String
"ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_"

showTableAccelerationStructureMotionInstanceTypeNV :: [(AccelerationStructureMotionInstanceTypeNV, String)]
showTableAccelerationStructureMotionInstanceTypeNV :: [(AccelerationStructureMotionInstanceTypeNV, String)]
showTableAccelerationStructureMotionInstanceTypeNV =
  [ (AccelerationStructureMotionInstanceTypeNV
ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV       , String
"STATIC_NV")
  , (AccelerationStructureMotionInstanceTypeNV
ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV, String
"MATRIX_MOTION_NV")
  , (AccelerationStructureMotionInstanceTypeNV
ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV   , String
"SRT_MOTION_NV")
  ]

instance Show AccelerationStructureMotionInstanceTypeNV where
  showsPrec :: Int -> AccelerationStructureMotionInstanceTypeNV -> ShowS
showsPrec = String
-> [(AccelerationStructureMotionInstanceTypeNV, String)]
-> String
-> (AccelerationStructureMotionInstanceTypeNV -> Int32)
-> (Int32 -> ShowS)
-> Int
-> AccelerationStructureMotionInstanceTypeNV
-> ShowS
forall a i.
Eq a =>
String
-> [(a, String)]
-> String
-> (a -> i)
-> (i -> ShowS)
-> Int
-> a
-> ShowS
enumShowsPrec String
enumPrefixAccelerationStructureMotionInstanceTypeNV
                            [(AccelerationStructureMotionInstanceTypeNV, String)]
showTableAccelerationStructureMotionInstanceTypeNV
                            String
conNameAccelerationStructureMotionInstanceTypeNV
                            (\(AccelerationStructureMotionInstanceTypeNV Int32
x) -> Int32
x)
                            (Int -> Int32 -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11)

instance Read AccelerationStructureMotionInstanceTypeNV where
  readPrec :: ReadPrec AccelerationStructureMotionInstanceTypeNV
readPrec = String
-> [(AccelerationStructureMotionInstanceTypeNV, String)]
-> String
-> (Int32 -> AccelerationStructureMotionInstanceTypeNV)
-> ReadPrec AccelerationStructureMotionInstanceTypeNV
forall i a.
Read i =>
String -> [(a, String)] -> String -> (i -> a) -> ReadPrec a
enumReadPrec String
enumPrefixAccelerationStructureMotionInstanceTypeNV
                          [(AccelerationStructureMotionInstanceTypeNV, String)]
showTableAccelerationStructureMotionInstanceTypeNV
                          String
conNameAccelerationStructureMotionInstanceTypeNV
                          Int32 -> AccelerationStructureMotionInstanceTypeNV
AccelerationStructureMotionInstanceTypeNV


type NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION = 1

-- No documentation found for TopLevel "VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION"
pattern NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION :: forall a . Integral a => a
pattern $bNV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION :: a
$mNV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION :: forall r a. Integral a => a -> (Void# -> r) -> (Void# -> r) -> r
NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION = 1


type NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME = "VK_NV_ray_tracing_motion_blur"

-- No documentation found for TopLevel "VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME"
pattern NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME :: forall a . (Eq a, IsString a) => a
pattern $bNV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME :: a
$mNV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME :: forall r a.
(Eq a, IsString a) =>
a -> (Void# -> r) -> (Void# -> r) -> r
NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME = "VK_NV_ray_tracing_motion_blur"