{-# language CPP #-}
-- | = Name
--
-- VK_AMD_rasterization_order - device extension
--
-- == VK_AMD_rasterization_order
--
-- [__Name String__]
--     @VK_AMD_rasterization_order@
--
-- [__Extension Type__]
--     Device extension
--
-- [__Registered Extension Number__]
--     19
--
-- [__Revision__]
--     1
--
-- [__Extension and Version Dependencies__]
--
--     -   Requires Vulkan 1.0
--
-- [__Contact__]
--
--     -   Daniel Rakos
--         <https://github.com/KhronosGroup/Vulkan-Docs/issues/new?title=VK_AMD_rasterization_order:%20&body=@drakos-amd%20 >
--
-- == Other Extension Metadata
--
-- [__Last Modified Date__]
--     2016-04-25
--
-- [__IP Status__]
--     No known IP claims.
--
-- [__Contributors__]
--
--     -   Matthaeus G. Chajdas, AMD
--
--     -   Jaakko Konttinen, AMD
--
--     -   Daniel Rakos, AMD
--
--     -   Graham Sellers, AMD
--
--     -   Dominik Witczak, AMD
--
-- == Description
--
-- This extension introduces the possibility for the application to control
-- the order of primitive rasterization. In unextended Vulkan, the
-- following stages are guaranteed to execute in /API order/:
--
-- -   depth bounds test
--
-- -   stencil test, stencil op, and stencil write
--
-- -   depth test and depth write
--
-- -   occlusion queries
--
-- -   blending, logic op, and color write
--
-- This extension enables applications to opt into a relaxed,
-- implementation defined primitive rasterization order that may allow
-- better parallel processing of primitives and thus enabling higher
-- primitive throughput. It is applicable in cases where the primitive
-- rasterization order is known to not affect the output of the rendering
-- or any differences caused by a different rasterization order are not a
-- concern from the point of view of the application’s purpose.
--
-- A few examples of cases when using the relaxed primitive rasterization
-- order would not have an effect on the final rendering:
--
-- -   If the primitives rendered are known to not overlap in framebuffer
--     space.
--
-- -   If depth testing is used with a comparison operator of
--     'Vulkan.Core10.Enums.CompareOp.COMPARE_OP_LESS',
--     'Vulkan.Core10.Enums.CompareOp.COMPARE_OP_LESS_OR_EQUAL',
--     'Vulkan.Core10.Enums.CompareOp.COMPARE_OP_GREATER', or
--     'Vulkan.Core10.Enums.CompareOp.COMPARE_OP_GREATER_OR_EQUAL', and the
--     primitives rendered are known to not overlap in clip space.
--
-- -   If depth testing is not used and blending is enabled for all
--     attachments with a commutative blend operator.
--
-- == New Structures
--
-- -   Extending
--     'Vulkan.Core10.Pipeline.PipelineRasterizationStateCreateInfo':
--
--     -   'PipelineRasterizationStateRasterizationOrderAMD'
--
-- == New Enums
--
-- -   'RasterizationOrderAMD'
--
-- == New Enum Constants
--
-- -   'AMD_RASTERIZATION_ORDER_EXTENSION_NAME'
--
-- -   'AMD_RASTERIZATION_ORDER_SPEC_VERSION'
--
-- -   Extending 'Vulkan.Core10.Enums.StructureType.StructureType':
--
--     -   'Vulkan.Core10.Enums.StructureType.STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD'
--
-- == Issues
--
-- 1) How is this extension useful to application developers?
--
-- __RESOLVED__: Allows them to increase primitive throughput for cases
-- when strict API order rasterization is not important due to the nature
-- of the content, the configuration used, or the requirements towards the
-- output of the rendering.
--
-- 2) How does this extension interact with content optimizations aiming to
-- reduce overdraw by appropriately ordering the input primitives?
--
-- __RESOLVED__: While the relaxed rasterization order might somewhat limit
-- the effectiveness of such content optimizations, most of the benefits of
-- it are expected to be retained even when the relaxed rasterization order
-- is used, so applications /should/ still apply these optimizations even
-- if they intend to use the extension.
--
-- 3) Are there any guarantees about the primitive rasterization order when
-- using the new relaxed mode?
--
-- __RESOLVED__: No. In this case the rasterization order is completely
-- implementation dependent, but in practice it is expected to partially
-- still follow the order of incoming primitives.
--
-- 4) Does the new relaxed rasterization order have any adverse effect on
-- repeatability and other invariance rules of the API?
--
-- __RESOLVED__: Yes, in the sense that it extends the list of exceptions
-- when the repeatability requirement does not apply.
--
-- == Examples
--
-- None
--
-- == Issues
--
-- None
--
-- == Version History
--
-- -   Revision 1, 2016-04-25 (Daniel Rakos)
--
--     -   Initial draft.
--
-- = See Also
--
-- 'PipelineRasterizationStateRasterizationOrderAMD',
-- 'RasterizationOrderAMD'
--
-- = Document Notes
--
-- For more information, see the
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_AMD_rasterization_order Vulkan Specification>
--
-- This page is a generated document. Fixes and changes should be made to
-- the generator scripts, not directly.
module Vulkan.Extensions.VK_AMD_rasterization_order  ( PipelineRasterizationStateRasterizationOrderAMD(..)
                                                     , RasterizationOrderAMD( RASTERIZATION_ORDER_STRICT_AMD
                                                                            , RASTERIZATION_ORDER_RELAXED_AMD
                                                                            , ..
                                                                            )
                                                     , AMD_RASTERIZATION_ORDER_SPEC_VERSION
                                                     , pattern AMD_RASTERIZATION_ORDER_SPEC_VERSION
                                                     , AMD_RASTERIZATION_ORDER_EXTENSION_NAME
                                                     , pattern AMD_RASTERIZATION_ORDER_EXTENSION_NAME
                                                     ) where

import Vulkan.Internal.Utils (enumReadPrec)
import Vulkan.Internal.Utils (enumShowsPrec)
import Foreign.Marshal.Alloc (allocaBytesAligned)
import Foreign.Ptr (nullPtr)
import Foreign.Ptr (plusPtr)
import GHC.Show (showsPrec)
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.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.Kind (Type)
import Vulkan.Core10.Enums.StructureType (StructureType)
import Vulkan.Core10.Enums.StructureType (StructureType(STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD))
-- | VkPipelineRasterizationStateRasterizationOrderAMD - Structure defining
-- rasterization order for a graphics pipeline
--
-- == Valid Usage (Implicit)
--
-- If the @VK_AMD_rasterization_order@ device extension is not enabled or
-- the application does not request a particular rasterization order
-- through specifying a 'PipelineRasterizationStateRasterizationOrderAMD'
-- structure then the rasterization order used by the graphics pipeline
-- defaults to 'RASTERIZATION_ORDER_STRICT_AMD'.
--
-- = See Also
--
-- 'RasterizationOrderAMD',
-- 'Vulkan.Core10.Enums.StructureType.StructureType'
data PipelineRasterizationStateRasterizationOrderAMD = PipelineRasterizationStateRasterizationOrderAMD
  { -- | @rasterizationOrder@ is a 'RasterizationOrderAMD' value specifying the
    -- primitive rasterization order to use.
    --
    -- #VUID-VkPipelineRasterizationStateRasterizationOrderAMD-rasterizationOrder-parameter#
    -- @rasterizationOrder@ /must/ be a valid 'RasterizationOrderAMD' value
    PipelineRasterizationStateRasterizationOrderAMD
-> RasterizationOrderAMD
rasterizationOrder :: RasterizationOrderAMD }
  deriving (Typeable, PipelineRasterizationStateRasterizationOrderAMD
-> PipelineRasterizationStateRasterizationOrderAMD -> Bool
(PipelineRasterizationStateRasterizationOrderAMD
 -> PipelineRasterizationStateRasterizationOrderAMD -> Bool)
-> (PipelineRasterizationStateRasterizationOrderAMD
    -> PipelineRasterizationStateRasterizationOrderAMD -> Bool)
-> Eq PipelineRasterizationStateRasterizationOrderAMD
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PipelineRasterizationStateRasterizationOrderAMD
-> PipelineRasterizationStateRasterizationOrderAMD -> Bool
$c/= :: PipelineRasterizationStateRasterizationOrderAMD
-> PipelineRasterizationStateRasterizationOrderAMD -> Bool
== :: PipelineRasterizationStateRasterizationOrderAMD
-> PipelineRasterizationStateRasterizationOrderAMD -> Bool
$c== :: PipelineRasterizationStateRasterizationOrderAMD
-> PipelineRasterizationStateRasterizationOrderAMD -> Bool
Eq)
#if defined(GENERIC_INSTANCES)
deriving instance Generic (PipelineRasterizationStateRasterizationOrderAMD)
#endif
deriving instance Show PipelineRasterizationStateRasterizationOrderAMD

instance ToCStruct PipelineRasterizationStateRasterizationOrderAMD where
  withCStruct :: PipelineRasterizationStateRasterizationOrderAMD
-> (Ptr PipelineRasterizationStateRasterizationOrderAMD -> IO b)
-> IO b
withCStruct x :: PipelineRasterizationStateRasterizationOrderAMD
x f :: Ptr PipelineRasterizationStateRasterizationOrderAMD -> IO b
f = Int
-> Int
-> (Ptr PipelineRasterizationStateRasterizationOrderAMD -> IO b)
-> IO b
forall a b. Int -> Int -> (Ptr a -> IO b) -> IO b
allocaBytesAligned 24 8 ((Ptr PipelineRasterizationStateRasterizationOrderAMD -> IO b)
 -> IO b)
-> (Ptr PipelineRasterizationStateRasterizationOrderAMD -> IO b)
-> IO b
forall a b. (a -> b) -> a -> b
$ \p :: Ptr PipelineRasterizationStateRasterizationOrderAMD
p -> Ptr PipelineRasterizationStateRasterizationOrderAMD
-> PipelineRasterizationStateRasterizationOrderAMD -> IO b -> IO b
forall a b. ToCStruct a => Ptr a -> a -> IO b -> IO b
pokeCStruct Ptr PipelineRasterizationStateRasterizationOrderAMD
p PipelineRasterizationStateRasterizationOrderAMD
x (Ptr PipelineRasterizationStateRasterizationOrderAMD -> IO b
f Ptr PipelineRasterizationStateRasterizationOrderAMD
p)
  pokeCStruct :: Ptr PipelineRasterizationStateRasterizationOrderAMD
-> PipelineRasterizationStateRasterizationOrderAMD -> IO b -> IO b
pokeCStruct p :: Ptr PipelineRasterizationStateRasterizationOrderAMD
p PipelineRasterizationStateRasterizationOrderAMD{..} f :: IO b
f = do
    Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineRasterizationStateRasterizationOrderAMD
p Ptr PipelineRasterizationStateRasterizationOrderAMD
-> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD)
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineRasterizationStateRasterizationOrderAMD
p Ptr PipelineRasterizationStateRasterizationOrderAMD
-> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    Ptr RasterizationOrderAMD -> RasterizationOrderAMD -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineRasterizationStateRasterizationOrderAMD
p Ptr PipelineRasterizationStateRasterizationOrderAMD
-> Int -> Ptr RasterizationOrderAMD
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16 :: Ptr RasterizationOrderAMD)) (RasterizationOrderAMD
rasterizationOrder)
    IO b
f
  cStructSize :: Int
cStructSize = 24
  cStructAlignment :: Int
cStructAlignment = 8
  pokeZeroCStruct :: Ptr PipelineRasterizationStateRasterizationOrderAMD -> IO b -> IO b
pokeZeroCStruct p :: Ptr PipelineRasterizationStateRasterizationOrderAMD
p f :: IO b
f = do
    Ptr StructureType -> StructureType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineRasterizationStateRasterizationOrderAMD
p Ptr PipelineRasterizationStateRasterizationOrderAMD
-> Int -> Ptr StructureType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD)
    Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineRasterizationStateRasterizationOrderAMD
p Ptr PipelineRasterizationStateRasterizationOrderAMD
-> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8 :: Ptr (Ptr ()))) (Ptr ()
forall a. Ptr a
nullPtr)
    Ptr RasterizationOrderAMD -> RasterizationOrderAMD -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineRasterizationStateRasterizationOrderAMD
p Ptr PipelineRasterizationStateRasterizationOrderAMD
-> Int -> Ptr RasterizationOrderAMD
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16 :: Ptr RasterizationOrderAMD)) (RasterizationOrderAMD
forall a. Zero a => a
zero)
    IO b
f

instance FromCStruct PipelineRasterizationStateRasterizationOrderAMD where
  peekCStruct :: Ptr PipelineRasterizationStateRasterizationOrderAMD
-> IO PipelineRasterizationStateRasterizationOrderAMD
peekCStruct p :: Ptr PipelineRasterizationStateRasterizationOrderAMD
p = do
    RasterizationOrderAMD
rasterizationOrder <- Ptr RasterizationOrderAMD -> IO RasterizationOrderAMD
forall a. Storable a => Ptr a -> IO a
peek @RasterizationOrderAMD ((Ptr PipelineRasterizationStateRasterizationOrderAMD
p Ptr PipelineRasterizationStateRasterizationOrderAMD
-> Int -> Ptr RasterizationOrderAMD
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16 :: Ptr RasterizationOrderAMD))
    PipelineRasterizationStateRasterizationOrderAMD
-> IO PipelineRasterizationStateRasterizationOrderAMD
forall (f :: * -> *) a. Applicative f => a -> f a
pure (PipelineRasterizationStateRasterizationOrderAMD
 -> IO PipelineRasterizationStateRasterizationOrderAMD)
-> PipelineRasterizationStateRasterizationOrderAMD
-> IO PipelineRasterizationStateRasterizationOrderAMD
forall a b. (a -> b) -> a -> b
$ RasterizationOrderAMD
-> PipelineRasterizationStateRasterizationOrderAMD
PipelineRasterizationStateRasterizationOrderAMD
             RasterizationOrderAMD
rasterizationOrder

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

instance Zero PipelineRasterizationStateRasterizationOrderAMD where
  zero :: PipelineRasterizationStateRasterizationOrderAMD
zero = RasterizationOrderAMD
-> PipelineRasterizationStateRasterizationOrderAMD
PipelineRasterizationStateRasterizationOrderAMD
           RasterizationOrderAMD
forall a. Zero a => a
zero


-- | VkRasterizationOrderAMD - Specify rasterization order for a graphics
-- pipeline
--
-- = See Also
--
-- 'PipelineRasterizationStateRasterizationOrderAMD'
newtype RasterizationOrderAMD = RasterizationOrderAMD Int32
  deriving newtype (RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
(RasterizationOrderAMD -> RasterizationOrderAMD -> Bool)
-> (RasterizationOrderAMD -> RasterizationOrderAMD -> Bool)
-> Eq RasterizationOrderAMD
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
$c/= :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
== :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
$c== :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
Eq, Eq RasterizationOrderAMD
Eq RasterizationOrderAMD =>
(RasterizationOrderAMD -> RasterizationOrderAMD -> Ordering)
-> (RasterizationOrderAMD -> RasterizationOrderAMD -> Bool)
-> (RasterizationOrderAMD -> RasterizationOrderAMD -> Bool)
-> (RasterizationOrderAMD -> RasterizationOrderAMD -> Bool)
-> (RasterizationOrderAMD -> RasterizationOrderAMD -> Bool)
-> (RasterizationOrderAMD
    -> RasterizationOrderAMD -> RasterizationOrderAMD)
-> (RasterizationOrderAMD
    -> RasterizationOrderAMD -> RasterizationOrderAMD)
-> Ord RasterizationOrderAMD
RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
RasterizationOrderAMD -> RasterizationOrderAMD -> Ordering
RasterizationOrderAMD
-> RasterizationOrderAMD -> RasterizationOrderAMD
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 :: RasterizationOrderAMD
-> RasterizationOrderAMD -> RasterizationOrderAMD
$cmin :: RasterizationOrderAMD
-> RasterizationOrderAMD -> RasterizationOrderAMD
max :: RasterizationOrderAMD
-> RasterizationOrderAMD -> RasterizationOrderAMD
$cmax :: RasterizationOrderAMD
-> RasterizationOrderAMD -> RasterizationOrderAMD
>= :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
$c>= :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
> :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
$c> :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
<= :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
$c<= :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
< :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
$c< :: RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
compare :: RasterizationOrderAMD -> RasterizationOrderAMD -> Ordering
$ccompare :: RasterizationOrderAMD -> RasterizationOrderAMD -> Ordering
$cp1Ord :: Eq RasterizationOrderAMD
Ord, Ptr b -> Int -> IO RasterizationOrderAMD
Ptr b -> Int -> RasterizationOrderAMD -> IO ()
Ptr RasterizationOrderAMD -> IO RasterizationOrderAMD
Ptr RasterizationOrderAMD -> Int -> IO RasterizationOrderAMD
Ptr RasterizationOrderAMD -> Int -> RasterizationOrderAMD -> IO ()
Ptr RasterizationOrderAMD -> RasterizationOrderAMD -> IO ()
RasterizationOrderAMD -> Int
(RasterizationOrderAMD -> Int)
-> (RasterizationOrderAMD -> Int)
-> (Ptr RasterizationOrderAMD -> Int -> IO RasterizationOrderAMD)
-> (Ptr RasterizationOrderAMD
    -> Int -> RasterizationOrderAMD -> IO ())
-> (forall b. Ptr b -> Int -> IO RasterizationOrderAMD)
-> (forall b. Ptr b -> Int -> RasterizationOrderAMD -> IO ())
-> (Ptr RasterizationOrderAMD -> IO RasterizationOrderAMD)
-> (Ptr RasterizationOrderAMD -> RasterizationOrderAMD -> IO ())
-> Storable RasterizationOrderAMD
forall b. Ptr b -> Int -> IO RasterizationOrderAMD
forall b. Ptr b -> Int -> RasterizationOrderAMD -> 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 RasterizationOrderAMD -> RasterizationOrderAMD -> IO ()
$cpoke :: Ptr RasterizationOrderAMD -> RasterizationOrderAMD -> IO ()
peek :: Ptr RasterizationOrderAMD -> IO RasterizationOrderAMD
$cpeek :: Ptr RasterizationOrderAMD -> IO RasterizationOrderAMD
pokeByteOff :: Ptr b -> Int -> RasterizationOrderAMD -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> RasterizationOrderAMD -> IO ()
peekByteOff :: Ptr b -> Int -> IO RasterizationOrderAMD
$cpeekByteOff :: forall b. Ptr b -> Int -> IO RasterizationOrderAMD
pokeElemOff :: Ptr RasterizationOrderAMD -> Int -> RasterizationOrderAMD -> IO ()
$cpokeElemOff :: Ptr RasterizationOrderAMD -> Int -> RasterizationOrderAMD -> IO ()
peekElemOff :: Ptr RasterizationOrderAMD -> Int -> IO RasterizationOrderAMD
$cpeekElemOff :: Ptr RasterizationOrderAMD -> Int -> IO RasterizationOrderAMD
alignment :: RasterizationOrderAMD -> Int
$calignment :: RasterizationOrderAMD -> Int
sizeOf :: RasterizationOrderAMD -> Int
$csizeOf :: RasterizationOrderAMD -> Int
Storable, RasterizationOrderAMD
RasterizationOrderAMD -> Zero RasterizationOrderAMD
forall a. a -> Zero a
zero :: RasterizationOrderAMD
$czero :: RasterizationOrderAMD
Zero)

-- | 'RASTERIZATION_ORDER_STRICT_AMD' specifies that operations for each
-- primitive in a subpass /must/ occur in
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#drawing-primitive-order primitive order>.
pattern $bRASTERIZATION_ORDER_STRICT_AMD :: RasterizationOrderAMD
$mRASTERIZATION_ORDER_STRICT_AMD :: forall r.
RasterizationOrderAMD -> (Void# -> r) -> (Void# -> r) -> r
RASTERIZATION_ORDER_STRICT_AMD  = RasterizationOrderAMD 0
-- | 'RASTERIZATION_ORDER_RELAXED_AMD' specifies that operations for each
-- primitive in a subpass /may/ not occur in
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#drawing-primitive-order primitive order>.
pattern $bRASTERIZATION_ORDER_RELAXED_AMD :: RasterizationOrderAMD
$mRASTERIZATION_ORDER_RELAXED_AMD :: forall r.
RasterizationOrderAMD -> (Void# -> r) -> (Void# -> r) -> r
RASTERIZATION_ORDER_RELAXED_AMD = RasterizationOrderAMD 1
{-# complete RASTERIZATION_ORDER_STRICT_AMD,
             RASTERIZATION_ORDER_RELAXED_AMD :: RasterizationOrderAMD #-}

conNameRasterizationOrderAMD :: String
conNameRasterizationOrderAMD :: String
conNameRasterizationOrderAMD = "RasterizationOrderAMD"

enumPrefixRasterizationOrderAMD :: String
enumPrefixRasterizationOrderAMD :: String
enumPrefixRasterizationOrderAMD = "RASTERIZATION_ORDER_"

showTableRasterizationOrderAMD :: [(RasterizationOrderAMD, String)]
showTableRasterizationOrderAMD :: [(RasterizationOrderAMD, String)]
showTableRasterizationOrderAMD =
  [(RasterizationOrderAMD
RASTERIZATION_ORDER_STRICT_AMD, "STRICT_AMD"), (RasterizationOrderAMD
RASTERIZATION_ORDER_RELAXED_AMD, "RELAXED_AMD")]

instance Show RasterizationOrderAMD where
  showsPrec :: Int -> RasterizationOrderAMD -> ShowS
showsPrec = String
-> [(RasterizationOrderAMD, String)]
-> String
-> (RasterizationOrderAMD -> Int32)
-> (Int32 -> ShowS)
-> Int
-> RasterizationOrderAMD
-> ShowS
forall a i.
Eq a =>
String
-> [(a, String)]
-> String
-> (a -> i)
-> (i -> ShowS)
-> Int
-> a
-> ShowS
enumShowsPrec String
enumPrefixRasterizationOrderAMD
                            [(RasterizationOrderAMD, String)]
showTableRasterizationOrderAMD
                            String
conNameRasterizationOrderAMD
                            (\(RasterizationOrderAMD x :: Int32
x) -> Int32
x)
                            (Int -> Int32 -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec 11)

instance Read RasterizationOrderAMD where
  readPrec :: ReadPrec RasterizationOrderAMD
readPrec = String
-> [(RasterizationOrderAMD, String)]
-> String
-> (Int32 -> RasterizationOrderAMD)
-> ReadPrec RasterizationOrderAMD
forall i a.
Read i =>
String -> [(a, String)] -> String -> (i -> a) -> ReadPrec a
enumReadPrec String
enumPrefixRasterizationOrderAMD
                          [(RasterizationOrderAMD, String)]
showTableRasterizationOrderAMD
                          String
conNameRasterizationOrderAMD
                          Int32 -> RasterizationOrderAMD
RasterizationOrderAMD


type AMD_RASTERIZATION_ORDER_SPEC_VERSION = 1

-- No documentation found for TopLevel "VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION"
pattern AMD_RASTERIZATION_ORDER_SPEC_VERSION :: forall a . Integral a => a
pattern $bAMD_RASTERIZATION_ORDER_SPEC_VERSION :: a
$mAMD_RASTERIZATION_ORDER_SPEC_VERSION :: forall r a. Integral a => a -> (Void# -> r) -> (Void# -> r) -> r
AMD_RASTERIZATION_ORDER_SPEC_VERSION = 1


type AMD_RASTERIZATION_ORDER_EXTENSION_NAME = "VK_AMD_rasterization_order"

-- No documentation found for TopLevel "VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME"
pattern AMD_RASTERIZATION_ORDER_EXTENSION_NAME :: forall a . (Eq a, IsString a) => a
pattern $bAMD_RASTERIZATION_ORDER_EXTENSION_NAME :: a
$mAMD_RASTERIZATION_ORDER_EXTENSION_NAME :: forall r a.
(Eq a, IsString a) =>
a -> (Void# -> r) -> (Void# -> r) -> r
AMD_RASTERIZATION_ORDER_EXTENSION_NAME = "VK_AMD_rasterization_order"