{-# OPTIONS_HADDOCK ignore-exports#-}
{-# LANGUAGE DataKinds                  #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE KindSignatures             #-}
{-# LANGUAGE PatternSynonyms            #-}
{-# LANGUAGE StandaloneDeriving         #-}
{-# LANGUAGE Strict                     #-}
{-# LANGUAGE TypeSynonymInstances       #-}
module Graphics.Vulkan.Types.Enum.Command
       (VkCommandBufferLevel(VkCommandBufferLevel,
                             VK_COMMAND_BUFFER_LEVEL_PRIMARY,
                             VK_COMMAND_BUFFER_LEVEL_SECONDARY),
        VkCommandBufferResetBitmask(VkCommandBufferResetBitmask,
                                    VkCommandBufferResetFlags, VkCommandBufferResetFlagBits,
                                    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT),
        VkCommandBufferResetFlags, VkCommandBufferResetFlagBits,
        VkCommandBufferUsageBitmask(VkCommandBufferUsageBitmask,
                                    VkCommandBufferUsageFlags, VkCommandBufferUsageFlagBits,
                                    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
                                    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
                                    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT),
        VkCommandBufferUsageFlags, VkCommandBufferUsageFlagBits,
        VkCommandPoolCreateBitmask(VkCommandPoolCreateBitmask,
                                   VkCommandPoolCreateFlags, VkCommandPoolCreateFlagBits,
                                   VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
                                   VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT),
        VkCommandPoolCreateFlags, VkCommandPoolCreateFlagBits,
        VkCommandPoolResetBitmask(VkCommandPoolResetBitmask,
                                  VkCommandPoolResetFlags, VkCommandPoolResetFlagBits,
                                  VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT),
        VkCommandPoolResetFlags, VkCommandPoolResetFlagBits)
       where
import Data.Bits                       (Bits, FiniteBits)
import Foreign.Storable                (Storable)
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 (..))

-- | type = @enum@
--
--   <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VkCommandBufferLevel VkCommandBufferLevel registry at www.khronos.org>
newtype VkCommandBufferLevel = VkCommandBufferLevel Int32
                               deriving (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
(VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> Eq VkCommandBufferLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c/= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
== :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c== :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
Eq, Eq VkCommandBufferLevel
Eq VkCommandBufferLevel
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Ordering)
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> (VkCommandBufferLevel -> VkCommandBufferLevel -> Bool)
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel -> VkCommandBufferLevel)
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel -> VkCommandBufferLevel)
-> Ord VkCommandBufferLevel
VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
VkCommandBufferLevel -> VkCommandBufferLevel -> Ordering
VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
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 :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
$cmin :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
max :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
$cmax :: VkCommandBufferLevel
-> VkCommandBufferLevel -> VkCommandBufferLevel
>= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c>= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
> :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c> :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
<= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c<= :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
< :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
$c< :: VkCommandBufferLevel -> VkCommandBufferLevel -> Bool
compare :: VkCommandBufferLevel -> VkCommandBufferLevel -> Ordering
$ccompare :: VkCommandBufferLevel -> VkCommandBufferLevel -> Ordering
Ord, Int -> VkCommandBufferLevel
VkCommandBufferLevel -> Int
VkCommandBufferLevel -> [VkCommandBufferLevel]
VkCommandBufferLevel -> VkCommandBufferLevel
VkCommandBufferLevel
-> VkCommandBufferLevel -> [VkCommandBufferLevel]
VkCommandBufferLevel
-> VkCommandBufferLevel
-> VkCommandBufferLevel
-> [VkCommandBufferLevel]
(VkCommandBufferLevel -> VkCommandBufferLevel)
-> (VkCommandBufferLevel -> VkCommandBufferLevel)
-> (Int -> VkCommandBufferLevel)
-> (VkCommandBufferLevel -> Int)
-> (VkCommandBufferLevel -> [VkCommandBufferLevel])
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel -> [VkCommandBufferLevel])
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel -> [VkCommandBufferLevel])
-> (VkCommandBufferLevel
    -> VkCommandBufferLevel
    -> VkCommandBufferLevel
    -> [VkCommandBufferLevel])
-> Enum VkCommandBufferLevel
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 :: VkCommandBufferLevel
-> VkCommandBufferLevel
-> VkCommandBufferLevel
-> [VkCommandBufferLevel]
$cenumFromThenTo :: VkCommandBufferLevel
-> VkCommandBufferLevel
-> VkCommandBufferLevel
-> [VkCommandBufferLevel]
enumFromTo :: VkCommandBufferLevel
-> VkCommandBufferLevel -> [VkCommandBufferLevel]
$cenumFromTo :: VkCommandBufferLevel
-> VkCommandBufferLevel -> [VkCommandBufferLevel]
enumFromThen :: VkCommandBufferLevel
-> VkCommandBufferLevel -> [VkCommandBufferLevel]
$cenumFromThen :: VkCommandBufferLevel
-> VkCommandBufferLevel -> [VkCommandBufferLevel]
enumFrom :: VkCommandBufferLevel -> [VkCommandBufferLevel]
$cenumFrom :: VkCommandBufferLevel -> [VkCommandBufferLevel]
fromEnum :: VkCommandBufferLevel -> Int
$cfromEnum :: VkCommandBufferLevel -> Int
toEnum :: Int -> VkCommandBufferLevel
$ctoEnum :: Int -> VkCommandBufferLevel
pred :: VkCommandBufferLevel -> VkCommandBufferLevel
$cpred :: VkCommandBufferLevel -> VkCommandBufferLevel
succ :: VkCommandBufferLevel -> VkCommandBufferLevel
$csucc :: VkCommandBufferLevel -> VkCommandBufferLevel
Enum, Ptr VkCommandBufferLevel -> IO VkCommandBufferLevel
Ptr VkCommandBufferLevel -> Int -> IO VkCommandBufferLevel
Ptr VkCommandBufferLevel -> Int -> VkCommandBufferLevel -> IO ()
Ptr VkCommandBufferLevel -> VkCommandBufferLevel -> IO ()
VkCommandBufferLevel -> Int
(VkCommandBufferLevel -> Int)
-> (VkCommandBufferLevel -> Int)
-> (Ptr VkCommandBufferLevel -> Int -> IO VkCommandBufferLevel)
-> (Ptr VkCommandBufferLevel
    -> Int -> VkCommandBufferLevel -> IO ())
-> (forall b. Ptr b -> Int -> IO VkCommandBufferLevel)
-> (forall b. Ptr b -> Int -> VkCommandBufferLevel -> IO ())
-> (Ptr VkCommandBufferLevel -> IO VkCommandBufferLevel)
-> (Ptr VkCommandBufferLevel -> VkCommandBufferLevel -> IO ())
-> Storable VkCommandBufferLevel
forall b. Ptr b -> Int -> IO VkCommandBufferLevel
forall b. Ptr b -> Int -> VkCommandBufferLevel -> 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 VkCommandBufferLevel -> VkCommandBufferLevel -> IO ()
$cpoke :: Ptr VkCommandBufferLevel -> VkCommandBufferLevel -> IO ()
peek :: Ptr VkCommandBufferLevel -> IO VkCommandBufferLevel
$cpeek :: Ptr VkCommandBufferLevel -> IO VkCommandBufferLevel
pokeByteOff :: forall b. Ptr b -> Int -> VkCommandBufferLevel -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> VkCommandBufferLevel -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO VkCommandBufferLevel
$cpeekByteOff :: forall b. Ptr b -> Int -> IO VkCommandBufferLevel
pokeElemOff :: Ptr VkCommandBufferLevel -> Int -> VkCommandBufferLevel -> IO ()
$cpokeElemOff :: Ptr VkCommandBufferLevel -> Int -> VkCommandBufferLevel -> IO ()
peekElemOff :: Ptr VkCommandBufferLevel -> Int -> IO VkCommandBufferLevel
$cpeekElemOff :: Ptr VkCommandBufferLevel -> Int -> IO VkCommandBufferLevel
alignment :: VkCommandBufferLevel -> Int
$calignment :: VkCommandBufferLevel -> Int
sizeOf :: VkCommandBufferLevel -> Int
$csizeOf :: VkCommandBufferLevel -> Int
Storable)

instance Show VkCommandBufferLevel where
    showsPrec :: Int -> VkCommandBufferLevel -> ShowS
showsPrec Int
_ VkCommandBufferLevel
VK_COMMAND_BUFFER_LEVEL_PRIMARY
      = String -> ShowS
showString String
"VK_COMMAND_BUFFER_LEVEL_PRIMARY"
    showsPrec Int
_ VkCommandBufferLevel
VK_COMMAND_BUFFER_LEVEL_SECONDARY
      = String -> ShowS
showString String
"VK_COMMAND_BUFFER_LEVEL_SECONDARY"
    showsPrec Int
p (VkCommandBufferLevel Int32
x)
      = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
          (String -> ShowS
showString String
"VkCommandBufferLevel " 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 VkCommandBufferLevel where
    readPrec :: ReadPrec VkCommandBufferLevel
readPrec
      = ReadPrec VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall a. ReadPrec a -> ReadPrec a
parens
          ([(String, ReadPrec VkCommandBufferLevel)]
-> ReadPrec VkCommandBufferLevel
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
             [(String
"VK_COMMAND_BUFFER_LEVEL_PRIMARY",
               VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferLevel
VK_COMMAND_BUFFER_LEVEL_PRIMARY),
              (String
"VK_COMMAND_BUFFER_LEVEL_SECONDARY",
               VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferLevel
VK_COMMAND_BUFFER_LEVEL_SECONDARY)]
             ReadPrec VkCommandBufferLevel
-> ReadPrec VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
             Int
-> ReadPrec VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
               (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkCommandBufferLevel") ReadPrec ()
-> ReadPrec VkCommandBufferLevel -> ReadPrec VkCommandBufferLevel
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  (Int32 -> VkCommandBufferLevel
VkCommandBufferLevel (Int32 -> VkCommandBufferLevel)
-> ReadPrec Int32 -> ReadPrec VkCommandBufferLevel
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_COMMAND_BUFFER_LEVEL_PRIMARY :: VkCommandBufferLevel

pattern $bVK_COMMAND_BUFFER_LEVEL_PRIMARY :: VkCommandBufferLevel
$mVK_COMMAND_BUFFER_LEVEL_PRIMARY :: forall {r}.
VkCommandBufferLevel -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_LEVEL_PRIMARY = VkCommandBufferLevel 0

pattern VK_COMMAND_BUFFER_LEVEL_SECONDARY :: VkCommandBufferLevel

pattern $bVK_COMMAND_BUFFER_LEVEL_SECONDARY :: VkCommandBufferLevel
$mVK_COMMAND_BUFFER_LEVEL_SECONDARY :: forall {r}.
VkCommandBufferLevel -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_LEVEL_SECONDARY = VkCommandBufferLevel 1

newtype VkCommandBufferResetBitmask (a ::
                                       FlagType) = VkCommandBufferResetBitmask VkFlags
                                                   deriving (VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
(VkCommandBufferResetBitmask a
 -> VkCommandBufferResetBitmask a -> Bool)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Bool)
-> Eq (VkCommandBufferResetBitmask a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
/= :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c/= :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
== :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c== :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
Eq, Eq (VkCommandBufferResetBitmask a)
Eq (VkCommandBufferResetBitmask a)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Ordering)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Bool)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Bool)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Bool)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> Bool)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a)
-> (VkCommandBufferResetBitmask a
    -> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a)
-> Ord (VkCommandBufferResetBitmask a)
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Ordering
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask 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 (VkCommandBufferResetBitmask a)
forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Ordering
forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
min :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
$cmin :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
max :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
$cmax :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> VkCommandBufferResetBitmask a
>= :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c>= :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
> :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c> :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
<= :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c<= :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
< :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
$c< :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Bool
compare :: VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Ordering
$ccompare :: forall (a :: FlagType).
VkCommandBufferResetBitmask a
-> VkCommandBufferResetBitmask a -> Ordering
Ord, Ptr (VkCommandBufferResetBitmask a)
-> IO (VkCommandBufferResetBitmask a)
Ptr (VkCommandBufferResetBitmask a)
-> Int -> IO (VkCommandBufferResetBitmask a)
Ptr (VkCommandBufferResetBitmask a)
-> Int -> VkCommandBufferResetBitmask a -> IO ()
Ptr (VkCommandBufferResetBitmask a)
-> VkCommandBufferResetBitmask a -> IO ()
VkCommandBufferResetBitmask a -> Int
(VkCommandBufferResetBitmask a -> Int)
-> (VkCommandBufferResetBitmask a -> Int)
-> (Ptr (VkCommandBufferResetBitmask a)
    -> Int -> IO (VkCommandBufferResetBitmask a))
-> (Ptr (VkCommandBufferResetBitmask a)
    -> Int -> VkCommandBufferResetBitmask a -> IO ())
-> (forall b. Ptr b -> Int -> IO (VkCommandBufferResetBitmask a))
-> (forall b.
    Ptr b -> Int -> VkCommandBufferResetBitmask a -> IO ())
-> (Ptr (VkCommandBufferResetBitmask a)
    -> IO (VkCommandBufferResetBitmask a))
-> (Ptr (VkCommandBufferResetBitmask a)
    -> VkCommandBufferResetBitmask a -> IO ())
-> Storable (VkCommandBufferResetBitmask a)
forall b. Ptr b -> Int -> IO (VkCommandBufferResetBitmask a)
forall b. Ptr b -> Int -> VkCommandBufferResetBitmask 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 (VkCommandBufferResetBitmask a)
-> IO (VkCommandBufferResetBitmask a)
forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> Int -> IO (VkCommandBufferResetBitmask a)
forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> Int -> VkCommandBufferResetBitmask a -> IO ()
forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> VkCommandBufferResetBitmask a -> IO ()
forall (a :: FlagType). VkCommandBufferResetBitmask a -> Int
forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandBufferResetBitmask a)
forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandBufferResetBitmask a -> IO ()
poke :: Ptr (VkCommandBufferResetBitmask a)
-> VkCommandBufferResetBitmask a -> IO ()
$cpoke :: forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> VkCommandBufferResetBitmask a -> IO ()
peek :: Ptr (VkCommandBufferResetBitmask a)
-> IO (VkCommandBufferResetBitmask a)
$cpeek :: forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> IO (VkCommandBufferResetBitmask a)
pokeByteOff :: forall b. Ptr b -> Int -> VkCommandBufferResetBitmask a -> IO ()
$cpokeByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandBufferResetBitmask a -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO (VkCommandBufferResetBitmask a)
$cpeekByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandBufferResetBitmask a)
pokeElemOff :: Ptr (VkCommandBufferResetBitmask a)
-> Int -> VkCommandBufferResetBitmask a -> IO ()
$cpokeElemOff :: forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> Int -> VkCommandBufferResetBitmask a -> IO ()
peekElemOff :: Ptr (VkCommandBufferResetBitmask a)
-> Int -> IO (VkCommandBufferResetBitmask a)
$cpeekElemOff :: forall (a :: FlagType).
Ptr (VkCommandBufferResetBitmask a)
-> Int -> IO (VkCommandBufferResetBitmask a)
alignment :: VkCommandBufferResetBitmask a -> Int
$calignment :: forall (a :: FlagType). VkCommandBufferResetBitmask a -> Int
sizeOf :: VkCommandBufferResetBitmask a -> Int
$csizeOf :: forall (a :: FlagType). VkCommandBufferResetBitmask a -> Int
Storable)

type VkCommandBufferResetFlags =
     VkCommandBufferResetBitmask FlagMask

type VkCommandBufferResetFlagBits =
     VkCommandBufferResetBitmask FlagBit

pattern VkCommandBufferResetFlagBits ::
        VkFlags -> VkCommandBufferResetBitmask FlagBit

pattern $bVkCommandBufferResetFlagBits :: VkFlags -> VkCommandBufferResetBitmask FlagBit
$mVkCommandBufferResetFlagBits :: forall {r}.
VkCommandBufferResetBitmask FlagBit
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandBufferResetFlagBits n =
        VkCommandBufferResetBitmask n

pattern VkCommandBufferResetFlags ::
        VkFlags -> VkCommandBufferResetBitmask FlagMask

pattern $bVkCommandBufferResetFlags :: VkFlags -> VkCommandBufferResetBitmask FlagMask
$mVkCommandBufferResetFlags :: forall {r}.
VkCommandBufferResetBitmask FlagMask
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandBufferResetFlags n = VkCommandBufferResetBitmask n

deriving instance Bits (VkCommandBufferResetBitmask FlagMask)

deriving instance FiniteBits (VkCommandBufferResetBitmask FlagMask)

instance Show (VkCommandBufferResetBitmask a) where
    showsPrec :: Int -> VkCommandBufferResetBitmask a -> ShowS
showsPrec Int
_ VkCommandBufferResetBitmask a
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
      = String -> ShowS
showString String
"VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT"
    showsPrec Int
p (VkCommandBufferResetBitmask VkFlags
x)
      = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
          (String -> ShowS
showString String
"VkCommandBufferResetBitmask " 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 (VkCommandBufferResetBitmask a) where
    readPrec :: ReadPrec (VkCommandBufferResetBitmask a)
readPrec
      = ReadPrec (VkCommandBufferResetBitmask a)
-> ReadPrec (VkCommandBufferResetBitmask a)
forall a. ReadPrec a -> ReadPrec a
parens
          ([(String, ReadPrec (VkCommandBufferResetBitmask a))]
-> ReadPrec (VkCommandBufferResetBitmask a)
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
             [(String
"VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT",
               VkCommandBufferResetBitmask a
-> ReadPrec (VkCommandBufferResetBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferResetBitmask a
forall (a :: FlagType). VkCommandBufferResetBitmask a
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT)]
             ReadPrec (VkCommandBufferResetBitmask a)
-> ReadPrec (VkCommandBufferResetBitmask a)
-> ReadPrec (VkCommandBufferResetBitmask a)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
             Int
-> ReadPrec (VkCommandBufferResetBitmask a)
-> ReadPrec (VkCommandBufferResetBitmask a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
               (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkCommandBufferResetBitmask") ReadPrec ()
-> ReadPrec (VkCommandBufferResetBitmask a)
-> ReadPrec (VkCommandBufferResetBitmask a)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  (VkFlags -> VkCommandBufferResetBitmask a
forall (a :: FlagType). VkFlags -> VkCommandBufferResetBitmask a
VkCommandBufferResetBitmask (VkFlags -> VkCommandBufferResetBitmask a)
-> ReadPrec VkFlags -> ReadPrec (VkCommandBufferResetBitmask 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)))

-- | Release resources owned by the buffer
--
--   bitpos = @0@
pattern VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT ::
        VkCommandBufferResetBitmask a

pattern $bVK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT :: forall (a :: FlagType). VkCommandBufferResetBitmask a
$mVK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT :: forall {r} {a :: FlagType}.
VkCommandBufferResetBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT =
        VkCommandBufferResetBitmask 1

newtype VkCommandBufferUsageBitmask (a ::
                                       FlagType) = VkCommandBufferUsageBitmask VkFlags
                                                   deriving (VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
(VkCommandBufferUsageBitmask a
 -> VkCommandBufferUsageBitmask a -> Bool)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Bool)
-> Eq (VkCommandBufferUsageBitmask a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
/= :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c/= :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
== :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c== :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
Eq, Eq (VkCommandBufferUsageBitmask a)
Eq (VkCommandBufferUsageBitmask a)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Ordering)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Bool)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Bool)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Bool)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> Bool)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a)
-> (VkCommandBufferUsageBitmask a
    -> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a)
-> Ord (VkCommandBufferUsageBitmask a)
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Ordering
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask 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 (VkCommandBufferUsageBitmask a)
forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Ordering
forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
min :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
$cmin :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
max :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
$cmax :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> VkCommandBufferUsageBitmask a
>= :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c>= :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
> :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c> :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
<= :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c<= :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
< :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
$c< :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Bool
compare :: VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Ordering
$ccompare :: forall (a :: FlagType).
VkCommandBufferUsageBitmask a
-> VkCommandBufferUsageBitmask a -> Ordering
Ord, Ptr (VkCommandBufferUsageBitmask a)
-> IO (VkCommandBufferUsageBitmask a)
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> IO (VkCommandBufferUsageBitmask a)
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> VkCommandBufferUsageBitmask a -> IO ()
Ptr (VkCommandBufferUsageBitmask a)
-> VkCommandBufferUsageBitmask a -> IO ()
VkCommandBufferUsageBitmask a -> Int
(VkCommandBufferUsageBitmask a -> Int)
-> (VkCommandBufferUsageBitmask a -> Int)
-> (Ptr (VkCommandBufferUsageBitmask a)
    -> Int -> IO (VkCommandBufferUsageBitmask a))
-> (Ptr (VkCommandBufferUsageBitmask a)
    -> Int -> VkCommandBufferUsageBitmask a -> IO ())
-> (forall b. Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a))
-> (forall b.
    Ptr b -> Int -> VkCommandBufferUsageBitmask a -> IO ())
-> (Ptr (VkCommandBufferUsageBitmask a)
    -> IO (VkCommandBufferUsageBitmask a))
-> (Ptr (VkCommandBufferUsageBitmask a)
    -> VkCommandBufferUsageBitmask a -> IO ())
-> Storable (VkCommandBufferUsageBitmask a)
forall b. Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a)
forall b. Ptr b -> Int -> VkCommandBufferUsageBitmask 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 (VkCommandBufferUsageBitmask a)
-> IO (VkCommandBufferUsageBitmask a)
forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> IO (VkCommandBufferUsageBitmask a)
forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> VkCommandBufferUsageBitmask a -> IO ()
forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> VkCommandBufferUsageBitmask a -> IO ()
forall (a :: FlagType). VkCommandBufferUsageBitmask a -> Int
forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a)
forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandBufferUsageBitmask a -> IO ()
poke :: Ptr (VkCommandBufferUsageBitmask a)
-> VkCommandBufferUsageBitmask a -> IO ()
$cpoke :: forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> VkCommandBufferUsageBitmask a -> IO ()
peek :: Ptr (VkCommandBufferUsageBitmask a)
-> IO (VkCommandBufferUsageBitmask a)
$cpeek :: forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> IO (VkCommandBufferUsageBitmask a)
pokeByteOff :: forall b. Ptr b -> Int -> VkCommandBufferUsageBitmask a -> IO ()
$cpokeByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandBufferUsageBitmask a -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a)
$cpeekByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandBufferUsageBitmask a)
pokeElemOff :: Ptr (VkCommandBufferUsageBitmask a)
-> Int -> VkCommandBufferUsageBitmask a -> IO ()
$cpokeElemOff :: forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> VkCommandBufferUsageBitmask a -> IO ()
peekElemOff :: Ptr (VkCommandBufferUsageBitmask a)
-> Int -> IO (VkCommandBufferUsageBitmask a)
$cpeekElemOff :: forall (a :: FlagType).
Ptr (VkCommandBufferUsageBitmask a)
-> Int -> IO (VkCommandBufferUsageBitmask a)
alignment :: VkCommandBufferUsageBitmask a -> Int
$calignment :: forall (a :: FlagType). VkCommandBufferUsageBitmask a -> Int
sizeOf :: VkCommandBufferUsageBitmask a -> Int
$csizeOf :: forall (a :: FlagType). VkCommandBufferUsageBitmask a -> Int
Storable)

type VkCommandBufferUsageFlags =
     VkCommandBufferUsageBitmask FlagMask

type VkCommandBufferUsageFlagBits =
     VkCommandBufferUsageBitmask FlagBit

pattern VkCommandBufferUsageFlagBits ::
        VkFlags -> VkCommandBufferUsageBitmask FlagBit

pattern $bVkCommandBufferUsageFlagBits :: VkFlags -> VkCommandBufferUsageBitmask FlagBit
$mVkCommandBufferUsageFlagBits :: forall {r}.
VkCommandBufferUsageBitmask FlagBit
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandBufferUsageFlagBits n =
        VkCommandBufferUsageBitmask n

pattern VkCommandBufferUsageFlags ::
        VkFlags -> VkCommandBufferUsageBitmask FlagMask

pattern $bVkCommandBufferUsageFlags :: VkFlags -> VkCommandBufferUsageBitmask FlagMask
$mVkCommandBufferUsageFlags :: forall {r}.
VkCommandBufferUsageBitmask FlagMask
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandBufferUsageFlags n = VkCommandBufferUsageBitmask n

deriving instance Bits (VkCommandBufferUsageBitmask FlagMask)

deriving instance FiniteBits (VkCommandBufferUsageBitmask FlagMask)

instance Show (VkCommandBufferUsageBitmask a) where
    showsPrec :: Int -> VkCommandBufferUsageBitmask a -> ShowS
showsPrec Int
_ VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
      = String -> ShowS
showString String
"VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"
    showsPrec Int
_ VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
      = String -> ShowS
showString String
"VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"
    showsPrec Int
_ VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
      = String -> ShowS
showString String
"VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT"
    showsPrec Int
p (VkCommandBufferUsageBitmask VkFlags
x)
      = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
          (String -> ShowS
showString String
"VkCommandBufferUsageBitmask " 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 (VkCommandBufferUsageBitmask a) where
    readPrec :: ReadPrec (VkCommandBufferUsageBitmask a)
readPrec
      = ReadPrec (VkCommandBufferUsageBitmask a)
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall a. ReadPrec a -> ReadPrec a
parens
          ([(String, ReadPrec (VkCommandBufferUsageBitmask a))]
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
             [(String
"VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT",
               VkCommandBufferUsageBitmask a
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferUsageBitmask a
forall (a :: FlagType). VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT),
              (String
"VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT",
               VkCommandBufferUsageBitmask a
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferUsageBitmask a
forall (a :: FlagType). VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT),
              (String
"VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT",
               VkCommandBufferUsageBitmask a
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandBufferUsageBitmask a
forall (a :: FlagType). VkCommandBufferUsageBitmask a
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)]
             ReadPrec (VkCommandBufferUsageBitmask a)
-> ReadPrec (VkCommandBufferUsageBitmask a)
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
             Int
-> ReadPrec (VkCommandBufferUsageBitmask a)
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
               (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkCommandBufferUsageBitmask") ReadPrec ()
-> ReadPrec (VkCommandBufferUsageBitmask a)
-> ReadPrec (VkCommandBufferUsageBitmask a)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  (VkFlags -> VkCommandBufferUsageBitmask a
forall (a :: FlagType). VkFlags -> VkCommandBufferUsageBitmask a
VkCommandBufferUsageBitmask (VkFlags -> VkCommandBufferUsageBitmask a)
-> ReadPrec VkFlags -> ReadPrec (VkCommandBufferUsageBitmask 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_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT ::
        VkCommandBufferUsageBitmask a

pattern $bVK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT :: forall (a :: FlagType). VkCommandBufferUsageBitmask a
$mVK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT :: forall {r} {a :: FlagType}.
VkCommandBufferUsageBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT =
        VkCommandBufferUsageBitmask 1

-- | bitpos = @1@
pattern VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT ::
        VkCommandBufferUsageBitmask a

pattern $bVK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT :: forall (a :: FlagType). VkCommandBufferUsageBitmask a
$mVK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT :: forall {r} {a :: FlagType}.
VkCommandBufferUsageBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT =
        VkCommandBufferUsageBitmask 2

-- | Command buffer may be submitted/executed more than once simultaneously
--
--   bitpos = @2@
pattern VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT ::
        VkCommandBufferUsageBitmask a

pattern $bVK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT :: forall (a :: FlagType). VkCommandBufferUsageBitmask a
$mVK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT :: forall {r} {a :: FlagType}.
VkCommandBufferUsageBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT =
        VkCommandBufferUsageBitmask 4

newtype VkCommandPoolCreateBitmask (a ::
                                      FlagType) = VkCommandPoolCreateBitmask VkFlags
                                                  deriving (VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
(VkCommandPoolCreateBitmask a
 -> VkCommandPoolCreateBitmask a -> Bool)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Bool)
-> Eq (VkCommandPoolCreateBitmask a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
/= :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c/= :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
== :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c== :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
Eq, Eq (VkCommandPoolCreateBitmask a)
Eq (VkCommandPoolCreateBitmask a)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Ordering)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Bool)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Bool)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Bool)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> Bool)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a)
-> (VkCommandPoolCreateBitmask a
    -> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a)
-> Ord (VkCommandPoolCreateBitmask a)
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Ordering
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask 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 (VkCommandPoolCreateBitmask a)
forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Ordering
forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
min :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
$cmin :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
max :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
$cmax :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> VkCommandPoolCreateBitmask a
>= :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c>= :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
> :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c> :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
<= :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c<= :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
< :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
$c< :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Bool
compare :: VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Ordering
$ccompare :: forall (a :: FlagType).
VkCommandPoolCreateBitmask a
-> VkCommandPoolCreateBitmask a -> Ordering
Ord, Ptr (VkCommandPoolCreateBitmask a)
-> IO (VkCommandPoolCreateBitmask a)
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> IO (VkCommandPoolCreateBitmask a)
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> VkCommandPoolCreateBitmask a -> IO ()
Ptr (VkCommandPoolCreateBitmask a)
-> VkCommandPoolCreateBitmask a -> IO ()
VkCommandPoolCreateBitmask a -> Int
(VkCommandPoolCreateBitmask a -> Int)
-> (VkCommandPoolCreateBitmask a -> Int)
-> (Ptr (VkCommandPoolCreateBitmask a)
    -> Int -> IO (VkCommandPoolCreateBitmask a))
-> (Ptr (VkCommandPoolCreateBitmask a)
    -> Int -> VkCommandPoolCreateBitmask a -> IO ())
-> (forall b. Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a))
-> (forall b.
    Ptr b -> Int -> VkCommandPoolCreateBitmask a -> IO ())
-> (Ptr (VkCommandPoolCreateBitmask a)
    -> IO (VkCommandPoolCreateBitmask a))
-> (Ptr (VkCommandPoolCreateBitmask a)
    -> VkCommandPoolCreateBitmask a -> IO ())
-> Storable (VkCommandPoolCreateBitmask a)
forall b. Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a)
forall b. Ptr b -> Int -> VkCommandPoolCreateBitmask 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 (VkCommandPoolCreateBitmask a)
-> IO (VkCommandPoolCreateBitmask a)
forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> IO (VkCommandPoolCreateBitmask a)
forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> VkCommandPoolCreateBitmask a -> IO ()
forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> VkCommandPoolCreateBitmask a -> IO ()
forall (a :: FlagType). VkCommandPoolCreateBitmask a -> Int
forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a)
forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandPoolCreateBitmask a -> IO ()
poke :: Ptr (VkCommandPoolCreateBitmask a)
-> VkCommandPoolCreateBitmask a -> IO ()
$cpoke :: forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> VkCommandPoolCreateBitmask a -> IO ()
peek :: Ptr (VkCommandPoolCreateBitmask a)
-> IO (VkCommandPoolCreateBitmask a)
$cpeek :: forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> IO (VkCommandPoolCreateBitmask a)
pokeByteOff :: forall b. Ptr b -> Int -> VkCommandPoolCreateBitmask a -> IO ()
$cpokeByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandPoolCreateBitmask a -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a)
$cpeekByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandPoolCreateBitmask a)
pokeElemOff :: Ptr (VkCommandPoolCreateBitmask a)
-> Int -> VkCommandPoolCreateBitmask a -> IO ()
$cpokeElemOff :: forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> VkCommandPoolCreateBitmask a -> IO ()
peekElemOff :: Ptr (VkCommandPoolCreateBitmask a)
-> Int -> IO (VkCommandPoolCreateBitmask a)
$cpeekElemOff :: forall (a :: FlagType).
Ptr (VkCommandPoolCreateBitmask a)
-> Int -> IO (VkCommandPoolCreateBitmask a)
alignment :: VkCommandPoolCreateBitmask a -> Int
$calignment :: forall (a :: FlagType). VkCommandPoolCreateBitmask a -> Int
sizeOf :: VkCommandPoolCreateBitmask a -> Int
$csizeOf :: forall (a :: FlagType). VkCommandPoolCreateBitmask a -> Int
Storable)

type VkCommandPoolCreateFlags = VkCommandPoolCreateBitmask FlagMask

type VkCommandPoolCreateFlagBits =
     VkCommandPoolCreateBitmask FlagBit

pattern VkCommandPoolCreateFlagBits ::
        VkFlags -> VkCommandPoolCreateBitmask FlagBit

pattern $bVkCommandPoolCreateFlagBits :: VkFlags -> VkCommandPoolCreateBitmask FlagBit
$mVkCommandPoolCreateFlagBits :: forall {r}.
VkCommandPoolCreateBitmask FlagBit
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandPoolCreateFlagBits n =
        VkCommandPoolCreateBitmask n

pattern VkCommandPoolCreateFlags ::
        VkFlags -> VkCommandPoolCreateBitmask FlagMask

pattern $bVkCommandPoolCreateFlags :: VkFlags -> VkCommandPoolCreateBitmask FlagMask
$mVkCommandPoolCreateFlags :: forall {r}.
VkCommandPoolCreateBitmask FlagMask
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandPoolCreateFlags n = VkCommandPoolCreateBitmask n

deriving instance Bits (VkCommandPoolCreateBitmask FlagMask)

deriving instance FiniteBits (VkCommandPoolCreateBitmask FlagMask)

instance Show (VkCommandPoolCreateBitmask a) where
    showsPrec :: Int -> VkCommandPoolCreateBitmask a -> ShowS
showsPrec Int
_ VkCommandPoolCreateBitmask a
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
      = String -> ShowS
showString String
"VK_COMMAND_POOL_CREATE_TRANSIENT_BIT"
    showsPrec Int
_ VkCommandPoolCreateBitmask a
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
      = String -> ShowS
showString String
"VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"
    showsPrec Int
p (VkCommandPoolCreateBitmask VkFlags
x)
      = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
          (String -> ShowS
showString String
"VkCommandPoolCreateBitmask " 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 (VkCommandPoolCreateBitmask a) where
    readPrec :: ReadPrec (VkCommandPoolCreateBitmask a)
readPrec
      = ReadPrec (VkCommandPoolCreateBitmask a)
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall a. ReadPrec a -> ReadPrec a
parens
          ([(String, ReadPrec (VkCommandPoolCreateBitmask a))]
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
             [(String
"VK_COMMAND_POOL_CREATE_TRANSIENT_BIT",
               VkCommandPoolCreateBitmask a
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandPoolCreateBitmask a
forall (a :: FlagType). VkCommandPoolCreateBitmask a
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT),
              (String
"VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT",
               VkCommandPoolCreateBitmask a
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandPoolCreateBitmask a
forall (a :: FlagType). VkCommandPoolCreateBitmask a
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)]
             ReadPrec (VkCommandPoolCreateBitmask a)
-> ReadPrec (VkCommandPoolCreateBitmask a)
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
             Int
-> ReadPrec (VkCommandPoolCreateBitmask a)
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
               (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkCommandPoolCreateBitmask") ReadPrec ()
-> ReadPrec (VkCommandPoolCreateBitmask a)
-> ReadPrec (VkCommandPoolCreateBitmask a)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  (VkFlags -> VkCommandPoolCreateBitmask a
forall (a :: FlagType). VkFlags -> VkCommandPoolCreateBitmask a
VkCommandPoolCreateBitmask (VkFlags -> VkCommandPoolCreateBitmask a)
-> ReadPrec VkFlags -> ReadPrec (VkCommandPoolCreateBitmask 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)))

-- | Command buffers have a short lifetime
--
--   bitpos = @0@
pattern VK_COMMAND_POOL_CREATE_TRANSIENT_BIT ::
        VkCommandPoolCreateBitmask a

pattern $bVK_COMMAND_POOL_CREATE_TRANSIENT_BIT :: forall (a :: FlagType). VkCommandPoolCreateBitmask a
$mVK_COMMAND_POOL_CREATE_TRANSIENT_BIT :: forall {r} {a :: FlagType}.
VkCommandPoolCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT =
        VkCommandPoolCreateBitmask 1

-- | Command buffers may release their memory individually
--
--   bitpos = @1@
pattern VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT ::
        VkCommandPoolCreateBitmask a

pattern $bVK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT :: forall (a :: FlagType). VkCommandPoolCreateBitmask a
$mVK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT :: forall {r} {a :: FlagType}.
VkCommandPoolCreateBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT =
        VkCommandPoolCreateBitmask 2

newtype VkCommandPoolResetBitmask (a ::
                                     FlagType) = VkCommandPoolResetBitmask VkFlags
                                                 deriving (VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
(VkCommandPoolResetBitmask a
 -> VkCommandPoolResetBitmask a -> Bool)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Bool)
-> Eq (VkCommandPoolResetBitmask a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
/= :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c/= :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
== :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c== :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
Eq, Eq (VkCommandPoolResetBitmask a)
Eq (VkCommandPoolResetBitmask a)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Ordering)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Bool)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Bool)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Bool)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> Bool)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a)
-> (VkCommandPoolResetBitmask a
    -> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a)
-> Ord (VkCommandPoolResetBitmask a)
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> Ordering
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask 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 (VkCommandPoolResetBitmask a)
forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
forall (a :: FlagType).
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> Ordering
forall (a :: FlagType).
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
min :: VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
$cmin :: forall (a :: FlagType).
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
max :: VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
$cmax :: forall (a :: FlagType).
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a
>= :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c>= :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
> :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c> :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
<= :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c<= :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
< :: VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
$c< :: forall (a :: FlagType).
VkCommandPoolResetBitmask a -> VkCommandPoolResetBitmask a -> Bool
compare :: VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> Ordering
$ccompare :: forall (a :: FlagType).
VkCommandPoolResetBitmask a
-> VkCommandPoolResetBitmask a -> Ordering
Ord, Ptr (VkCommandPoolResetBitmask a)
-> IO (VkCommandPoolResetBitmask a)
Ptr (VkCommandPoolResetBitmask a)
-> Int -> IO (VkCommandPoolResetBitmask a)
Ptr (VkCommandPoolResetBitmask a)
-> Int -> VkCommandPoolResetBitmask a -> IO ()
Ptr (VkCommandPoolResetBitmask a)
-> VkCommandPoolResetBitmask a -> IO ()
VkCommandPoolResetBitmask a -> Int
(VkCommandPoolResetBitmask a -> Int)
-> (VkCommandPoolResetBitmask a -> Int)
-> (Ptr (VkCommandPoolResetBitmask a)
    -> Int -> IO (VkCommandPoolResetBitmask a))
-> (Ptr (VkCommandPoolResetBitmask a)
    -> Int -> VkCommandPoolResetBitmask a -> IO ())
-> (forall b. Ptr b -> Int -> IO (VkCommandPoolResetBitmask a))
-> (forall b. Ptr b -> Int -> VkCommandPoolResetBitmask a -> IO ())
-> (Ptr (VkCommandPoolResetBitmask a)
    -> IO (VkCommandPoolResetBitmask a))
-> (Ptr (VkCommandPoolResetBitmask a)
    -> VkCommandPoolResetBitmask a -> IO ())
-> Storable (VkCommandPoolResetBitmask a)
forall b. Ptr b -> Int -> IO (VkCommandPoolResetBitmask a)
forall b. Ptr b -> Int -> VkCommandPoolResetBitmask 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 (VkCommandPoolResetBitmask a)
-> IO (VkCommandPoolResetBitmask a)
forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> Int -> IO (VkCommandPoolResetBitmask a)
forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> Int -> VkCommandPoolResetBitmask a -> IO ()
forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> VkCommandPoolResetBitmask a -> IO ()
forall (a :: FlagType). VkCommandPoolResetBitmask a -> Int
forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandPoolResetBitmask a)
forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandPoolResetBitmask a -> IO ()
poke :: Ptr (VkCommandPoolResetBitmask a)
-> VkCommandPoolResetBitmask a -> IO ()
$cpoke :: forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> VkCommandPoolResetBitmask a -> IO ()
peek :: Ptr (VkCommandPoolResetBitmask a)
-> IO (VkCommandPoolResetBitmask a)
$cpeek :: forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> IO (VkCommandPoolResetBitmask a)
pokeByteOff :: forall b. Ptr b -> Int -> VkCommandPoolResetBitmask a -> IO ()
$cpokeByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> VkCommandPoolResetBitmask a -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO (VkCommandPoolResetBitmask a)
$cpeekByteOff :: forall (a :: FlagType) b.
Ptr b -> Int -> IO (VkCommandPoolResetBitmask a)
pokeElemOff :: Ptr (VkCommandPoolResetBitmask a)
-> Int -> VkCommandPoolResetBitmask a -> IO ()
$cpokeElemOff :: forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> Int -> VkCommandPoolResetBitmask a -> IO ()
peekElemOff :: Ptr (VkCommandPoolResetBitmask a)
-> Int -> IO (VkCommandPoolResetBitmask a)
$cpeekElemOff :: forall (a :: FlagType).
Ptr (VkCommandPoolResetBitmask a)
-> Int -> IO (VkCommandPoolResetBitmask a)
alignment :: VkCommandPoolResetBitmask a -> Int
$calignment :: forall (a :: FlagType). VkCommandPoolResetBitmask a -> Int
sizeOf :: VkCommandPoolResetBitmask a -> Int
$csizeOf :: forall (a :: FlagType). VkCommandPoolResetBitmask a -> Int
Storable)

type VkCommandPoolResetFlags = VkCommandPoolResetBitmask FlagMask

type VkCommandPoolResetFlagBits = VkCommandPoolResetBitmask FlagBit

pattern VkCommandPoolResetFlagBits ::
        VkFlags -> VkCommandPoolResetBitmask FlagBit

pattern $bVkCommandPoolResetFlagBits :: VkFlags -> VkCommandPoolResetBitmask FlagBit
$mVkCommandPoolResetFlagBits :: forall {r}.
VkCommandPoolResetBitmask FlagBit
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandPoolResetFlagBits n = VkCommandPoolResetBitmask n

pattern VkCommandPoolResetFlags ::
        VkFlags -> VkCommandPoolResetBitmask FlagMask

pattern $bVkCommandPoolResetFlags :: VkFlags -> VkCommandPoolResetBitmask FlagMask
$mVkCommandPoolResetFlags :: forall {r}.
VkCommandPoolResetBitmask FlagMask
-> (VkFlags -> r) -> (Void# -> r) -> r
VkCommandPoolResetFlags n = VkCommandPoolResetBitmask n

deriving instance Bits (VkCommandPoolResetBitmask FlagMask)

deriving instance FiniteBits (VkCommandPoolResetBitmask FlagMask)

instance Show (VkCommandPoolResetBitmask a) where
    showsPrec :: Int -> VkCommandPoolResetBitmask a -> ShowS
showsPrec Int
_ VkCommandPoolResetBitmask a
VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
      = String -> ShowS
showString String
"VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT"
    showsPrec Int
p (VkCommandPoolResetBitmask VkFlags
x)
      = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11)
          (String -> ShowS
showString String
"VkCommandPoolResetBitmask " 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 (VkCommandPoolResetBitmask a) where
    readPrec :: ReadPrec (VkCommandPoolResetBitmask a)
readPrec
      = ReadPrec (VkCommandPoolResetBitmask a)
-> ReadPrec (VkCommandPoolResetBitmask a)
forall a. ReadPrec a -> ReadPrec a
parens
          ([(String, ReadPrec (VkCommandPoolResetBitmask a))]
-> ReadPrec (VkCommandPoolResetBitmask a)
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
             [(String
"VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT",
               VkCommandPoolResetBitmask a
-> ReadPrec (VkCommandPoolResetBitmask a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkCommandPoolResetBitmask a
forall (a :: FlagType). VkCommandPoolResetBitmask a
VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT)]
             ReadPrec (VkCommandPoolResetBitmask a)
-> ReadPrec (VkCommandPoolResetBitmask a)
-> ReadPrec (VkCommandPoolResetBitmask a)
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
             Int
-> ReadPrec (VkCommandPoolResetBitmask a)
-> ReadPrec (VkCommandPoolResetBitmask a)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
               (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkCommandPoolResetBitmask") ReadPrec ()
-> ReadPrec (VkCommandPoolResetBitmask a)
-> ReadPrec (VkCommandPoolResetBitmask a)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  (VkFlags -> VkCommandPoolResetBitmask a
forall (a :: FlagType). VkFlags -> VkCommandPoolResetBitmask a
VkCommandPoolResetBitmask (VkFlags -> VkCommandPoolResetBitmask a)
-> ReadPrec VkFlags -> ReadPrec (VkCommandPoolResetBitmask 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)))

-- | Release resources owned by the pool
--
--   bitpos = @0@
pattern VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT ::
        VkCommandPoolResetBitmask a

pattern $bVK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT :: forall (a :: FlagType). VkCommandPoolResetBitmask a
$mVK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT :: forall {r} {a :: FlagType}.
VkCommandPoolResetBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT =
        VkCommandPoolResetBitmask 1