{-# OPTIONS_HADDOCK ignore-exports#-}
{-# LANGUAGE DataKinds                  #-}
{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE KindSignatures             #-}
{-# LANGUAGE PatternSynonyms            #-}
{-# LANGUAGE StandaloneDeriving         #-}
{-# LANGUAGE Strict                     #-}
{-# LANGUAGE TypeSynonymInstances       #-}
module Graphics.Vulkan.Types.Enum.IndirectCommands
       (VkIndirectCommandsLayoutUsageBitmaskNVX(VkIndirectCommandsLayoutUsageBitmaskNVX,
                                                VkIndirectCommandsLayoutUsageFlagsNVX,
                                                VkIndirectCommandsLayoutUsageFlagBitsNVX,
                                                VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX,
                                                VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX,
                                                VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX,
                                                VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX),
        VkIndirectCommandsLayoutUsageFlagsNVX,
        VkIndirectCommandsLayoutUsageFlagBitsNVX,
        VkIndirectCommandsTokenTypeNVX(VkIndirectCommandsTokenTypeNVX,
                                       VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
                                       VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX,
                                       VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX,
                                       VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX,
                                       VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX,
                                       VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX,
                                       VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX,
                                       VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX))
       where
import           Data.Bits                       (Bits, FiniteBits)
import           Data.Data                       (Data)
import           Foreign.Storable                (Storable)
import           GHC.Generics                    (Generic)
import           GHC.Read                        (choose, expectP)
import           Graphics.Vulkan.Marshal         (FlagBit, FlagMask, FlagType,
                                                  Int32)
import           Graphics.Vulkan.Types.BaseTypes (VkFlags (..))
import           Text.ParserCombinators.ReadPrec (prec, step, (+++))
import           Text.Read                       (Read (..), parens)
import           Text.Read.Lex                   (Lexeme (..))

newtype VkIndirectCommandsLayoutUsageBitmaskNVX (a ::
                                                   FlagType) = VkIndirectCommandsLayoutUsageBitmaskNVX VkFlags
                                                                 deriving (VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
(VkIndirectCommandsLayoutUsageBitmaskNVX a
 -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool)
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool)
-> Eq (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
/= :: VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
$c/= :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
== :: VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
$c== :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
Eq, Eq (VkIndirectCommandsLayoutUsageBitmaskNVX a)
Eq (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Ordering)
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool)
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool)
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool)
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool)
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> Ord (VkIndirectCommandsLayoutUsageBitmaskNVX a)
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Ordering
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
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
forall (a :: FlagType).
Eq (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Ordering
forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
min :: VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
$cmin :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
max :: VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
$cmax :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
>= :: VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
$c>= :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
> :: VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
$c> :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
<= :: VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
$c<= :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
< :: VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
$c< :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Bool
compare :: VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Ordering
$ccompare :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> Ordering
$cp1Ord :: forall (a :: FlagType).
Eq (VkIndirectCommandsLayoutUsageBitmaskNVX a)
Ord, Ptr b -> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
Ptr b -> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
VkIndirectCommandsLayoutUsageBitmaskNVX a -> Int
(VkIndirectCommandsLayoutUsageBitmaskNVX a -> Int)
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a -> Int)
-> (Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
    -> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a))
-> (Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
    -> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ())
-> (forall b.
    Ptr b -> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a))
-> (forall b.
    Ptr b -> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ())
-> (Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
    -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a))
-> (Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ())
-> Storable (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall b.
Ptr b -> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall b.
Ptr b -> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> 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
forall (a :: FlagType).
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (a :: FlagType).
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (a :: FlagType).
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
forall (a :: FlagType).
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a -> Int
forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (a :: FlagType) b.
Ptr b -> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
poke :: Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
$cpoke :: forall (a :: FlagType).
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
peek :: Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
$cpeek :: forall (a :: FlagType).
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
pokeByteOff :: Ptr b -> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
$cpokeByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
peekByteOff :: Ptr b -> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
$cpeekByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
pokeElemOff :: Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
$cpokeElemOff :: forall (a :: FlagType).
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> IO ()
peekElemOff :: Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
$cpeekElemOff :: forall (a :: FlagType).
Ptr (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> Int -> IO (VkIndirectCommandsLayoutUsageBitmaskNVX a)
alignment :: VkIndirectCommandsLayoutUsageBitmaskNVX a -> Int
$calignment :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a -> Int
sizeOf :: VkIndirectCommandsLayoutUsageBitmaskNVX a -> Int
$csizeOf :: forall (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a -> Int
Storable, Typeable (VkIndirectCommandsLayoutUsageBitmaskNVX a)
DataType
Constr
Typeable (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> c (VkIndirectCommandsLayoutUsageBitmaskNVX a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (VkIndirectCommandsLayoutUsageBitmaskNVX a))
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a -> Constr)
-> (VkIndirectCommandsLayoutUsageBitmaskNVX a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (VkIndirectCommandsLayoutUsageBitmaskNVX a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VkIndirectCommandsLayoutUsageBitmaskNVX a)))
-> ((forall b. Data b => b -> b)
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> m (VkIndirectCommandsLayoutUsageBitmaskNVX a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> m (VkIndirectCommandsLayoutUsageBitmaskNVX a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a
    -> m (VkIndirectCommandsLayoutUsageBitmaskNVX a))
-> Data (VkIndirectCommandsLayoutUsageBitmaskNVX a)
VkIndirectCommandsLayoutUsageBitmaskNVX a -> DataType
VkIndirectCommandsLayoutUsageBitmaskNVX a -> Constr
(forall b. Data b => b -> b)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> c (VkIndirectCommandsLayoutUsageBitmaskNVX a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> u
forall u.
(forall d. Data d => d -> u)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> r
forall (a :: FlagType).
Typeable a =>
Typeable (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (a :: FlagType).
Typeable a =>
VkIndirectCommandsLayoutUsageBitmaskNVX a -> DataType
forall (a :: FlagType).
Typeable a =>
VkIndirectCommandsLayoutUsageBitmaskNVX a -> Constr
forall (a :: FlagType).
Typeable a =>
(forall b. Data b => b -> b)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
forall (a :: FlagType) u.
Typeable a =>
Int
-> (forall d. Data d => d -> u)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> u
forall (a :: FlagType) u.
Typeable a =>
(forall d. Data d => d -> u)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> [u]
forall (a :: FlagType) r r'.
Typeable a =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> r
forall (a :: FlagType) r r'.
Typeable a =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> r
forall (a :: FlagType) (m :: * -> *).
(Typeable a, Monad m) =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> m (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> m (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> c (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (a :: FlagType) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (VkIndirectCommandsLayoutUsageBitmaskNVX a))
forall (a :: FlagType) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkIndirectCommandsLayoutUsageBitmaskNVX a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> m (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> m (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> c (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (VkIndirectCommandsLayoutUsageBitmaskNVX a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkIndirectCommandsLayoutUsageBitmaskNVX a))
$cVkIndirectCommandsLayoutUsageBitmaskNVX :: Constr
$tVkIndirectCommandsLayoutUsageBitmaskNVX :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> m (VkIndirectCommandsLayoutUsageBitmaskNVX a)
$cgmapMo :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> m (VkIndirectCommandsLayoutUsageBitmaskNVX a)
gmapMp :: (forall d. Data d => d -> m d)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> m (VkIndirectCommandsLayoutUsageBitmaskNVX a)
$cgmapMp :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> m (VkIndirectCommandsLayoutUsageBitmaskNVX a)
gmapM :: (forall d. Data d => d -> m d)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> m (VkIndirectCommandsLayoutUsageBitmaskNVX a)
$cgmapM :: forall (a :: FlagType) (m :: * -> *).
(Typeable a, Monad m) =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> m (VkIndirectCommandsLayoutUsageBitmaskNVX a)
gmapQi :: Int
-> (forall d. Data d => d -> u)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> u
$cgmapQi :: forall (a :: FlagType) u.
Typeable a =>
Int
-> (forall d. Data d => d -> u)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> u
gmapQ :: (forall d. Data d => d -> u)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> [u]
$cgmapQ :: forall (a :: FlagType) u.
Typeable a =>
(forall d. Data d => d -> u)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> r
$cgmapQr :: forall (a :: FlagType) r r'.
Typeable a =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> r
$cgmapQl :: forall (a :: FlagType) r r'.
Typeable a =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> r
gmapT :: (forall b. Data b => b -> b)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
$cgmapT :: forall (a :: FlagType).
Typeable a =>
(forall b. Data b => b -> b)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkIndirectCommandsLayoutUsageBitmaskNVX a))
$cdataCast2 :: forall (a :: FlagType) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (VkIndirectCommandsLayoutUsageBitmaskNVX a))
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c (VkIndirectCommandsLayoutUsageBitmaskNVX a))
$cdataCast1 :: forall (a :: FlagType) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (VkIndirectCommandsLayoutUsageBitmaskNVX a))
dataTypeOf :: VkIndirectCommandsLayoutUsageBitmaskNVX a -> DataType
$cdataTypeOf :: forall (a :: FlagType).
Typeable a =>
VkIndirectCommandsLayoutUsageBitmaskNVX a -> DataType
toConstr :: VkIndirectCommandsLayoutUsageBitmaskNVX a -> Constr
$ctoConstr :: forall (a :: FlagType).
Typeable a =>
VkIndirectCommandsLayoutUsageBitmaskNVX a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkIndirectCommandsLayoutUsageBitmaskNVX a)
$cgunfold :: forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (VkIndirectCommandsLayoutUsageBitmaskNVX a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> c (VkIndirectCommandsLayoutUsageBitmaskNVX a)
$cgfoldl :: forall (a :: FlagType) (c :: * -> *).
Typeable a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
-> c (VkIndirectCommandsLayoutUsageBitmaskNVX a)
$cp1Data :: forall (a :: FlagType).
Typeable a =>
Typeable (VkIndirectCommandsLayoutUsageBitmaskNVX a)
Data,
                                                                           (forall x.
 VkIndirectCommandsLayoutUsageBitmaskNVX a
 -> Rep (VkIndirectCommandsLayoutUsageBitmaskNVX a) x)
-> (forall x.
    Rep (VkIndirectCommandsLayoutUsageBitmaskNVX a) x
    -> VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> Generic (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall x.
Rep (VkIndirectCommandsLayoutUsageBitmaskNVX a) x
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
forall x.
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> Rep (VkIndirectCommandsLayoutUsageBitmaskNVX a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (a :: FlagType) x.
Rep (VkIndirectCommandsLayoutUsageBitmaskNVX a) x
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
forall (a :: FlagType) x.
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> Rep (VkIndirectCommandsLayoutUsageBitmaskNVX a) x
$cto :: forall (a :: FlagType) x.
Rep (VkIndirectCommandsLayoutUsageBitmaskNVX a) x
-> VkIndirectCommandsLayoutUsageBitmaskNVX a
$cfrom :: forall (a :: FlagType) x.
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> Rep (VkIndirectCommandsLayoutUsageBitmaskNVX a) x
Generic)

type VkIndirectCommandsLayoutUsageFlagsNVX =
     VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask

type VkIndirectCommandsLayoutUsageFlagBitsNVX =
     VkIndirectCommandsLayoutUsageBitmaskNVX FlagBit

pattern VkIndirectCommandsLayoutUsageFlagBitsNVX ::
        VkFlags -> VkIndirectCommandsLayoutUsageBitmaskNVX FlagBit

pattern $bVkIndirectCommandsLayoutUsageFlagBitsNVX :: VkFlags -> VkIndirectCommandsLayoutUsageBitmaskNVX FlagBit
$mVkIndirectCommandsLayoutUsageFlagBitsNVX :: forall r.
VkIndirectCommandsLayoutUsageBitmaskNVX FlagBit
-> (VkFlags -> r) -> (Void# -> r) -> r
VkIndirectCommandsLayoutUsageFlagBitsNVX n =
        VkIndirectCommandsLayoutUsageBitmaskNVX n

pattern VkIndirectCommandsLayoutUsageFlagsNVX ::
        VkFlags -> VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask

pattern $bVkIndirectCommandsLayoutUsageFlagsNVX :: VkFlags -> VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask
$mVkIndirectCommandsLayoutUsageFlagsNVX :: forall r.
VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask
-> (VkFlags -> r) -> (Void# -> r) -> r
VkIndirectCommandsLayoutUsageFlagsNVX n =
        VkIndirectCommandsLayoutUsageBitmaskNVX n

deriving instance
         Bits (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask)

deriving instance
         FiniteBits (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask)

deriving instance
         Integral (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask)

deriving instance
         Num (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask)

deriving instance
         Bounded (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask)

deriving instance
         Enum (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask)

deriving instance
         Real (VkIndirectCommandsLayoutUsageBitmaskNVX FlagMask)

instance Show (VkIndirectCommandsLayoutUsageBitmaskNVX a) where
        showsPrec :: Int -> VkIndirectCommandsLayoutUsageBitmaskNVX a -> ShowS
showsPrec Int
_
          VkIndirectCommandsLayoutUsageBitmaskNVX a
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX
          = String -> ShowS
showString
              String
"VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX"
        showsPrec Int
_
          VkIndirectCommandsLayoutUsageBitmaskNVX a
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX
          = String -> ShowS
showString
              String
"VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX"
        showsPrec Int
_
          VkIndirectCommandsLayoutUsageBitmaskNVX a
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX
          = String -> ShowS
showString
              String
"VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX"
        showsPrec Int
_
          VkIndirectCommandsLayoutUsageBitmaskNVX a
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
          = String -> ShowS
showString
              String
"VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX"
        showsPrec Int
p (VkIndirectCommandsLayoutUsageBitmaskNVX VkFlags
x)
          = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
              (String -> ShowS
showString String
"VkIndirectCommandsLayoutUsageBitmaskNVX " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                 Int -> VkFlags -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 VkFlags
x)

instance Read (VkIndirectCommandsLayoutUsageBitmaskNVX a) where
        readPrec :: ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
readPrec
          = ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall a. ReadPrec a -> ReadPrec a
parens
              ([(String, ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a))]
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
                 [(String
"VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX",
                   VkIndirectCommandsLayoutUsageBitmaskNVX a
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure
                     VkIndirectCommandsLayoutUsageBitmaskNVX a
forall (a :: FlagType). VkIndirectCommandsLayoutUsageBitmaskNVX a
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX),
                  (String
"VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX",
                   VkIndirectCommandsLayoutUsageBitmaskNVX a
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsLayoutUsageBitmaskNVX a
forall (a :: FlagType). VkIndirectCommandsLayoutUsageBitmaskNVX a
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX),
                  (String
"VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX",
                   VkIndirectCommandsLayoutUsageBitmaskNVX a
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsLayoutUsageBitmaskNVX a
forall (a :: FlagType). VkIndirectCommandsLayoutUsageBitmaskNVX a
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX),
                  (String
"VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX",
                   VkIndirectCommandsLayoutUsageBitmaskNVX a
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsLayoutUsageBitmaskNVX a
forall (a :: FlagType). VkIndirectCommandsLayoutUsageBitmaskNVX a
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX)]
                 ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
                 Int
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
                   (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkIndirectCommandsLayoutUsageBitmaskNVX") ReadPrec ()
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                      (VkFlags -> VkIndirectCommandsLayoutUsageBitmaskNVX a
forall (a :: FlagType).
VkFlags -> VkIndirectCommandsLayoutUsageBitmaskNVX a
VkIndirectCommandsLayoutUsageBitmaskNVX (VkFlags -> VkIndirectCommandsLayoutUsageBitmaskNVX a)
-> ReadPrec VkFlags
-> ReadPrec (VkIndirectCommandsLayoutUsageBitmaskNVX a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadPrec VkFlags -> ReadPrec VkFlags
forall a. ReadPrec a -> ReadPrec a
step ReadPrec VkFlags
forall a. Read a => ReadPrec a
readPrec)))

-- | bitpos = @0@
pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX
        :: VkIndirectCommandsLayoutUsageBitmaskNVX a

pattern $bVK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX :: VkIndirectCommandsLayoutUsageBitmaskNVX a
$mVK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX :: forall r (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX
        = VkIndirectCommandsLayoutUsageBitmaskNVX 1

-- | bitpos = @1@
pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX
        :: VkIndirectCommandsLayoutUsageBitmaskNVX a

pattern $bVK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX :: VkIndirectCommandsLayoutUsageBitmaskNVX a
$mVK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX :: forall r (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX
        = VkIndirectCommandsLayoutUsageBitmaskNVX 2

-- | bitpos = @2@
pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX
        :: VkIndirectCommandsLayoutUsageBitmaskNVX a

pattern $bVK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX :: VkIndirectCommandsLayoutUsageBitmaskNVX a
$mVK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX :: forall r (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX
        = VkIndirectCommandsLayoutUsageBitmaskNVX 4

-- | bitpos = @3@
pattern VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
        :: VkIndirectCommandsLayoutUsageBitmaskNVX a

pattern $bVK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX :: VkIndirectCommandsLayoutUsageBitmaskNVX a
$mVK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX :: forall r (a :: FlagType).
VkIndirectCommandsLayoutUsageBitmaskNVX a
-> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
        = VkIndirectCommandsLayoutUsageBitmaskNVX 8

-- | type = @enum@
--
--   <https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VkIndirectCommandsTokenTypeNVX VkIndirectCommandsTokenTypeNVX registry at www.khronos.org>
newtype VkIndirectCommandsTokenTypeNVX = VkIndirectCommandsTokenTypeNVX Int32
                                           deriving (VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
(VkIndirectCommandsTokenTypeNVX
 -> VkIndirectCommandsTokenTypeNVX -> Bool)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX -> Bool)
-> Eq VkIndirectCommandsTokenTypeNVX
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
$c/= :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
== :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
$c== :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
Eq, Eq VkIndirectCommandsTokenTypeNVX
Eq VkIndirectCommandsTokenTypeNVX
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX -> Ordering)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX -> Bool)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX -> Bool)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX -> Bool)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX -> Bool)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX)
-> Ord VkIndirectCommandsTokenTypeNVX
VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Ordering
VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
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 :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$cmin :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
max :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$cmax :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
>= :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
$c>= :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
> :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
$c> :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
<= :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
$c<= :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
< :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
$c< :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Bool
compare :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Ordering
$ccompare :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> Ordering
$cp1Ord :: Eq VkIndirectCommandsTokenTypeNVX
Ord, Integer -> VkIndirectCommandsTokenTypeNVX
VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
(VkIndirectCommandsTokenTypeNVX
 -> VkIndirectCommandsTokenTypeNVX
 -> VkIndirectCommandsTokenTypeNVX)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX)
-> (Integer -> VkIndirectCommandsTokenTypeNVX)
-> Num VkIndirectCommandsTokenTypeNVX
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> VkIndirectCommandsTokenTypeNVX
$cfromInteger :: Integer -> VkIndirectCommandsTokenTypeNVX
signum :: VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$csignum :: VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
abs :: VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$cabs :: VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
negate :: VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$cnegate :: VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
* :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$c* :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
- :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$c- :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
+ :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$c+ :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
Num, VkIndirectCommandsTokenTypeNVX
VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> Bounded VkIndirectCommandsTokenTypeNVX
forall a. a -> a -> Bounded a
maxBound :: VkIndirectCommandsTokenTypeNVX
$cmaxBound :: VkIndirectCommandsTokenTypeNVX
minBound :: VkIndirectCommandsTokenTypeNVX
$cminBound :: VkIndirectCommandsTokenTypeNVX
Bounded, Ptr b -> Int -> IO VkIndirectCommandsTokenTypeNVX
Ptr b -> Int -> VkIndirectCommandsTokenTypeNVX -> IO ()
Ptr VkIndirectCommandsTokenTypeNVX
-> IO VkIndirectCommandsTokenTypeNVX
Ptr VkIndirectCommandsTokenTypeNVX
-> Int -> IO VkIndirectCommandsTokenTypeNVX
Ptr VkIndirectCommandsTokenTypeNVX
-> Int -> VkIndirectCommandsTokenTypeNVX -> IO ()
Ptr VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> IO ()
VkIndirectCommandsTokenTypeNVX -> Int
(VkIndirectCommandsTokenTypeNVX -> Int)
-> (VkIndirectCommandsTokenTypeNVX -> Int)
-> (Ptr VkIndirectCommandsTokenTypeNVX
    -> Int -> IO VkIndirectCommandsTokenTypeNVX)
-> (Ptr VkIndirectCommandsTokenTypeNVX
    -> Int -> VkIndirectCommandsTokenTypeNVX -> IO ())
-> (forall b. Ptr b -> Int -> IO VkIndirectCommandsTokenTypeNVX)
-> (forall b.
    Ptr b -> Int -> VkIndirectCommandsTokenTypeNVX -> IO ())
-> (Ptr VkIndirectCommandsTokenTypeNVX
    -> IO VkIndirectCommandsTokenTypeNVX)
-> (Ptr VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX -> IO ())
-> Storable VkIndirectCommandsTokenTypeNVX
forall b. Ptr b -> Int -> IO VkIndirectCommandsTokenTypeNVX
forall b. Ptr b -> Int -> VkIndirectCommandsTokenTypeNVX -> 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 VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> IO ()
$cpoke :: Ptr VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX -> IO ()
peek :: Ptr VkIndirectCommandsTokenTypeNVX
-> IO VkIndirectCommandsTokenTypeNVX
$cpeek :: Ptr VkIndirectCommandsTokenTypeNVX
-> IO VkIndirectCommandsTokenTypeNVX
pokeByteOff :: Ptr b -> Int -> VkIndirectCommandsTokenTypeNVX -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkIndirectCommandsTokenTypeNVX -> IO ()
peekByteOff :: Ptr b -> Int -> IO VkIndirectCommandsTokenTypeNVX
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkIndirectCommandsTokenTypeNVX
pokeElemOff :: Ptr VkIndirectCommandsTokenTypeNVX
-> Int -> VkIndirectCommandsTokenTypeNVX -> IO ()
$cpokeElemOff :: Ptr VkIndirectCommandsTokenTypeNVX
-> Int -> VkIndirectCommandsTokenTypeNVX -> IO ()
peekElemOff :: Ptr VkIndirectCommandsTokenTypeNVX
-> Int -> IO VkIndirectCommandsTokenTypeNVX
$cpeekElemOff :: Ptr VkIndirectCommandsTokenTypeNVX
-> Int -> IO VkIndirectCommandsTokenTypeNVX
alignment :: VkIndirectCommandsTokenTypeNVX -> Int
$calignment :: VkIndirectCommandsTokenTypeNVX -> Int
sizeOf :: VkIndirectCommandsTokenTypeNVX -> Int
$csizeOf :: VkIndirectCommandsTokenTypeNVX -> Int
Storable, Int -> VkIndirectCommandsTokenTypeNVX
VkIndirectCommandsTokenTypeNVX -> Int
VkIndirectCommandsTokenTypeNVX -> [VkIndirectCommandsTokenTypeNVX]
VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> [VkIndirectCommandsTokenTypeNVX]
VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> [VkIndirectCommandsTokenTypeNVX]
(VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX)
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX)
-> (Int -> VkIndirectCommandsTokenTypeNVX)
-> (VkIndirectCommandsTokenTypeNVX -> Int)
-> (VkIndirectCommandsTokenTypeNVX
    -> [VkIndirectCommandsTokenTypeNVX])
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX
    -> [VkIndirectCommandsTokenTypeNVX])
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX
    -> [VkIndirectCommandsTokenTypeNVX])
-> (VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX
    -> [VkIndirectCommandsTokenTypeNVX])
-> Enum VkIndirectCommandsTokenTypeNVX
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> [VkIndirectCommandsTokenTypeNVX]
$cenumFromThenTo :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> [VkIndirectCommandsTokenTypeNVX]
enumFromTo :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> [VkIndirectCommandsTokenTypeNVX]
$cenumFromTo :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> [VkIndirectCommandsTokenTypeNVX]
enumFromThen :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> [VkIndirectCommandsTokenTypeNVX]
$cenumFromThen :: VkIndirectCommandsTokenTypeNVX
-> VkIndirectCommandsTokenTypeNVX
-> [VkIndirectCommandsTokenTypeNVX]
enumFrom :: VkIndirectCommandsTokenTypeNVX -> [VkIndirectCommandsTokenTypeNVX]
$cenumFrom :: VkIndirectCommandsTokenTypeNVX -> [VkIndirectCommandsTokenTypeNVX]
fromEnum :: VkIndirectCommandsTokenTypeNVX -> Int
$cfromEnum :: VkIndirectCommandsTokenTypeNVX -> Int
toEnum :: Int -> VkIndirectCommandsTokenTypeNVX
$ctoEnum :: Int -> VkIndirectCommandsTokenTypeNVX
pred :: VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$cpred :: VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
succ :: VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$csucc :: VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
Enum, Typeable VkIndirectCommandsTokenTypeNVX
DataType
Constr
Typeable VkIndirectCommandsTokenTypeNVX
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> VkIndirectCommandsTokenTypeNVX
    -> c VkIndirectCommandsTokenTypeNVX)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c VkIndirectCommandsTokenTypeNVX)
-> (VkIndirectCommandsTokenTypeNVX -> Constr)
-> (VkIndirectCommandsTokenTypeNVX -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c VkIndirectCommandsTokenTypeNVX))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c VkIndirectCommandsTokenTypeNVX))
-> ((forall b. Data b => b -> b)
    -> VkIndirectCommandsTokenTypeNVX
    -> VkIndirectCommandsTokenTypeNVX)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkIndirectCommandsTokenTypeNVX
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> VkIndirectCommandsTokenTypeNVX
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> VkIndirectCommandsTokenTypeNVX -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> VkIndirectCommandsTokenTypeNVX
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> VkIndirectCommandsTokenTypeNVX
    -> m VkIndirectCommandsTokenTypeNVX)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkIndirectCommandsTokenTypeNVX
    -> m VkIndirectCommandsTokenTypeNVX)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> VkIndirectCommandsTokenTypeNVX
    -> m VkIndirectCommandsTokenTypeNVX)
-> Data VkIndirectCommandsTokenTypeNVX
VkIndirectCommandsTokenTypeNVX -> DataType
VkIndirectCommandsTokenTypeNVX -> Constr
(forall b. Data b => b -> b)
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkIndirectCommandsTokenTypeNVX
-> c VkIndirectCommandsTokenTypeNVX
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c VkIndirectCommandsTokenTypeNVX
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u)
-> VkIndirectCommandsTokenTypeNVX
-> u
forall u.
(forall d. Data d => d -> u)
-> VkIndirectCommandsTokenTypeNVX -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsTokenTypeNVX
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsTokenTypeNVX
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsTokenTypeNVX
-> m VkIndirectCommandsTokenTypeNVX
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsTokenTypeNVX
-> m VkIndirectCommandsTokenTypeNVX
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c VkIndirectCommandsTokenTypeNVX
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkIndirectCommandsTokenTypeNVX
-> c VkIndirectCommandsTokenTypeNVX
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c VkIndirectCommandsTokenTypeNVX)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkIndirectCommandsTokenTypeNVX)
$cVkIndirectCommandsTokenTypeNVX :: Constr
$tVkIndirectCommandsTokenTypeNVX :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> VkIndirectCommandsTokenTypeNVX
-> m VkIndirectCommandsTokenTypeNVX
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsTokenTypeNVX
-> m VkIndirectCommandsTokenTypeNVX
gmapMp :: (forall d. Data d => d -> m d)
-> VkIndirectCommandsTokenTypeNVX
-> m VkIndirectCommandsTokenTypeNVX
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsTokenTypeNVX
-> m VkIndirectCommandsTokenTypeNVX
gmapM :: (forall d. Data d => d -> m d)
-> VkIndirectCommandsTokenTypeNVX
-> m VkIndirectCommandsTokenTypeNVX
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> VkIndirectCommandsTokenTypeNVX
-> m VkIndirectCommandsTokenTypeNVX
gmapQi :: Int
-> (forall d. Data d => d -> u)
-> VkIndirectCommandsTokenTypeNVX
-> u
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u)
-> VkIndirectCommandsTokenTypeNVX
-> u
gmapQ :: (forall d. Data d => d -> u)
-> VkIndirectCommandsTokenTypeNVX -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u)
-> VkIndirectCommandsTokenTypeNVX -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsTokenTypeNVX
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsTokenTypeNVX
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsTokenTypeNVX
-> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> VkIndirectCommandsTokenTypeNVX
-> r
gmapT :: (forall b. Data b => b -> b)
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
$cgmapT :: (forall b. Data b => b -> b)
-> VkIndirectCommandsTokenTypeNVX -> VkIndirectCommandsTokenTypeNVX
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkIndirectCommandsTokenTypeNVX)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c VkIndirectCommandsTokenTypeNVX)
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c VkIndirectCommandsTokenTypeNVX)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c VkIndirectCommandsTokenTypeNVX)
dataTypeOf :: VkIndirectCommandsTokenTypeNVX -> DataType
$cdataTypeOf :: VkIndirectCommandsTokenTypeNVX -> DataType
toConstr :: VkIndirectCommandsTokenTypeNVX -> Constr
$ctoConstr :: VkIndirectCommandsTokenTypeNVX -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c VkIndirectCommandsTokenTypeNVX
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c VkIndirectCommandsTokenTypeNVX
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkIndirectCommandsTokenTypeNVX
-> c VkIndirectCommandsTokenTypeNVX
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> VkIndirectCommandsTokenTypeNVX
-> c VkIndirectCommandsTokenTypeNVX
$cp1Data :: Typeable VkIndirectCommandsTokenTypeNVX
Data,
                                                     (forall x.
 VkIndirectCommandsTokenTypeNVX
 -> Rep VkIndirectCommandsTokenTypeNVX x)
-> (forall x.
    Rep VkIndirectCommandsTokenTypeNVX x
    -> VkIndirectCommandsTokenTypeNVX)
-> Generic VkIndirectCommandsTokenTypeNVX
forall x.
Rep VkIndirectCommandsTokenTypeNVX x
-> VkIndirectCommandsTokenTypeNVX
forall x.
VkIndirectCommandsTokenTypeNVX
-> Rep VkIndirectCommandsTokenTypeNVX x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep VkIndirectCommandsTokenTypeNVX x
-> VkIndirectCommandsTokenTypeNVX
$cfrom :: forall x.
VkIndirectCommandsTokenTypeNVX
-> Rep VkIndirectCommandsTokenTypeNVX x
Generic)

instance Show VkIndirectCommandsTokenTypeNVX where
        showsPrec :: Int -> VkIndirectCommandsTokenTypeNVX -> ShowS
showsPrec Int
_ VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX
          = String -> ShowS
showString String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX"
        showsPrec Int
_ VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX
          = String -> ShowS
showString String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX"
        showsPrec Int
_ VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX
          = String -> ShowS
showString String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX"
        showsPrec Int
_ VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX
          = String -> ShowS
showString String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX"
        showsPrec Int
_ VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX
          = String -> ShowS
showString String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX"
        showsPrec Int
_ VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX
          = String -> ShowS
showString String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX"
        showsPrec Int
_ VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX
          = String -> ShowS
showString String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX"
        showsPrec Int
_ VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX
          = String -> ShowS
showString String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX"
        showsPrec Int
p (VkIndirectCommandsTokenTypeNVX Int32
x)
          = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
              (String -> ShowS
showString String
"VkIndirectCommandsTokenTypeNVX " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int32 -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
11 Int32
x)

instance Read VkIndirectCommandsTokenTypeNVX where
        readPrec :: ReadPrec VkIndirectCommandsTokenTypeNVX
readPrec
          = ReadPrec VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall a. ReadPrec a -> ReadPrec a
parens
              ([(String, ReadPrec VkIndirectCommandsTokenTypeNVX)]
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
                 [(String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX",
                   VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX),
                  (String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX",
                   VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX),
                  (String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX",
                   VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX),
                  (String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX",
                   VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX),
                  (String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX",
                   VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX),
                  (String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX",
                   VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX),
                  (String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX",
                   VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX),
                  (String
"VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX",
                   VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkIndirectCommandsTokenTypeNVX
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX)]
                 ReadPrec VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
                 Int
-> ReadPrec VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
                   (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkIndirectCommandsTokenTypeNVX") ReadPrec ()
-> ReadPrec VkIndirectCommandsTokenTypeNVX
-> ReadPrec VkIndirectCommandsTokenTypeNVX
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                      (Int32 -> VkIndirectCommandsTokenTypeNVX
VkIndirectCommandsTokenTypeNVX (Int32 -> VkIndirectCommandsTokenTypeNVX)
-> ReadPrec Int32 -> ReadPrec VkIndirectCommandsTokenTypeNVX
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadPrec Int32 -> ReadPrec Int32
forall a. ReadPrec a -> ReadPrec a
step ReadPrec Int32
forall a. Read a => ReadPrec a
readPrec)))

pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX ::
        VkIndirectCommandsTokenTypeNVX

pattern $bVK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX :: VkIndirectCommandsTokenTypeNVX
$mVK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX :: forall r.
VkIndirectCommandsTokenTypeNVX -> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX =
        VkIndirectCommandsTokenTypeNVX 0

pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX ::
        VkIndirectCommandsTokenTypeNVX

pattern $bVK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX :: VkIndirectCommandsTokenTypeNVX
$mVK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX :: forall r.
VkIndirectCommandsTokenTypeNVX -> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX =
        VkIndirectCommandsTokenTypeNVX 1

pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX ::
        VkIndirectCommandsTokenTypeNVX

pattern $bVK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX :: VkIndirectCommandsTokenTypeNVX
$mVK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX :: forall r.
VkIndirectCommandsTokenTypeNVX -> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX =
        VkIndirectCommandsTokenTypeNVX 2

pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX ::
        VkIndirectCommandsTokenTypeNVX

pattern $bVK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX :: VkIndirectCommandsTokenTypeNVX
$mVK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX :: forall r.
VkIndirectCommandsTokenTypeNVX -> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX =
        VkIndirectCommandsTokenTypeNVX 3

pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX ::
        VkIndirectCommandsTokenTypeNVX

pattern $bVK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX :: VkIndirectCommandsTokenTypeNVX
$mVK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX :: forall r.
VkIndirectCommandsTokenTypeNVX -> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX =
        VkIndirectCommandsTokenTypeNVX 4

pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX ::
        VkIndirectCommandsTokenTypeNVX

pattern $bVK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX :: VkIndirectCommandsTokenTypeNVX
$mVK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX :: forall r.
VkIndirectCommandsTokenTypeNVX -> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX =
        VkIndirectCommandsTokenTypeNVX 5

pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX ::
        VkIndirectCommandsTokenTypeNVX

pattern $bVK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX :: VkIndirectCommandsTokenTypeNVX
$mVK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX :: forall r.
VkIndirectCommandsTokenTypeNVX -> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX =
        VkIndirectCommandsTokenTypeNVX 6

pattern VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX ::
        VkIndirectCommandsTokenTypeNVX

pattern $bVK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX :: VkIndirectCommandsTokenTypeNVX
$mVK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX :: forall r.
VkIndirectCommandsTokenTypeNVX -> (Void# -> r) -> (Void# -> r) -> r
VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX =
        VkIndirectCommandsTokenTypeNVX 7