{-# 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
--
-- [__Ratification Status__]
--     Not ratified
--
-- [__Extension and Version Dependencies__; __Contact__]
--
--     -   Daniel Rakos
--         <https://github.com/KhronosGroup/Vulkan-Docs/issues/new?body=[VK_AMD_rasterization_order] @drakos-amd%0A*Here describe the issue or question you have about the VK_AMD_rasterization_order extension* >
--
-- == 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://registry.khronos.org/vulkan/specs/1.3-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 (allocaBytes)
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
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_AMD_rasterization_order VK_AMD_rasterization_order>,
-- '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
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 :: forall b.
PipelineRasterizationStateRasterizationOrderAMD
-> (Ptr PipelineRasterizationStateRasterizationOrderAMD -> IO b)
-> IO b
withCStruct PipelineRasterizationStateRasterizationOrderAMD
x Ptr PipelineRasterizationStateRasterizationOrderAMD -> IO b
f = forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
24 forall a b. (a -> b) -> a -> b
$ \Ptr PipelineRasterizationStateRasterizationOrderAMD
p -> 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 :: forall b.
Ptr PipelineRasterizationStateRasterizationOrderAMD
-> PipelineRasterizationStateRasterizationOrderAMD -> IO b -> IO b
pokeCStruct Ptr PipelineRasterizationStateRasterizationOrderAMD
p PipelineRasterizationStateRasterizationOrderAMD{RasterizationOrderAMD
rasterizationOrder :: RasterizationOrderAMD
$sel:rasterizationOrder:PipelineRasterizationStateRasterizationOrderAMD :: PipelineRasterizationStateRasterizationOrderAMD
-> RasterizationOrderAMD
..} IO b
f = do
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineRasterizationStateRasterizationOrderAMD
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD)
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineRasterizationStateRasterizationOrderAMD
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 PipelineRasterizationStateRasterizationOrderAMD
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr RasterizationOrderAMD)) (RasterizationOrderAMD
rasterizationOrder)
    IO b
f
  cStructSize :: Int
cStructSize = Int
24
  cStructAlignment :: Int
cStructAlignment = Int
8
  pokeZeroCStruct :: forall b.
Ptr PipelineRasterizationStateRasterizationOrderAMD -> IO b -> IO b
pokeZeroCStruct Ptr PipelineRasterizationStateRasterizationOrderAMD
p IO b
f = do
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineRasterizationStateRasterizationOrderAMD
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: Ptr StructureType)) (StructureType
STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD)
    forall a. Storable a => Ptr a -> a -> IO ()
poke ((Ptr PipelineRasterizationStateRasterizationOrderAMD
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 PipelineRasterizationStateRasterizationOrderAMD
p forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: Ptr RasterizationOrderAMD)) (forall a. Zero a => a
zero)
    IO b
f

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

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

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


-- | VkRasterizationOrderAMD - Specify rasterization order for a graphics
-- pipeline
--
-- = See Also
--
-- <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_AMD_rasterization_order VK_AMD_rasterization_order>,
-- 'PipelineRasterizationStateRasterizationOrderAMD'
newtype RasterizationOrderAMD = RasterizationOrderAMD Int32
  deriving newtype (RasterizationOrderAMD -> RasterizationOrderAMD -> Bool
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
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
Ord, Ptr RasterizationOrderAMD -> IO RasterizationOrderAMD
Ptr RasterizationOrderAMD -> Int -> IO RasterizationOrderAMD
Ptr RasterizationOrderAMD -> Int -> RasterizationOrderAMD -> IO ()
Ptr RasterizationOrderAMD -> RasterizationOrderAMD -> IO ()
RasterizationOrderAMD -> Int
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 :: forall b. Ptr b -> Int -> RasterizationOrderAMD -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> RasterizationOrderAMD -> IO ()
peekByteOff :: forall b. 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
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://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#drawing-primitive-order primitive order>.
pattern $bRASTERIZATION_ORDER_STRICT_AMD :: RasterizationOrderAMD
$mRASTERIZATION_ORDER_STRICT_AMD :: forall {r}.
RasterizationOrderAMD -> ((# #) -> r) -> ((# #) -> 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://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#drawing-primitive-order primitive order>.
pattern $bRASTERIZATION_ORDER_RELAXED_AMD :: RasterizationOrderAMD
$mRASTERIZATION_ORDER_RELAXED_AMD :: forall {r}.
RasterizationOrderAMD -> ((# #) -> r) -> ((# #) -> r) -> r
RASTERIZATION_ORDER_RELAXED_AMD = RasterizationOrderAMD 1

{-# COMPLETE
  RASTERIZATION_ORDER_STRICT_AMD
  , RASTERIZATION_ORDER_RELAXED_AMD ::
    RasterizationOrderAMD
  #-}

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

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

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

instance Show RasterizationOrderAMD where
  showsPrec :: Int -> RasterizationOrderAMD -> ShowS
showsPrec =
    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 Int32
x) -> Int32
x)
      (forall a. Show a => Int -> a -> ShowS
showsPrec Int
11)

instance Read RasterizationOrderAMD where
  readPrec :: ReadPrec RasterizationOrderAMD
readPrec =
    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 :: forall a. Integral a => a
$mAMD_RASTERIZATION_ORDER_SPEC_VERSION :: forall {r} {a}.
Integral a =>
a -> ((# #) -> r) -> ((# #) -> 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 :: forall a. (Eq a, IsString a) => a
$mAMD_RASTERIZATION_ORDER_EXTENSION_NAME :: forall {r} {a}.
(Eq a, IsString a) =>
a -> ((# #) -> r) -> ((# #) -> r) -> r
AMD_RASTERIZATION_ORDER_EXTENSION_NAME = "VK_AMD_rasterization_order"