{-# language CPP #-}
-- | = Name
--
-- VK_NV_framebuffer_mixed_samples - device extension
--
-- == VK_NV_framebuffer_mixed_samples
--
-- [__Name String__]
--     @VK_NV_framebuffer_mixed_samples@
--
-- [__Extension Type__]
--     Device extension
--
-- [__Registered Extension Number__]
--     153
--
-- [__Revision__]
--     1
--
-- [__Ratification Status__]
--     Not ratified
--
-- [__Extension and Version Dependencies__; __Contact__]
--
--     -   Jeff Bolz
--         <https://github.com/KhronosGroup/Vulkan-Docs/issues/new?body=[VK_NV_framebuffer_mixed_samples] @jeffbolznv%0A*Here describe the issue or question you have about the VK_NV_framebuffer_mixed_samples extension* >
--
-- == Other Extension Metadata
--
-- [__Last Modified Date__]
--     2017-06-04
--
-- [__Contributors__]
--
--     -   Jeff Bolz, NVIDIA
--
-- == Description
--
-- This extension allows multisample rendering with a raster and
-- depth\/stencil sample count that is larger than the color sample count.
-- Rasterization and the results of the depth and stencil tests together
-- determine the portion of a pixel that is “covered”. It can be useful to
-- evaluate coverage at a higher frequency than color samples are stored.
-- This coverage is then “reduced” to a collection of covered color
-- samples, each having an opacity value corresponding to the fraction of
-- the color sample covered. The opacity can optionally be blended into
-- individual color samples.
--
-- Rendering with fewer color samples than depth\/stencil samples greatly
-- reduces the amount of memory and bandwidth consumed by the color buffer.
-- However, converting the coverage values into opacity introduces
-- artifacts where triangles share edges and /may/ not be suitable for
-- normal triangle mesh rendering.
--
-- One expected use case for this functionality is Stencil-then-Cover path
-- rendering (similar to the OpenGL GL_NV_path_rendering extension). The
-- stencil step determines the coverage (in the stencil buffer) for an
-- entire path at the higher sample frequency, and then the cover step
-- draws the path into the lower frequency color buffer using the coverage
-- information to antialias path edges. With this two-step process,
-- internal edges are fully covered when antialiasing is applied and there
-- is no corruption on these edges.
--
-- The key features of this extension are:
--
-- -   It allows render pass and framebuffer objects to be created where
--     the number of samples in the depth\/stencil attachment in a subpass
--     is a multiple of the number of samples in the color attachments in
--     the subpass.
--
-- -   A coverage reduction step is added to Fragment Operations which
--     converts a set of covered raster\/depth\/stencil samples to a set of
--     color samples that perform blending and color writes. The coverage
--     reduction step also includes an optional coverage modulation step,
--     multiplying color values by a fractional opacity corresponding to
--     the number of associated raster\/depth\/stencil samples covered.
--
-- == New Structures
--
-- -   Extending
--     'Vulkan.Core10.Pipeline.PipelineMultisampleStateCreateInfo':
--
--     -   'PipelineCoverageModulationStateCreateInfoNV'
--
-- == New Enums
--
-- -   'CoverageModulationModeNV'
--
-- == New Bitmasks
--
-- -   'PipelineCoverageModulationStateCreateFlagsNV'
--
-- == New Enum Constants
--
-- -   'NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME'
--
-- -   'NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION'
--
-- -   Extending 'Vulkan.Core10.Enums.StructureType.StructureType':
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV'
--
-- == Version History
--
-- -   Revision 1, 2017-06-04 (Jeff Bolz)
--
--     -   Internal revisions
--
-- == See Also
--
-- 'CoverageModulationModeNV',
-- 'PipelineCoverageModulationStateCreateFlagsNV',
-- 'PipelineCoverageModulationStateCreateInfoNV'
--
-- == Document Notes
--
-- For more information, see the
-- <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VK_NV_framebuffer_mixed_samples 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_framebuffer_mixed_samples  ( PipelineCoverageModulationStateCreateInfoNV(..)
                                                          , PipelineCoverageModulationStateCreateFlagsNV(..)
                                                          , CoverageModulationModeNV( COVERAGE_MODULATION_MODE_NONE_NV
                                                                                    , COVERAGE_MODULATION_MODE_RGB_NV
                                                                                    , COVERAGE_MODULATION_MODE_ALPHA_NV
                                                                                    , COVERAGE_MODULATION_MODE_RGBA_NV
                                                                                    , ..
                                                                                    )
                                                          , NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION
                                                          , pattern NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION
                                                          , NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME
                                                          , pattern NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME
                                                          ) where

import Data.Bits (Bits)
import Data.Bits (FiniteBits)
import Vulkan.Internal.Utils (enumReadPrec)
import Vulkan.Internal.Utils (enumShowsPrec)
import Control.Monad (unless)
import Foreign.Marshal.Alloc (allocaBytes)
import GHC.IO (throwIO)
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 Data.Vector (generateM)
import qualified Data.Vector (imapM_)
import qualified Data.Vector (length)
import qualified Data.Vector (null)
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.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 GHC.Generics (Generic)
import GHC.IO.Exception (IOErrorType(..))
import GHC.IO.Exception (IOException(..))
import Data.Int (Int32)
import Foreign.Ptr (Ptr)
import GHC.Read (Read(readPrec))
import GHC.Show (Show(showsPrec))
import Data.Word (Word32)
import Data.Kind (Type)
import Control.Monad.Trans.Cont (ContT(..))
import Data.Vector (Vector)
import Vulkan.CStruct.Utils (advancePtrBytes)
import Vulkan.Core10.FundamentalTypes (bool32ToBool)
import Vulkan.Core10.FundamentalTypes (boolToBool32)
import Vulkan.Core10.FundamentalTypes (Bool32)
import Vulkan.Core10.FundamentalTypes (Flags)
import Vulkan.Core10.Enums.StructureType (StructureType)
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV))
-- | VkPipelineCoverageModulationStateCreateInfoNV - Structure specifying
-- parameters controlling coverage modulation
--
-- = Description
--
-- If @coverageModulationTableEnable@ is
-- 'Vulkan.Core10.FundamentalTypes.FALSE', then for each color sample the
-- associated bits of the pixel coverage are counted and divided by the
-- number of associated bits to produce a modulation factor R in the range
-- (0,1] (a value of zero would have been killed due to a color coverage of
-- 0). Specifically:
--
-- -   N = value of @rasterizationSamples@
--
-- -   M = value of 'Vulkan.Core10.Pass.AttachmentDescription'::@samples@
--     for any color attachments
--
-- -   R = popcount(associated coverage bits) \/ (N \/ M)
--
-- If @coverageModulationTableEnable@ is
-- 'Vulkan.Core10.FundamentalTypes.TRUE', the value R is computed using a
-- programmable lookup table. The lookup table has N \/ M elements, and the
-- element of the table is selected by:
--
-- -   R = @pCoverageModulationTable@[popcount(associated coverage bits)-1]
--
-- Note that the table does not have an entry for popcount(associated
-- coverage bits) = 0, because such samples would have been killed.
--
-- The values of @pCoverageModulationTable@ /may/ be rounded to an
-- implementation-dependent precision, which is at least as fine as 1 \/ N,
-- and clamped to [0,1].
--
-- For each color attachment with a floating point or normalized color
-- format, each fragment output color value is replicated to M values which
-- /can/ each be modulated (multiplied) by that color sample’s associated
-- value of R. Which components are modulated is controlled by
-- @coverageModulationMode@.
--
-- If this structure is not included in the @pNext@ chain, it is as if
-- @coverageModulationMode@ is 'COVERAGE_MODULATION_MODE_NONE_NV'.
--
-- If the
-- <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#fragops-coverage-reduction coverage reduction mode>
-- is
-- 'Vulkan.Extensions.VK_NV_coverage_reduction_mode.COVERAGE_REDUCTION_MODE_TRUNCATE_NV',
-- each color sample is associated with only a single coverage sample. In
-- this case, it is as if @coverageModulationMode@ is
-- 'COVERAGE_MODULATION_MODE_NONE_NV'.
--
-- == Valid Usage
--
-- -   #VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405#
--     If @coverageModulationTableEnable@ is
--     'Vulkan.Core10.FundamentalTypes.TRUE',
--     @coverageModulationTableCount@ /must/ be equal to the number of
--     rasterization samples divided by the number of color samples in the
--     subpass
--
-- == Valid Usage (Implicit)
--
-- -   #VUID-VkPipelineCoverageModulationStateCreateInfoNV-sType-sType#
--     @sType@ /must/ be
--     'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV'
--
-- -   #VUID-VkPipelineCoverageModulationStateCreateInfoNV-flags-zerobitmask#
--     @flags@ /must/ be @0@
--
-- -   #VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationMode-parameter#
--     @coverageModulationMode@ /must/ be a valid
--     'CoverageModulationModeNV' value
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_framebuffer_mixed_samples VK_NV_framebuffer_mixed_samples>,
-- 'Vulkan.Core10.FundamentalTypes.Bool32', 'CoverageModulationModeNV',
-- 'PipelineCoverageModulationStateCreateFlagsNV',
-- 'Vulkan.Core10.Enums.StructureType.StructureType'
data PipelineCoverageModulationStateCreateInfoNV = PipelineCoverageModulationStateCreateInfoNV
  { -- | @flags@ is reserved for future use.
    PipelineCoverageModulationStateCreateInfoNV
-> PipelineCoverageModulationStateCreateFlagsNV
flags :: PipelineCoverageModulationStateCreateFlagsNV
  , -- | @coverageModulationMode@ is a 'CoverageModulationModeNV' value
    -- controlling which color components are modulated.
    PipelineCoverageModulationStateCreateInfoNV
-> CoverageModulationModeNV
coverageModulationMode :: CoverageModulationModeNV
  , -- | @coverageModulationTableEnable@ controls whether the modulation factor
    -- is looked up from a table in @pCoverageModulationTable@.
    PipelineCoverageModulationStateCreateInfoNV -> Bool
coverageModulationTableEnable :: Bool
  , -- | @coverageModulationTableCount@ is the number of elements in
    -- @pCoverageModulationTable@.
    PipelineCoverageModulationStateCreateInfoNV -> Word32
coverageModulationTableCount :: Word32
  , -- | @pCoverageModulationTable@ is a table of modulation factors containing a
    -- value for each number of covered samples.
    PipelineCoverageModulationStateCreateInfoNV -> Vector Float
coverageModulationTable :: Vector Float
  }
  deriving (Typeable)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (PipelineCoverageModulationStateCreateInfoNV)
#endif
deriving instance Show PipelineCoverageModulationStateCreateInfoNV

instance ToCStruct PipelineCoverageModulationStateCreateInfoNV where
  withCStruct :: forall b.
PipelineCoverageModulationStateCreateInfoNV
-> (Ptr PipelineCoverageModulationStateCreateInfoNV -> IO b)
-> IO b
withCStruct PipelineCoverageModulationStateCreateInfoNV
x Ptr PipelineCoverageModulationStateCreateInfoNV -> IO b
f = forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
40 forall a b. (a -> b) -> a -> b
$ \Ptr PipelineCoverageModulationStateCreateInfoNV
p -> forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr PipelineCoverageModulationStateCreateInfoNV
p PipelineCoverageModulationStateCreateInfoNV
x (Ptr PipelineCoverageModulationStateCreateInfoNV -> IO b
f Ptr PipelineCoverageModulationStateCreateInfoNV
p)
  pokeCStruct :: forall b.
Ptr PipelineCoverageModulationStateCreateInfoNV
-> PipelineCoverageModulationStateCreateInfoNV -> IO b -> IO b
pokeCStruct Ptr PipelineCoverageModulationStateCreateInfoNV
p PipelineCoverageModulationStateCreateInfoNV{Bool
Word32
Vector Float
CoverageModulationModeNV
PipelineCoverageModulationStateCreateFlagsNV
coverageModulationTable :: Vector Float
coverageModulationTableCount :: Word32
coverageModulationTableEnable :: Bool
coverageModulationMode :: CoverageModulationModeNV
flags :: PipelineCoverageModulationStateCreateFlagsNV
$sel:coverageModulationTable:PipelineCoverageModulationStateCreateInfoNV :: PipelineCoverageModulationStateCreateInfoNV -> Vector Float
$sel:coverageModulationTableCount:PipelineCoverageModulationStateCreateInfoNV :: PipelineCoverageModulationStateCreateInfoNV -> Word32
$sel:coverageModulationTableEnable:PipelineCoverageModulationStateCreateInfoNV :: PipelineCoverageModulationStateCreateInfoNV -> Bool
$sel:coverageModulationMode:PipelineCoverageModulationStateCreateInfoNV :: PipelineCoverageModulationStateCreateInfoNV
-> CoverageModulationModeNV
$sel:flags:PipelineCoverageModulationStateCreateInfoNV :: PipelineCoverageModulationStateCreateInfoNV
-> PipelineCoverageModulationStateCreateFlagsNV
..} IO b
f = forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT forall a b. (a -> b) -> a -> b
$ do
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (forall a. Ptr a
nullPtr)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr PipelineCoverageModulationStateCreateFlagsNV)) (PipelineCoverageModulationStateCreateFlagsNV
flags)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr CoverageModulationModeNV)) (CoverageModulationModeNV
coverageModulationMode)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (Bool
coverageModulationTableEnable))
    let pCoverageModulationTableLength :: Int
pCoverageModulationTableLength = forall a. Vector a -> Int
Data.Vector.length forall a b. (a -> b) -> a -> b
$ (Vector Float
coverageModulationTable)
    Word32
coverageModulationTableCount'' <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ if (Word32
coverageModulationTableCount) forall a. Eq a => a -> a -> Bool
== Word32
0
      then forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
pCoverageModulationTableLength
      else do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
pCoverageModulationTableLength forall a. Eq a => a -> a -> Bool
== (Word32
coverageModulationTableCount) Bool -> Bool -> Bool
|| Int
pCoverageModulationTableLength forall a. Eq a => a -> a -> Bool
== Int
0) forall a b. (a -> b) -> a -> b
$
          forall e a. Exception e => e -> IO a
throwIO forall a b. (a -> b) -> a -> b
$ Maybe Handle
-> IOErrorType
-> String
-> String
-> Maybe CInt
-> Maybe String
-> IOException
IOError forall a. Maybe a
Nothing IOErrorType
InvalidArgument String
"" String
"pCoverageModulationTable must be empty or have 'coverageModulationTableCount' elements" forall a. Maybe a
Nothing forall a. Maybe a
Nothing
        forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word32
coverageModulationTableCount)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28 :: Ptr Word32)) (Word32
coverageModulationTableCount'')
    Ptr CFloat
pCoverageModulationTable'' <- if forall a. Vector a -> Bool
Data.Vector.null (Vector Float
coverageModulationTable)
      then forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Ptr a
nullPtr
      else do
        Ptr CFloat
pPCoverageModulationTable <- forall {k} (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT forall a b. (a -> b) -> a -> b
$ forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes @CFloat (((forall a. Vector a -> Int
Data.Vector.length (Vector Float
coverageModulationTable))) forall a. Num a => a -> a -> a
* Int
4)
        forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a b.
Monad m =>
(Int -> a -> m b) -> Vector a -> m ()
Data.Vector.imapM_ (\Int
i Float
e -> forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr CFloat
pPCoverageModulationTable forall a b. Ptr a -> Int -> Ptr b
`plusPtr` (Int
4 forall a. Num a => a -> a -> a
* (Int
i)) :: Ptr CFloat) (Float -> CFloat
CFloat (Float
e))) ((Vector Float
coverageModulationTable))
        forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Ptr CFloat
pPCoverageModulationTable
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32 :: Ptr (Ptr CFloat))) Ptr CFloat
pCoverageModulationTable''
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ IO b
f
  cStructSize :: Int
cStructSize = Int
40
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: forall b.
Ptr PipelineCoverageModulationStateCreateInfoNV -> IO b -> IO b
pokeZeroCStruct Ptr PipelineCoverageModulationStateCreateInfoNV
p IO b
f = do
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV)
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: Ptr (Ptr ()))) (forall a. Ptr a
nullPtr)
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr CoverageModulationModeNV)) (forall a. Zero a => a
zero)
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr Bool32)) (Bool -> Bool32
boolToBool32 (forall a. Zero a => a
zero))
    IO b
f

instance FromCStruct PipelineCoverageModulationStateCreateInfoNV where
  peekCStruct :: Ptr PipelineCoverageModulationStateCreateInfoNV
-> IO PipelineCoverageModulationStateCreateInfoNV
peekCStruct Ptr PipelineCoverageModulationStateCreateInfoNV
p = do
    PipelineCoverageModulationStateCreateFlagsNV
flags <- forall a. Storable a => Ptr a -> IO a
peek @PipelineCoverageModulationStateCreateFlagsNV ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr PipelineCoverageModulationStateCreateFlagsNV))
    CoverageModulationModeNV
coverageModulationMode <- forall a. Storable a => Ptr a -> IO a
peek @CoverageModulationModeNV ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20 :: Ptr CoverageModulationModeNV))
    Bool32
coverageModulationTableEnable <- forall a. Storable a => Ptr a -> IO a
peek @Bool32 ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24 :: Ptr Bool32))
    Word32
coverageModulationTableCount <- forall a. Storable a => Ptr a -> IO a
peek @Word32 ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28 :: Ptr Word32))
    Ptr CFloat
pCoverageModulationTable <- forall a. Storable a => Ptr a -> IO a
peek @(Ptr CFloat) ((Ptr PipelineCoverageModulationStateCreateInfoNV
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32 :: Ptr (Ptr CFloat)))
    let pCoverageModulationTableLength :: Int
pCoverageModulationTableLength = if Ptr CFloat
pCoverageModulationTable forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr then Int
0 else (forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
coverageModulationTableCount)
    Vector Float
pCoverageModulationTable' <- forall (m :: * -> *) a.
Monad m =>
Int -> (Int -> m a) -> m (Vector a)
generateM Int
pCoverageModulationTableLength (\Int
i -> do
      CFloat
pCoverageModulationTableElem <- forall a. Storable a => Ptr a -> IO a
peek @CFloat ((Ptr CFloat
pCoverageModulationTable forall a. Ptr a -> Int -> Ptr a
`advancePtrBytes` (Int
4 forall a. Num a => a -> a -> a
* (Int
i)) :: Ptr CFloat))
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ coerce :: forall a b. Coercible a b => a -> b
coerce @CFloat @Float CFloat
pCoverageModulationTableElem)
    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ PipelineCoverageModulationStateCreateFlagsNV
-> CoverageModulationModeNV
-> Bool
-> Word32
-> Vector Float
-> PipelineCoverageModulationStateCreateInfoNV
PipelineCoverageModulationStateCreateInfoNV
             PipelineCoverageModulationStateCreateFlagsNV
flags
             CoverageModulationModeNV
coverageModulationMode
             (Bool32 -> Bool
bool32ToBool Bool32
coverageModulationTableEnable)
             Word32
coverageModulationTableCount
             Vector Float
pCoverageModulationTable'

instance Zero PipelineCoverageModulationStateCreateInfoNV where
  zero :: PipelineCoverageModulationStateCreateInfoNV
zero = PipelineCoverageModulationStateCreateFlagsNV
-> CoverageModulationModeNV
-> Bool
-> Word32
-> Vector Float
-> PipelineCoverageModulationStateCreateInfoNV
PipelineCoverageModulationStateCreateInfoNV
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Zero a => a
zero
           forall a. Monoid a => a
mempty


-- | VkPipelineCoverageModulationStateCreateFlagsNV - Reserved for future use
--
-- = Description
--
-- 'PipelineCoverageModulationStateCreateFlagsNV' 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_framebuffer_mixed_samples VK_NV_framebuffer_mixed_samples>,
-- 'PipelineCoverageModulationStateCreateInfoNV'
newtype PipelineCoverageModulationStateCreateFlagsNV = PipelineCoverageModulationStateCreateFlagsNV Flags
  deriving newtype (PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
$c/= :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
== :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
$c== :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
Eq, Eq PipelineCoverageModulationStateCreateFlagsNV
PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Ordering
PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
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 :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
$cmin :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
max :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
$cmax :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
>= :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
$c>= :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
> :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
$c> :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
<= :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
$c<= :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
< :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
$c< :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Bool
compare :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Ordering
$ccompare :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> Ordering
Ord, Ptr PipelineCoverageModulationStateCreateFlagsNV
-> IO PipelineCoverageModulationStateCreateFlagsNV
Ptr PipelineCoverageModulationStateCreateFlagsNV
-> Int -> IO PipelineCoverageModulationStateCreateFlagsNV
Ptr PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV -> IO ()
Ptr PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> IO ()
PipelineCoverageModulationStateCreateFlagsNV -> Int
forall b.
Ptr b -> Int -> IO PipelineCoverageModulationStateCreateFlagsNV
forall b.
Ptr b
-> Int -> PipelineCoverageModulationStateCreateFlagsNV -> 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 PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> IO ()
$cpoke :: Ptr PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV -> IO ()
peek :: Ptr PipelineCoverageModulationStateCreateFlagsNV
-> IO PipelineCoverageModulationStateCreateFlagsNV
$cpeek :: Ptr PipelineCoverageModulationStateCreateFlagsNV
-> IO PipelineCoverageModulationStateCreateFlagsNV
pokeByteOff :: forall b.
Ptr b
-> Int -> PipelineCoverageModulationStateCreateFlagsNV -> IO ()
$cpokeByteOff :: forall b.
Ptr b
-> Int -> PipelineCoverageModulationStateCreateFlagsNV -> IO ()
peekByteOff :: forall b.
Ptr b -> Int -> IO PipelineCoverageModulationStateCreateFlagsNV
$cpeekByteOff :: forall b.
Ptr b -> Int -> IO PipelineCoverageModulationStateCreateFlagsNV
pokeElemOff :: Ptr PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV -> IO ()
$cpokeElemOff :: Ptr PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV -> IO ()
peekElemOff :: Ptr PipelineCoverageModulationStateCreateFlagsNV
-> Int -> IO PipelineCoverageModulationStateCreateFlagsNV
$cpeekElemOff :: Ptr PipelineCoverageModulationStateCreateFlagsNV
-> Int -> IO PipelineCoverageModulationStateCreateFlagsNV
alignment :: PipelineCoverageModulationStateCreateFlagsNV -> Int
$calignment :: PipelineCoverageModulationStateCreateFlagsNV -> Int
sizeOf :: PipelineCoverageModulationStateCreateFlagsNV -> Int
$csizeOf :: PipelineCoverageModulationStateCreateFlagsNV -> Int
Storable, PipelineCoverageModulationStateCreateFlagsNV
forall a. a -> Zero a
zero :: PipelineCoverageModulationStateCreateFlagsNV
$czero :: PipelineCoverageModulationStateCreateFlagsNV
Zero, Eq PipelineCoverageModulationStateCreateFlagsNV
PipelineCoverageModulationStateCreateFlagsNV
Int -> PipelineCoverageModulationStateCreateFlagsNV
PipelineCoverageModulationStateCreateFlagsNV -> Bool
PipelineCoverageModulationStateCreateFlagsNV -> Int
PipelineCoverageModulationStateCreateFlagsNV -> Maybe Int
PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
PipelineCoverageModulationStateCreateFlagsNV -> Int -> Bool
PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
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 :: PipelineCoverageModulationStateCreateFlagsNV -> Int
$cpopCount :: PipelineCoverageModulationStateCreateFlagsNV -> Int
rotateR :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$crotateR :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
rotateL :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$crotateL :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
unsafeShiftR :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$cunsafeShiftR :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
shiftR :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$cshiftR :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
unsafeShiftL :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$cunsafeShiftL :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
shiftL :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$cshiftL :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
isSigned :: PipelineCoverageModulationStateCreateFlagsNV -> Bool
$cisSigned :: PipelineCoverageModulationStateCreateFlagsNV -> Bool
bitSize :: PipelineCoverageModulationStateCreateFlagsNV -> Int
$cbitSize :: PipelineCoverageModulationStateCreateFlagsNV -> Int
bitSizeMaybe :: PipelineCoverageModulationStateCreateFlagsNV -> Maybe Int
$cbitSizeMaybe :: PipelineCoverageModulationStateCreateFlagsNV -> Maybe Int
testBit :: PipelineCoverageModulationStateCreateFlagsNV -> Int -> Bool
$ctestBit :: PipelineCoverageModulationStateCreateFlagsNV -> Int -> Bool
complementBit :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$ccomplementBit :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
clearBit :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$cclearBit :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
setBit :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$csetBit :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
bit :: Int -> PipelineCoverageModulationStateCreateFlagsNV
$cbit :: Int -> PipelineCoverageModulationStateCreateFlagsNV
zeroBits :: PipelineCoverageModulationStateCreateFlagsNV
$czeroBits :: PipelineCoverageModulationStateCreateFlagsNV
rotate :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$crotate :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
shift :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
$cshift :: PipelineCoverageModulationStateCreateFlagsNV
-> Int -> PipelineCoverageModulationStateCreateFlagsNV
complement :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
$ccomplement :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
xor :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
$cxor :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
.|. :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
$c.|. :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
.&. :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
$c.&. :: PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
-> PipelineCoverageModulationStateCreateFlagsNV
Bits, Bits PipelineCoverageModulationStateCreateFlagsNV
PipelineCoverageModulationStateCreateFlagsNV -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
countTrailingZeros :: PipelineCoverageModulationStateCreateFlagsNV -> Int
$ccountTrailingZeros :: PipelineCoverageModulationStateCreateFlagsNV -> Int
countLeadingZeros :: PipelineCoverageModulationStateCreateFlagsNV -> Int
$ccountLeadingZeros :: PipelineCoverageModulationStateCreateFlagsNV -> Int
finiteBitSize :: PipelineCoverageModulationStateCreateFlagsNV -> Int
$cfiniteBitSize :: PipelineCoverageModulationStateCreateFlagsNV -> Int
FiniteBits)

conNamePipelineCoverageModulationStateCreateFlagsNV :: String
conNamePipelineCoverageModulationStateCreateFlagsNV :: String
conNamePipelineCoverageModulationStateCreateFlagsNV = String
"PipelineCoverageModulationStateCreateFlagsNV"

enumPrefixPipelineCoverageModulationStateCreateFlagsNV :: String
enumPrefixPipelineCoverageModulationStateCreateFlagsNV :: String
enumPrefixPipelineCoverageModulationStateCreateFlagsNV = String
""

showTablePipelineCoverageModulationStateCreateFlagsNV :: [(PipelineCoverageModulationStateCreateFlagsNV, String)]
showTablePipelineCoverageModulationStateCreateFlagsNV :: [(PipelineCoverageModulationStateCreateFlagsNV, String)]
showTablePipelineCoverageModulationStateCreateFlagsNV = []

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

instance Read PipelineCoverageModulationStateCreateFlagsNV where
  readPrec :: ReadPrec PipelineCoverageModulationStateCreateFlagsNV
readPrec =
    forall i a.
Read i =>
String -> [(a, String)] -> String -> (i -> a) -> ReadPrec a
enumReadPrec
      String
enumPrefixPipelineCoverageModulationStateCreateFlagsNV
      [(PipelineCoverageModulationStateCreateFlagsNV, String)]
showTablePipelineCoverageModulationStateCreateFlagsNV
      String
conNamePipelineCoverageModulationStateCreateFlagsNV
      Word32 -> PipelineCoverageModulationStateCreateFlagsNV
PipelineCoverageModulationStateCreateFlagsNV

-- | VkCoverageModulationModeNV - Specify the coverage modulation mode
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_NV_framebuffer_mixed_samples VK_NV_framebuffer_mixed_samples>,
-- 'PipelineCoverageModulationStateCreateInfoNV',
-- 'Vulkan.Extensions.VK_EXT_extended_dynamic_state3.cmdSetCoverageModulationModeNV'
newtype CoverageModulationModeNV = CoverageModulationModeNV Int32
  deriving newtype (CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
$c/= :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
== :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
$c== :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
Eq, Eq CoverageModulationModeNV
CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
CoverageModulationModeNV -> CoverageModulationModeNV -> Ordering
CoverageModulationModeNV
-> CoverageModulationModeNV -> CoverageModulationModeNV
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 :: CoverageModulationModeNV
-> CoverageModulationModeNV -> CoverageModulationModeNV
$cmin :: CoverageModulationModeNV
-> CoverageModulationModeNV -> CoverageModulationModeNV
max :: CoverageModulationModeNV
-> CoverageModulationModeNV -> CoverageModulationModeNV
$cmax :: CoverageModulationModeNV
-> CoverageModulationModeNV -> CoverageModulationModeNV
>= :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
$c>= :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
> :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
$c> :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
<= :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
$c<= :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
< :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
$c< :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool
compare :: CoverageModulationModeNV -> CoverageModulationModeNV -> Ordering
$ccompare :: CoverageModulationModeNV -> CoverageModulationModeNV -> Ordering
Ord, Ptr CoverageModulationModeNV -> IO CoverageModulationModeNV
Ptr CoverageModulationModeNV -> Int -> IO CoverageModulationModeNV
Ptr CoverageModulationModeNV
-> Int -> CoverageModulationModeNV -> IO ()
Ptr CoverageModulationModeNV -> CoverageModulationModeNV -> IO ()
CoverageModulationModeNV -> Int
forall b. Ptr b -> Int -> IO CoverageModulationModeNV
forall b. Ptr b -> Int -> CoverageModulationModeNV -> 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 CoverageModulationModeNV -> CoverageModulationModeNV -> IO ()
$cpoke :: Ptr CoverageModulationModeNV -> CoverageModulationModeNV -> IO ()
peek :: Ptr CoverageModulationModeNV -> IO CoverageModulationModeNV
$cpeek :: Ptr CoverageModulationModeNV -> IO CoverageModulationModeNV
pokeByteOff :: forall b. Ptr b -> Int -> CoverageModulationModeNV -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> CoverageModulationModeNV -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO CoverageModulationModeNV
$cpeekByteOff :: forall b. Ptr b -> Int -> IO CoverageModulationModeNV
pokeElemOff :: Ptr CoverageModulationModeNV
-> Int -> CoverageModulationModeNV -> IO ()
$cpokeElemOff :: Ptr CoverageModulationModeNV
-> Int -> CoverageModulationModeNV -> IO ()
peekElemOff :: Ptr CoverageModulationModeNV -> Int -> IO CoverageModulationModeNV
$cpeekElemOff :: Ptr CoverageModulationModeNV -> Int -> IO CoverageModulationModeNV
alignment :: CoverageModulationModeNV -> Int
$calignment :: CoverageModulationModeNV -> Int
sizeOf :: CoverageModulationModeNV -> Int
$csizeOf :: CoverageModulationModeNV -> Int
Storable, CoverageModulationModeNV
forall a. a -> Zero a
zero :: CoverageModulationModeNV
$czero :: CoverageModulationModeNV
Zero)

-- | 'COVERAGE_MODULATION_MODE_NONE_NV' specifies that no components are
-- multiplied by the modulation factor.
pattern $bCOVERAGE_MODULATION_MODE_NONE_NV :: CoverageModulationModeNV
$mCOVERAGE_MODULATION_MODE_NONE_NV :: forall {r}.
CoverageModulationModeNV -> ((# #) -> r) -> ((# #) -> r) -> r
COVERAGE_MODULATION_MODE_NONE_NV = CoverageModulationModeNV 0

-- | 'COVERAGE_MODULATION_MODE_RGB_NV' specifies that the red, green, and
-- blue components are multiplied by the modulation factor.
pattern $bCOVERAGE_MODULATION_MODE_RGB_NV :: CoverageModulationModeNV
$mCOVERAGE_MODULATION_MODE_RGB_NV :: forall {r}.
CoverageModulationModeNV -> ((# #) -> r) -> ((# #) -> r) -> r
COVERAGE_MODULATION_MODE_RGB_NV = CoverageModulationModeNV 1

-- | 'COVERAGE_MODULATION_MODE_ALPHA_NV' specifies that the alpha component
-- is multiplied by the modulation factor.
pattern $bCOVERAGE_MODULATION_MODE_ALPHA_NV :: CoverageModulationModeNV
$mCOVERAGE_MODULATION_MODE_ALPHA_NV :: forall {r}.
CoverageModulationModeNV -> ((# #) -> r) -> ((# #) -> r) -> r
COVERAGE_MODULATION_MODE_ALPHA_NV = CoverageModulationModeNV 2

-- | 'COVERAGE_MODULATION_MODE_RGBA_NV' specifies that all components are
-- multiplied by the modulation factor.
pattern $bCOVERAGE_MODULATION_MODE_RGBA_NV :: CoverageModulationModeNV
$mCOVERAGE_MODULATION_MODE_RGBA_NV :: forall {r}.
CoverageModulationModeNV -> ((# #) -> r) -> ((# #) -> r) -> r
COVERAGE_MODULATION_MODE_RGBA_NV = CoverageModulationModeNV 3

{-# COMPLETE
  COVERAGE_MODULATION_MODE_NONE_NV
  , COVERAGE_MODULATION_MODE_RGB_NV
  , COVERAGE_MODULATION_MODE_ALPHA_NV
  , COVERAGE_MODULATION_MODE_RGBA_NV ::
    CoverageModulationModeNV
  #-}

conNameCoverageModulationModeNV :: String
conNameCoverageModulationModeNV :: String
conNameCoverageModulationModeNV = String
"CoverageModulationModeNV"

enumPrefixCoverageModulationModeNV :: String
enumPrefixCoverageModulationModeNV :: String
enumPrefixCoverageModulationModeNV = String
"COVERAGE_MODULATION_MODE_"

showTableCoverageModulationModeNV :: [(CoverageModulationModeNV, String)]
showTableCoverageModulationModeNV :: [(CoverageModulationModeNV, String)]
showTableCoverageModulationModeNV =
  [
    ( CoverageModulationModeNV
COVERAGE_MODULATION_MODE_NONE_NV
    , String
"NONE_NV"
    )
  ,
    ( CoverageModulationModeNV
COVERAGE_MODULATION_MODE_RGB_NV
    , String
"RGB_NV"
    )
  ,
    ( CoverageModulationModeNV
COVERAGE_MODULATION_MODE_ALPHA_NV
    , String
"ALPHA_NV"
    )
  ,
    ( CoverageModulationModeNV
COVERAGE_MODULATION_MODE_RGBA_NV
    , String
"RGBA_NV"
    )
  ]

instance Show CoverageModulationModeNV where
  showsPrec :: Int -> CoverageModulationModeNV -> ShowS
showsPrec =
    forall a i.
Eq a =>
String
-> [(a, String)]
-> String
-> (a -> i)
-> (i -> ShowS)
-> Int
-> a
-> ShowS
enumShowsPrec
      String
enumPrefixCoverageModulationModeNV
      [(CoverageModulationModeNV, String)]
showTableCoverageModulationModeNV
      String
conNameCoverageModulationModeNV
      (\(CoverageModulationModeNV Int32
x) -> Int32
x)
      (forall a. Show a => Int -> a -> ShowS
showsPrec Int
11)

instance Read CoverageModulationModeNV where
  readPrec :: ReadPrec CoverageModulationModeNV
readPrec =
    forall i a.
Read i =>
String -> [(a, String)] -> String -> (i -> a) -> ReadPrec a
enumReadPrec
      String
enumPrefixCoverageModulationModeNV
      [(CoverageModulationModeNV, String)]
showTableCoverageModulationModeNV
      String
conNameCoverageModulationModeNV
      Int32 -> CoverageModulationModeNV
CoverageModulationModeNV

type NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION = 1

-- No documentation found for TopLevel "VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION"
pattern NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION :: forall a . Integral a => a
pattern $bNV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION :: forall a. Integral a => a
$mNV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION :: forall {r} {a}.
Integral a =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION = 1


type NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME = "VK_NV_framebuffer_mixed_samples"

-- No documentation found for TopLevel "VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME"
pattern NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME :: forall a . (Eq a, IsString a) => a
pattern $bNV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a
$mNV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME = "VK_NV_framebuffer_mixed_samples"