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

type VkStencilFaceFlags = VkStencilFaceBitmask FlagMask

type VkStencilFaceFlagBits = VkStencilFaceBitmask FlagBit

pattern VkStencilFaceFlagBits ::
        VkFlags -> VkStencilFaceBitmask FlagBit

pattern $bVkStencilFaceFlagBits :: VkFlags -> VkStencilFaceBitmask FlagBit
$mVkStencilFaceFlagBits :: forall r.
VkStencilFaceBitmask FlagBit -> (VkFlags -> r) -> (Void# -> r) -> r
VkStencilFaceFlagBits n = VkStencilFaceBitmask n

pattern VkStencilFaceFlags ::
        VkFlags -> VkStencilFaceBitmask FlagMask

pattern $bVkStencilFaceFlags :: VkFlags -> VkStencilFaceBitmask FlagMask
$mVkStencilFaceFlags :: forall r.
VkStencilFaceBitmask FlagMask
-> (VkFlags -> r) -> (Void# -> r) -> r
VkStencilFaceFlags n = VkStencilFaceBitmask n

deriving instance Bits (VkStencilFaceBitmask FlagMask)

deriving instance FiniteBits (VkStencilFaceBitmask FlagMask)

deriving instance Integral (VkStencilFaceBitmask FlagMask)

deriving instance Num (VkStencilFaceBitmask FlagMask)

deriving instance Bounded (VkStencilFaceBitmask FlagMask)

deriving instance Enum (VkStencilFaceBitmask FlagMask)

deriving instance Real (VkStencilFaceBitmask FlagMask)

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

-- | Front face
--
--   bitpos = @0@
pattern VK_STENCIL_FACE_FRONT_BIT :: VkStencilFaceBitmask a

pattern $bVK_STENCIL_FACE_FRONT_BIT :: VkStencilFaceBitmask a
$mVK_STENCIL_FACE_FRONT_BIT :: forall r (a :: FlagType).
VkStencilFaceBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_FACE_FRONT_BIT = VkStencilFaceBitmask 1

-- | Back face
--
--   bitpos = @1@
pattern VK_STENCIL_FACE_BACK_BIT :: VkStencilFaceBitmask a

pattern $bVK_STENCIL_FACE_BACK_BIT :: VkStencilFaceBitmask a
$mVK_STENCIL_FACE_BACK_BIT :: forall r (a :: FlagType).
VkStencilFaceBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_FACE_BACK_BIT = VkStencilFaceBitmask 2

-- | Front and back faces
pattern VK_STENCIL_FRONT_AND_BACK :: VkStencilFaceBitmask a

pattern $bVK_STENCIL_FRONT_AND_BACK :: VkStencilFaceBitmask a
$mVK_STENCIL_FRONT_AND_BACK :: forall r (a :: FlagType).
VkStencilFaceBitmask a -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_FRONT_AND_BACK = VkStencilFaceBitmask 3

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

instance Show VkStencilOp where
        showsPrec :: Int -> VkStencilOp -> ShowS
showsPrec Int
_ VkStencilOp
VK_STENCIL_OP_KEEP = String -> ShowS
showString String
"VK_STENCIL_OP_KEEP"
        showsPrec Int
_ VkStencilOp
VK_STENCIL_OP_ZERO = String -> ShowS
showString String
"VK_STENCIL_OP_ZERO"
        showsPrec Int
_ VkStencilOp
VK_STENCIL_OP_REPLACE
          = String -> ShowS
showString String
"VK_STENCIL_OP_REPLACE"
        showsPrec Int
_ VkStencilOp
VK_STENCIL_OP_INCREMENT_AND_CLAMP
          = String -> ShowS
showString String
"VK_STENCIL_OP_INCREMENT_AND_CLAMP"
        showsPrec Int
_ VkStencilOp
VK_STENCIL_OP_DECREMENT_AND_CLAMP
          = String -> ShowS
showString String
"VK_STENCIL_OP_DECREMENT_AND_CLAMP"
        showsPrec Int
_ VkStencilOp
VK_STENCIL_OP_INVERT
          = String -> ShowS
showString String
"VK_STENCIL_OP_INVERT"
        showsPrec Int
_ VkStencilOp
VK_STENCIL_OP_INCREMENT_AND_WRAP
          = String -> ShowS
showString String
"VK_STENCIL_OP_INCREMENT_AND_WRAP"
        showsPrec Int
_ VkStencilOp
VK_STENCIL_OP_DECREMENT_AND_WRAP
          = String -> ShowS
showString String
"VK_STENCIL_OP_DECREMENT_AND_WRAP"
        showsPrec Int
p (VkStencilOp Int32
x)
          = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
11) (String -> ShowS
showString String
"VkStencilOp " 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 VkStencilOp where
        readPrec :: ReadPrec VkStencilOp
readPrec
          = ReadPrec VkStencilOp -> ReadPrec VkStencilOp
forall a. ReadPrec a -> ReadPrec a
parens
              ([(String, ReadPrec VkStencilOp)] -> ReadPrec VkStencilOp
forall a. [(String, ReadPrec a)] -> ReadPrec a
choose
                 [(String
"VK_STENCIL_OP_KEEP", VkStencilOp -> ReadPrec VkStencilOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkStencilOp
VK_STENCIL_OP_KEEP),
                  (String
"VK_STENCIL_OP_ZERO", VkStencilOp -> ReadPrec VkStencilOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkStencilOp
VK_STENCIL_OP_ZERO),
                  (String
"VK_STENCIL_OP_REPLACE", VkStencilOp -> ReadPrec VkStencilOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkStencilOp
VK_STENCIL_OP_REPLACE),
                  (String
"VK_STENCIL_OP_INCREMENT_AND_CLAMP",
                   VkStencilOp -> ReadPrec VkStencilOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkStencilOp
VK_STENCIL_OP_INCREMENT_AND_CLAMP),
                  (String
"VK_STENCIL_OP_DECREMENT_AND_CLAMP",
                   VkStencilOp -> ReadPrec VkStencilOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkStencilOp
VK_STENCIL_OP_DECREMENT_AND_CLAMP),
                  (String
"VK_STENCIL_OP_INVERT", VkStencilOp -> ReadPrec VkStencilOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkStencilOp
VK_STENCIL_OP_INVERT),
                  (String
"VK_STENCIL_OP_INCREMENT_AND_WRAP",
                   VkStencilOp -> ReadPrec VkStencilOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkStencilOp
VK_STENCIL_OP_INCREMENT_AND_WRAP),
                  (String
"VK_STENCIL_OP_DECREMENT_AND_WRAP",
                   VkStencilOp -> ReadPrec VkStencilOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure VkStencilOp
VK_STENCIL_OP_DECREMENT_AND_WRAP)]
                 ReadPrec VkStencilOp
-> ReadPrec VkStencilOp -> ReadPrec VkStencilOp
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++
                 Int -> ReadPrec VkStencilOp -> ReadPrec VkStencilOp
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
10
                   (Lexeme -> ReadPrec ()
expectP (String -> Lexeme
Ident String
"VkStencilOp") ReadPrec () -> ReadPrec VkStencilOp -> ReadPrec VkStencilOp
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Int32 -> VkStencilOp
VkStencilOp (Int32 -> VkStencilOp) -> ReadPrec Int32 -> ReadPrec VkStencilOp
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_STENCIL_OP_KEEP :: VkStencilOp

pattern $bVK_STENCIL_OP_KEEP :: VkStencilOp
$mVK_STENCIL_OP_KEEP :: forall r. VkStencilOp -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_OP_KEEP = VkStencilOp 0

pattern VK_STENCIL_OP_ZERO :: VkStencilOp

pattern $bVK_STENCIL_OP_ZERO :: VkStencilOp
$mVK_STENCIL_OP_ZERO :: forall r. VkStencilOp -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_OP_ZERO = VkStencilOp 1

pattern VK_STENCIL_OP_REPLACE :: VkStencilOp

pattern $bVK_STENCIL_OP_REPLACE :: VkStencilOp
$mVK_STENCIL_OP_REPLACE :: forall r. VkStencilOp -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_OP_REPLACE = VkStencilOp 2

pattern VK_STENCIL_OP_INCREMENT_AND_CLAMP :: VkStencilOp

pattern $bVK_STENCIL_OP_INCREMENT_AND_CLAMP :: VkStencilOp
$mVK_STENCIL_OP_INCREMENT_AND_CLAMP :: forall r. VkStencilOp -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_OP_INCREMENT_AND_CLAMP = VkStencilOp 3

pattern VK_STENCIL_OP_DECREMENT_AND_CLAMP :: VkStencilOp

pattern $bVK_STENCIL_OP_DECREMENT_AND_CLAMP :: VkStencilOp
$mVK_STENCIL_OP_DECREMENT_AND_CLAMP :: forall r. VkStencilOp -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_OP_DECREMENT_AND_CLAMP = VkStencilOp 4

pattern VK_STENCIL_OP_INVERT :: VkStencilOp

pattern $bVK_STENCIL_OP_INVERT :: VkStencilOp
$mVK_STENCIL_OP_INVERT :: forall r. VkStencilOp -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_OP_INVERT = VkStencilOp 5

pattern VK_STENCIL_OP_INCREMENT_AND_WRAP :: VkStencilOp

pattern $bVK_STENCIL_OP_INCREMENT_AND_WRAP :: VkStencilOp
$mVK_STENCIL_OP_INCREMENT_AND_WRAP :: forall r. VkStencilOp -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_OP_INCREMENT_AND_WRAP = VkStencilOp 6

pattern VK_STENCIL_OP_DECREMENT_AND_WRAP :: VkStencilOp

pattern $bVK_STENCIL_OP_DECREMENT_AND_WRAP :: VkStencilOp
$mVK_STENCIL_OP_DECREMENT_AND_WRAP :: forall r. VkStencilOp -> (Void# -> r) -> (Void# -> r) -> r
VK_STENCIL_OP_DECREMENT_AND_WRAP = VkStencilOp 7