Safe Haskell	None
Language	Haskell2010

Graphics.Vulkan.Ext.VK_KHR_maintenance1

Contents

Vulkan extension: VK_KHR_maintenance1
Orphan instances

Synopsis

Vulkan extension: `VK_KHR_maintenance1`

supported: vulkan

contact: Piers Daniell pdaniell-nv@

author: KHR

type: device

Extension number: 70

newtype VkAndroidSurfaceCreateFlagsKHR Source #

Constructors

VkAndroidSurfaceCreateFlagsKHR VkFlags

Instances

Bounded VkAndroidSurfaceCreateFlagsKHR Source #
Methods minBound :: VkAndroidSurfaceCreateFlagsKHR # maxBound :: VkAndroidSurfaceCreateFlagsKHR #
Enum VkAndroidSurfaceCreateFlagsKHR Source #
Methods succ :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # pred :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # toEnum :: Int -> VkAndroidSurfaceCreateFlagsKHR # fromEnum :: VkAndroidSurfaceCreateFlagsKHR -> Int # enumFrom :: VkAndroidSurfaceCreateFlagsKHR -> [VkAndroidSurfaceCreateFlagsKHR] # enumFromThen :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> [VkAndroidSurfaceCreateFlagsKHR] # enumFromTo :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> [VkAndroidSurfaceCreateFlagsKHR] # enumFromThenTo :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> [VkAndroidSurfaceCreateFlagsKHR] #
Eq VkAndroidSurfaceCreateFlagsKHR Source #
Methods (==) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> Bool # (/=) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> Bool #
Integral VkAndroidSurfaceCreateFlagsKHR Source #
Methods quot :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # rem :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # div :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # mod :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # quotRem :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> (VkAndroidSurfaceCreateFlagsKHR, VkAndroidSurfaceCreateFlagsKHR) # divMod :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> (VkAndroidSurfaceCreateFlagsKHR, VkAndroidSurfaceCreateFlagsKHR) # toInteger :: VkAndroidSurfaceCreateFlagsKHR -> Integer #
Data VkAndroidSurfaceCreateFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkAndroidSurfaceCreateFlagsKHR -> c VkAndroidSurfaceCreateFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkAndroidSurfaceCreateFlagsKHR # toConstr :: VkAndroidSurfaceCreateFlagsKHR -> Constr # dataTypeOf :: VkAndroidSurfaceCreateFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkAndroidSurfaceCreateFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkAndroidSurfaceCreateFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkAndroidSurfaceCreateFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkAndroidSurfaceCreateFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkAndroidSurfaceCreateFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkAndroidSurfaceCreateFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkAndroidSurfaceCreateFlagsKHR -> m VkAndroidSurfaceCreateFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkAndroidSurfaceCreateFlagsKHR -> m VkAndroidSurfaceCreateFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkAndroidSurfaceCreateFlagsKHR -> m VkAndroidSurfaceCreateFlagsKHR #
Num VkAndroidSurfaceCreateFlagsKHR Source #
Methods (+) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # (-) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # (*) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # negate :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # abs :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # signum :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # fromInteger :: Integer -> VkAndroidSurfaceCreateFlagsKHR #
Ord VkAndroidSurfaceCreateFlagsKHR Source #
Methods compare :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> Ordering # (<) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> Bool # (<=) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> Bool # (>) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> Bool # (>=) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> Bool # max :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # min :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR #
Read VkAndroidSurfaceCreateFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkAndroidSurfaceCreateFlagsKHR # readList :: ReadS [VkAndroidSurfaceCreateFlagsKHR] # readPrec :: ReadPrec VkAndroidSurfaceCreateFlagsKHR # readListPrec :: ReadPrec [VkAndroidSurfaceCreateFlagsKHR] #
Real VkAndroidSurfaceCreateFlagsKHR Source #
Methods toRational :: VkAndroidSurfaceCreateFlagsKHR -> Rational #
Show VkAndroidSurfaceCreateFlagsKHR Source #
Methods showsPrec :: Int -> VkAndroidSurfaceCreateFlagsKHR -> ShowS # show :: VkAndroidSurfaceCreateFlagsKHR -> String # showList :: [VkAndroidSurfaceCreateFlagsKHR] -> ShowS #
Generic VkAndroidSurfaceCreateFlagsKHR Source #
Associated Types type Rep VkAndroidSurfaceCreateFlagsKHR :: * -> * # Methods from :: VkAndroidSurfaceCreateFlagsKHR -> Rep VkAndroidSurfaceCreateFlagsKHR x # to :: Rep VkAndroidSurfaceCreateFlagsKHR x -> VkAndroidSurfaceCreateFlagsKHR #
Storable VkAndroidSurfaceCreateFlagsKHR Source #
Methods sizeOf :: VkAndroidSurfaceCreateFlagsKHR -> Int # alignment :: VkAndroidSurfaceCreateFlagsKHR -> Int # peekElemOff :: Ptr VkAndroidSurfaceCreateFlagsKHR -> Int -> IO VkAndroidSurfaceCreateFlagsKHR # pokeElemOff :: Ptr VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkAndroidSurfaceCreateFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkAndroidSurfaceCreateFlagsKHR -> IO () # peek :: Ptr VkAndroidSurfaceCreateFlagsKHR -> IO VkAndroidSurfaceCreateFlagsKHR # poke :: Ptr VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> IO () #
Bits VkAndroidSurfaceCreateFlagsKHR Source #
Methods (.&.) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # (.\|.) :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # xor :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # complement :: VkAndroidSurfaceCreateFlagsKHR -> VkAndroidSurfaceCreateFlagsKHR # shift :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # rotate :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # zeroBits :: VkAndroidSurfaceCreateFlagsKHR # bit :: Int -> VkAndroidSurfaceCreateFlagsKHR # setBit :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # clearBit :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # complementBit :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # testBit :: VkAndroidSurfaceCreateFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkAndroidSurfaceCreateFlagsKHR -> Maybe Int # bitSize :: VkAndroidSurfaceCreateFlagsKHR -> Int # isSigned :: VkAndroidSurfaceCreateFlagsKHR -> Bool # shiftL :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # unsafeShiftL :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # shiftR :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # unsafeShiftR :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # rotateL :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # rotateR :: VkAndroidSurfaceCreateFlagsKHR -> Int -> VkAndroidSurfaceCreateFlagsKHR # popCount :: VkAndroidSurfaceCreateFlagsKHR -> Int #
FiniteBits VkAndroidSurfaceCreateFlagsKHR Source #
Methods finiteBitSize :: VkAndroidSurfaceCreateFlagsKHR -> Int # countLeadingZeros :: VkAndroidSurfaceCreateFlagsKHR -> Int # countTrailingZeros :: VkAndroidSurfaceCreateFlagsKHR -> Int #
type Rep VkAndroidSurfaceCreateFlagsKHR Source #
type Rep VkAndroidSurfaceCreateFlagsKHR = D1 (MetaData "VkAndroidSurfaceCreateFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkAndroidSurfaceCreateFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkBufferViewCreateFlags Source #

Constructors

VkBufferViewCreateFlags VkFlags

Instances

Bounded VkBufferViewCreateFlags Source #
Methods minBound :: VkBufferViewCreateFlags # maxBound :: VkBufferViewCreateFlags #
Enum VkBufferViewCreateFlags Source #
Methods succ :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags # pred :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags # toEnum :: Int -> VkBufferViewCreateFlags # fromEnum :: VkBufferViewCreateFlags -> Int # enumFrom :: VkBufferViewCreateFlags -> [VkBufferViewCreateFlags] # enumFromThen :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> [VkBufferViewCreateFlags] # enumFromTo :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> [VkBufferViewCreateFlags] # enumFromThenTo :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> [VkBufferViewCreateFlags] #
Eq VkBufferViewCreateFlags Source #
Methods (==) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool # (/=) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool #
Integral VkBufferViewCreateFlags Source #
Methods quot :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # rem :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # div :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # mod :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # quotRem :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> (VkBufferViewCreateFlags, VkBufferViewCreateFlags) # divMod :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> (VkBufferViewCreateFlags, VkBufferViewCreateFlags) # toInteger :: VkBufferViewCreateFlags -> Integer #
Data VkBufferViewCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkBufferViewCreateFlags -> c VkBufferViewCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkBufferViewCreateFlags # toConstr :: VkBufferViewCreateFlags -> Constr # dataTypeOf :: VkBufferViewCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkBufferViewCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkBufferViewCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkBufferViewCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkBufferViewCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkBufferViewCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkBufferViewCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkBufferViewCreateFlags -> m VkBufferViewCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkBufferViewCreateFlags -> m VkBufferViewCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkBufferViewCreateFlags -> m VkBufferViewCreateFlags #
Num VkBufferViewCreateFlags Source #
Methods (+) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # (-) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # (*) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # negate :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags # abs :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags # signum :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags # fromInteger :: Integer -> VkBufferViewCreateFlags #
Ord VkBufferViewCreateFlags Source #
Methods compare :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Ordering # (<) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool # (<=) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool # (>) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool # (>=) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> Bool # max :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # min :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags #
Read VkBufferViewCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkBufferViewCreateFlags # readList :: ReadS [VkBufferViewCreateFlags] # readPrec :: ReadPrec VkBufferViewCreateFlags # readListPrec :: ReadPrec [VkBufferViewCreateFlags] #
Real VkBufferViewCreateFlags Source #
Methods toRational :: VkBufferViewCreateFlags -> Rational #
Show VkBufferViewCreateFlags Source #
Methods showsPrec :: Int -> VkBufferViewCreateFlags -> ShowS # show :: VkBufferViewCreateFlags -> String # showList :: [VkBufferViewCreateFlags] -> ShowS #
Generic VkBufferViewCreateFlags Source #
Associated Types type Rep VkBufferViewCreateFlags :: * -> * # Methods from :: VkBufferViewCreateFlags -> Rep VkBufferViewCreateFlags x # to :: Rep VkBufferViewCreateFlags x -> VkBufferViewCreateFlags #
Storable VkBufferViewCreateFlags Source #
Methods sizeOf :: VkBufferViewCreateFlags -> Int # alignment :: VkBufferViewCreateFlags -> Int # peekElemOff :: Ptr VkBufferViewCreateFlags -> Int -> IO VkBufferViewCreateFlags # pokeElemOff :: Ptr VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkBufferViewCreateFlags # pokeByteOff :: Ptr b -> Int -> VkBufferViewCreateFlags -> IO () # peek :: Ptr VkBufferViewCreateFlags -> IO VkBufferViewCreateFlags # poke :: Ptr VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> IO () #
Bits VkBufferViewCreateFlags Source #
Methods (.&.) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # (.\|.) :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # xor :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags -> VkBufferViewCreateFlags # complement :: VkBufferViewCreateFlags -> VkBufferViewCreateFlags # shift :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # rotate :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # zeroBits :: VkBufferViewCreateFlags # bit :: Int -> VkBufferViewCreateFlags # setBit :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # clearBit :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # complementBit :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # testBit :: VkBufferViewCreateFlags -> Int -> Bool # bitSizeMaybe :: VkBufferViewCreateFlags -> Maybe Int # bitSize :: VkBufferViewCreateFlags -> Int # isSigned :: VkBufferViewCreateFlags -> Bool # shiftL :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # unsafeShiftL :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # shiftR :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # unsafeShiftR :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # rotateL :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # rotateR :: VkBufferViewCreateFlags -> Int -> VkBufferViewCreateFlags # popCount :: VkBufferViewCreateFlags -> Int #
FiniteBits VkBufferViewCreateFlags Source #
Methods finiteBitSize :: VkBufferViewCreateFlags -> Int # countLeadingZeros :: VkBufferViewCreateFlags -> Int # countTrailingZeros :: VkBufferViewCreateFlags -> Int #
type Rep VkBufferViewCreateFlags Source #
type Rep VkBufferViewCreateFlags = D1 (MetaData "VkBufferViewCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkBufferViewCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkCommandPoolTrimFlags Source #

Constructors

VkCommandPoolTrimFlags VkFlags

Instances

Bounded VkCommandPoolTrimFlags Source #
Methods minBound :: VkCommandPoolTrimFlags # maxBound :: VkCommandPoolTrimFlags #
Enum VkCommandPoolTrimFlags Source #
Methods succ :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # pred :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # toEnum :: Int -> VkCommandPoolTrimFlags # fromEnum :: VkCommandPoolTrimFlags -> Int # enumFrom :: VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags] # enumFromThen :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags] # enumFromTo :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags] # enumFromThenTo :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> [VkCommandPoolTrimFlags] #
Eq VkCommandPoolTrimFlags Source #
Methods (==) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool # (/=) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool #
Integral VkCommandPoolTrimFlags Source #
Methods quot :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # rem :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # div :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # mod :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # quotRem :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> (VkCommandPoolTrimFlags, VkCommandPoolTrimFlags) # divMod :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> (VkCommandPoolTrimFlags, VkCommandPoolTrimFlags) # toInteger :: VkCommandPoolTrimFlags -> Integer #
Data VkCommandPoolTrimFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkCommandPoolTrimFlags -> c VkCommandPoolTrimFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkCommandPoolTrimFlags # toConstr :: VkCommandPoolTrimFlags -> Constr # dataTypeOf :: VkCommandPoolTrimFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkCommandPoolTrimFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkCommandPoolTrimFlags) # gmapT :: (forall b. Data b => b -> b) -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkCommandPoolTrimFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkCommandPoolTrimFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkCommandPoolTrimFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkCommandPoolTrimFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkCommandPoolTrimFlags -> m VkCommandPoolTrimFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkCommandPoolTrimFlags -> m VkCommandPoolTrimFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkCommandPoolTrimFlags -> m VkCommandPoolTrimFlags #
Num VkCommandPoolTrimFlags Source #
Methods (+) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # (-) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # (*) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # negate :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # abs :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # signum :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # fromInteger :: Integer -> VkCommandPoolTrimFlags #
Ord VkCommandPoolTrimFlags Source #
Methods compare :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Ordering # (<) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool # (<=) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool # (>) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool # (>=) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> Bool # max :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # min :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags #
Read VkCommandPoolTrimFlags Source #
Methods readsPrec :: Int -> ReadS VkCommandPoolTrimFlags # readList :: ReadS [VkCommandPoolTrimFlags] # readPrec :: ReadPrec VkCommandPoolTrimFlags # readListPrec :: ReadPrec [VkCommandPoolTrimFlags] #
Real VkCommandPoolTrimFlags Source #
Methods toRational :: VkCommandPoolTrimFlags -> Rational #
Show VkCommandPoolTrimFlags Source #
Methods showsPrec :: Int -> VkCommandPoolTrimFlags -> ShowS # show :: VkCommandPoolTrimFlags -> String # showList :: [VkCommandPoolTrimFlags] -> ShowS #
Generic VkCommandPoolTrimFlags Source #
Associated Types type Rep VkCommandPoolTrimFlags :: * -> * # Methods from :: VkCommandPoolTrimFlags -> Rep VkCommandPoolTrimFlags x # to :: Rep VkCommandPoolTrimFlags x -> VkCommandPoolTrimFlags #
Storable VkCommandPoolTrimFlags Source #
Methods sizeOf :: VkCommandPoolTrimFlags -> Int # alignment :: VkCommandPoolTrimFlags -> Int # peekElemOff :: Ptr VkCommandPoolTrimFlags -> Int -> IO VkCommandPoolTrimFlags # pokeElemOff :: Ptr VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkCommandPoolTrimFlags # pokeByteOff :: Ptr b -> Int -> VkCommandPoolTrimFlags -> IO () # peek :: Ptr VkCommandPoolTrimFlags -> IO VkCommandPoolTrimFlags # poke :: Ptr VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> IO () #
Bits VkCommandPoolTrimFlags Source #
Methods (.&.) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # (.\|.) :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # xor :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # complement :: VkCommandPoolTrimFlags -> VkCommandPoolTrimFlags # shift :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # rotate :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # zeroBits :: VkCommandPoolTrimFlags # bit :: Int -> VkCommandPoolTrimFlags # setBit :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # clearBit :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # complementBit :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # testBit :: VkCommandPoolTrimFlags -> Int -> Bool # bitSizeMaybe :: VkCommandPoolTrimFlags -> Maybe Int # bitSize :: VkCommandPoolTrimFlags -> Int # isSigned :: VkCommandPoolTrimFlags -> Bool # shiftL :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # unsafeShiftL :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # shiftR :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # unsafeShiftR :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # rotateL :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # rotateR :: VkCommandPoolTrimFlags -> Int -> VkCommandPoolTrimFlags # popCount :: VkCommandPoolTrimFlags -> Int #
FiniteBits VkCommandPoolTrimFlags Source #
Methods finiteBitSize :: VkCommandPoolTrimFlags -> Int # countLeadingZeros :: VkCommandPoolTrimFlags -> Int # countTrailingZeros :: VkCommandPoolTrimFlags -> Int #
type Rep VkCommandPoolTrimFlags Source #
type Rep VkCommandPoolTrimFlags = D1 (MetaData "VkCommandPoolTrimFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkCommandPoolTrimFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkCommandPoolTrimFlagsKHR Source #

Constructors

VkCommandPoolTrimFlagsKHR VkFlags

Instances

Bounded VkCommandPoolTrimFlagsKHR Source #
Methods minBound :: VkCommandPoolTrimFlagsKHR # maxBound :: VkCommandPoolTrimFlagsKHR #
Enum VkCommandPoolTrimFlagsKHR Source #
Methods succ :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # pred :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # toEnum :: Int -> VkCommandPoolTrimFlagsKHR # fromEnum :: VkCommandPoolTrimFlagsKHR -> Int # enumFrom :: VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR] # enumFromThen :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR] # enumFromTo :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR] # enumFromThenTo :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> [VkCommandPoolTrimFlagsKHR] #
Eq VkCommandPoolTrimFlagsKHR Source #
Methods (==) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool # (/=) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool #
Integral VkCommandPoolTrimFlagsKHR Source #
Methods quot :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # rem :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # div :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # mod :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # quotRem :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> (VkCommandPoolTrimFlagsKHR, VkCommandPoolTrimFlagsKHR) # divMod :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> (VkCommandPoolTrimFlagsKHR, VkCommandPoolTrimFlagsKHR) # toInteger :: VkCommandPoolTrimFlagsKHR -> Integer #
Data VkCommandPoolTrimFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkCommandPoolTrimFlagsKHR -> c VkCommandPoolTrimFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkCommandPoolTrimFlagsKHR # toConstr :: VkCommandPoolTrimFlagsKHR -> Constr # dataTypeOf :: VkCommandPoolTrimFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkCommandPoolTrimFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkCommandPoolTrimFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkCommandPoolTrimFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkCommandPoolTrimFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkCommandPoolTrimFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkCommandPoolTrimFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkCommandPoolTrimFlagsKHR -> m VkCommandPoolTrimFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkCommandPoolTrimFlagsKHR -> m VkCommandPoolTrimFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkCommandPoolTrimFlagsKHR -> m VkCommandPoolTrimFlagsKHR #
Num VkCommandPoolTrimFlagsKHR Source #
Methods (+) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # (-) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # (*) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # negate :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # abs :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # signum :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # fromInteger :: Integer -> VkCommandPoolTrimFlagsKHR #
Ord VkCommandPoolTrimFlagsKHR Source #
Methods compare :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Ordering # (<) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool # (<=) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool # (>) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool # (>=) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> Bool # max :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # min :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR #
Read VkCommandPoolTrimFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkCommandPoolTrimFlagsKHR # readList :: ReadS [VkCommandPoolTrimFlagsKHR] # readPrec :: ReadPrec VkCommandPoolTrimFlagsKHR # readListPrec :: ReadPrec [VkCommandPoolTrimFlagsKHR] #
Real VkCommandPoolTrimFlagsKHR Source #
Methods toRational :: VkCommandPoolTrimFlagsKHR -> Rational #
Show VkCommandPoolTrimFlagsKHR Source #
Methods showsPrec :: Int -> VkCommandPoolTrimFlagsKHR -> ShowS # show :: VkCommandPoolTrimFlagsKHR -> String # showList :: [VkCommandPoolTrimFlagsKHR] -> ShowS #
Generic VkCommandPoolTrimFlagsKHR Source #
Associated Types type Rep VkCommandPoolTrimFlagsKHR :: * -> * # Methods from :: VkCommandPoolTrimFlagsKHR -> Rep VkCommandPoolTrimFlagsKHR x # to :: Rep VkCommandPoolTrimFlagsKHR x -> VkCommandPoolTrimFlagsKHR #
Storable VkCommandPoolTrimFlagsKHR Source #
Methods sizeOf :: VkCommandPoolTrimFlagsKHR -> Int # alignment :: VkCommandPoolTrimFlagsKHR -> Int # peekElemOff :: Ptr VkCommandPoolTrimFlagsKHR -> Int -> IO VkCommandPoolTrimFlagsKHR # pokeElemOff :: Ptr VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkCommandPoolTrimFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkCommandPoolTrimFlagsKHR -> IO () # peek :: Ptr VkCommandPoolTrimFlagsKHR -> IO VkCommandPoolTrimFlagsKHR # poke :: Ptr VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> IO () #
Bits VkCommandPoolTrimFlagsKHR Source #
Methods (.&.) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # (.\|.) :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # xor :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # complement :: VkCommandPoolTrimFlagsKHR -> VkCommandPoolTrimFlagsKHR # shift :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # rotate :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # zeroBits :: VkCommandPoolTrimFlagsKHR # bit :: Int -> VkCommandPoolTrimFlagsKHR # setBit :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # clearBit :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # complementBit :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # testBit :: VkCommandPoolTrimFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkCommandPoolTrimFlagsKHR -> Maybe Int # bitSize :: VkCommandPoolTrimFlagsKHR -> Int # isSigned :: VkCommandPoolTrimFlagsKHR -> Bool # shiftL :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # unsafeShiftL :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # shiftR :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # unsafeShiftR :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # rotateL :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # rotateR :: VkCommandPoolTrimFlagsKHR -> Int -> VkCommandPoolTrimFlagsKHR # popCount :: VkCommandPoolTrimFlagsKHR -> Int #
FiniteBits VkCommandPoolTrimFlagsKHR Source #
Methods finiteBitSize :: VkCommandPoolTrimFlagsKHR -> Int # countLeadingZeros :: VkCommandPoolTrimFlagsKHR -> Int # countTrailingZeros :: VkCommandPoolTrimFlagsKHR -> Int #
type Rep VkCommandPoolTrimFlagsKHR Source #
type Rep VkCommandPoolTrimFlagsKHR = D1 (MetaData "VkCommandPoolTrimFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkCommandPoolTrimFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkDebugUtilsMessengerCallbackDataFlagsEXT Source #

Constructors

VkDebugUtilsMessengerCallbackDataFlagsEXT VkFlags

Instances

Bounded VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods minBound :: VkDebugUtilsMessengerCallbackDataFlagsEXT # maxBound :: VkDebugUtilsMessengerCallbackDataFlagsEXT #
Enum VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods succ :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # pred :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # toEnum :: Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # fromEnum :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int # enumFrom :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> [VkDebugUtilsMessengerCallbackDataFlagsEXT] # enumFromThen :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> [VkDebugUtilsMessengerCallbackDataFlagsEXT] # enumFromTo :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> [VkDebugUtilsMessengerCallbackDataFlagsEXT] # enumFromThenTo :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> [VkDebugUtilsMessengerCallbackDataFlagsEXT] #
Eq VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods (==) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool # (/=) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool #
Integral VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods quot :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # rem :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # div :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # mod :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # quotRem :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> (VkDebugUtilsMessengerCallbackDataFlagsEXT, VkDebugUtilsMessengerCallbackDataFlagsEXT) # divMod :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> (VkDebugUtilsMessengerCallbackDataFlagsEXT, VkDebugUtilsMessengerCallbackDataFlagsEXT) # toInteger :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Integer #
Data VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> c VkDebugUtilsMessengerCallbackDataFlagsEXT # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkDebugUtilsMessengerCallbackDataFlagsEXT # toConstr :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Constr # dataTypeOf :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkDebugUtilsMessengerCallbackDataFlagsEXT) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkDebugUtilsMessengerCallbackDataFlagsEXT) # gmapT :: (forall b. Data b => b -> b) -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> r # gmapQ :: (forall d. Data d => d -> u) -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> m VkDebugUtilsMessengerCallbackDataFlagsEXT # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> m VkDebugUtilsMessengerCallbackDataFlagsEXT # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> m VkDebugUtilsMessengerCallbackDataFlagsEXT #
Num VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods (+) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # (-) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # (*) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # negate :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # abs :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # signum :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # fromInteger :: Integer -> VkDebugUtilsMessengerCallbackDataFlagsEXT #
Ord VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods compare :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Ordering # (<) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool # (<=) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool # (>) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool # (>=) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool # max :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # min :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT #
Read VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods readsPrec :: Int -> ReadS VkDebugUtilsMessengerCallbackDataFlagsEXT # readList :: ReadS [VkDebugUtilsMessengerCallbackDataFlagsEXT] # readPrec :: ReadPrec VkDebugUtilsMessengerCallbackDataFlagsEXT # readListPrec :: ReadPrec [VkDebugUtilsMessengerCallbackDataFlagsEXT] #
Real VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods toRational :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Rational #
Show VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods showsPrec :: Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> ShowS # show :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> String # showList :: [VkDebugUtilsMessengerCallbackDataFlagsEXT] -> ShowS #
Generic VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Associated Types type Rep VkDebugUtilsMessengerCallbackDataFlagsEXT :: * -> * # Methods from :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Rep VkDebugUtilsMessengerCallbackDataFlagsEXT x # to :: Rep VkDebugUtilsMessengerCallbackDataFlagsEXT x -> VkDebugUtilsMessengerCallbackDataFlagsEXT #
Storable VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods sizeOf :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int # alignment :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int # peekElemOff :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT # pokeElemOff :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT # pokeByteOff :: Ptr b -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO () # peek :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO VkDebugUtilsMessengerCallbackDataFlagsEXT # poke :: Ptr VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> IO () #
Bits VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods (.&.) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # (.\|.) :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # xor :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # complement :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> VkDebugUtilsMessengerCallbackDataFlagsEXT # shift :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # rotate :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # zeroBits :: VkDebugUtilsMessengerCallbackDataFlagsEXT # bit :: Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # setBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # clearBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # complementBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # testBit :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> Bool # bitSizeMaybe :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Maybe Int # bitSize :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int # isSigned :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Bool # shiftL :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # unsafeShiftL :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # shiftR :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # unsafeShiftR :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # rotateL :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # rotateR :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int -> VkDebugUtilsMessengerCallbackDataFlagsEXT # popCount :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int #
FiniteBits VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
Methods finiteBitSize :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int # countLeadingZeros :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int # countTrailingZeros :: VkDebugUtilsMessengerCallbackDataFlagsEXT -> Int #
type Rep VkDebugUtilsMessengerCallbackDataFlagsEXT Source #
type Rep VkDebugUtilsMessengerCallbackDataFlagsEXT = D1 (MetaData "VkDebugUtilsMessengerCallbackDataFlagsEXT" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkDebugUtilsMessengerCallbackDataFlagsEXT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkDebugUtilsMessengerCreateFlagsEXT Source #

Constructors

VkDebugUtilsMessengerCreateFlagsEXT VkFlags

Instances

Bounded VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods minBound :: VkDebugUtilsMessengerCreateFlagsEXT # maxBound :: VkDebugUtilsMessengerCreateFlagsEXT #
Enum VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods succ :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # pred :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # toEnum :: Int -> VkDebugUtilsMessengerCreateFlagsEXT # fromEnum :: VkDebugUtilsMessengerCreateFlagsEXT -> Int # enumFrom :: VkDebugUtilsMessengerCreateFlagsEXT -> [VkDebugUtilsMessengerCreateFlagsEXT] # enumFromThen :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> [VkDebugUtilsMessengerCreateFlagsEXT] # enumFromTo :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> [VkDebugUtilsMessengerCreateFlagsEXT] # enumFromThenTo :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> [VkDebugUtilsMessengerCreateFlagsEXT] #
Eq VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods (==) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool # (/=) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool #
Integral VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods quot :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # rem :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # div :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # mod :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # quotRem :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> (VkDebugUtilsMessengerCreateFlagsEXT, VkDebugUtilsMessengerCreateFlagsEXT) # divMod :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> (VkDebugUtilsMessengerCreateFlagsEXT, VkDebugUtilsMessengerCreateFlagsEXT) # toInteger :: VkDebugUtilsMessengerCreateFlagsEXT -> Integer #
Data VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkDebugUtilsMessengerCreateFlagsEXT -> c VkDebugUtilsMessengerCreateFlagsEXT # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkDebugUtilsMessengerCreateFlagsEXT # toConstr :: VkDebugUtilsMessengerCreateFlagsEXT -> Constr # dataTypeOf :: VkDebugUtilsMessengerCreateFlagsEXT -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkDebugUtilsMessengerCreateFlagsEXT) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkDebugUtilsMessengerCreateFlagsEXT) # gmapT :: (forall b. Data b => b -> b) -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkDebugUtilsMessengerCreateFlagsEXT -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkDebugUtilsMessengerCreateFlagsEXT -> r # gmapQ :: (forall d. Data d => d -> u) -> VkDebugUtilsMessengerCreateFlagsEXT -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkDebugUtilsMessengerCreateFlagsEXT -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkDebugUtilsMessengerCreateFlagsEXT -> m VkDebugUtilsMessengerCreateFlagsEXT # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDebugUtilsMessengerCreateFlagsEXT -> m VkDebugUtilsMessengerCreateFlagsEXT # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDebugUtilsMessengerCreateFlagsEXT -> m VkDebugUtilsMessengerCreateFlagsEXT #
Num VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods (+) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # (-) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # (*) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # negate :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # abs :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # signum :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # fromInteger :: Integer -> VkDebugUtilsMessengerCreateFlagsEXT #
Ord VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods compare :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> Ordering # (<) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool # (<=) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool # (>) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool # (>=) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> Bool # max :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # min :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT #
Read VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods readsPrec :: Int -> ReadS VkDebugUtilsMessengerCreateFlagsEXT # readList :: ReadS [VkDebugUtilsMessengerCreateFlagsEXT] # readPrec :: ReadPrec VkDebugUtilsMessengerCreateFlagsEXT # readListPrec :: ReadPrec [VkDebugUtilsMessengerCreateFlagsEXT] #
Real VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods toRational :: VkDebugUtilsMessengerCreateFlagsEXT -> Rational #
Show VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods showsPrec :: Int -> VkDebugUtilsMessengerCreateFlagsEXT -> ShowS # show :: VkDebugUtilsMessengerCreateFlagsEXT -> String # showList :: [VkDebugUtilsMessengerCreateFlagsEXT] -> ShowS #
Generic VkDebugUtilsMessengerCreateFlagsEXT Source #
Associated Types type Rep VkDebugUtilsMessengerCreateFlagsEXT :: * -> * # Methods from :: VkDebugUtilsMessengerCreateFlagsEXT -> Rep VkDebugUtilsMessengerCreateFlagsEXT x # to :: Rep VkDebugUtilsMessengerCreateFlagsEXT x -> VkDebugUtilsMessengerCreateFlagsEXT #
Storable VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods sizeOf :: VkDebugUtilsMessengerCreateFlagsEXT -> Int # alignment :: VkDebugUtilsMessengerCreateFlagsEXT -> Int # peekElemOff :: Ptr VkDebugUtilsMessengerCreateFlagsEXT -> Int -> IO VkDebugUtilsMessengerCreateFlagsEXT # pokeElemOff :: Ptr VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDebugUtilsMessengerCreateFlagsEXT # pokeByteOff :: Ptr b -> Int -> VkDebugUtilsMessengerCreateFlagsEXT -> IO () # peek :: Ptr VkDebugUtilsMessengerCreateFlagsEXT -> IO VkDebugUtilsMessengerCreateFlagsEXT # poke :: Ptr VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> IO () #
Bits VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods (.&.) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # (.\|.) :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # xor :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # complement :: VkDebugUtilsMessengerCreateFlagsEXT -> VkDebugUtilsMessengerCreateFlagsEXT # shift :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # rotate :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # zeroBits :: VkDebugUtilsMessengerCreateFlagsEXT # bit :: Int -> VkDebugUtilsMessengerCreateFlagsEXT # setBit :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # clearBit :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # complementBit :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # testBit :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> Bool # bitSizeMaybe :: VkDebugUtilsMessengerCreateFlagsEXT -> Maybe Int # bitSize :: VkDebugUtilsMessengerCreateFlagsEXT -> Int # isSigned :: VkDebugUtilsMessengerCreateFlagsEXT -> Bool # shiftL :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # unsafeShiftL :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # shiftR :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # unsafeShiftR :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # rotateL :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # rotateR :: VkDebugUtilsMessengerCreateFlagsEXT -> Int -> VkDebugUtilsMessengerCreateFlagsEXT # popCount :: VkDebugUtilsMessengerCreateFlagsEXT -> Int #
FiniteBits VkDebugUtilsMessengerCreateFlagsEXT Source #
Methods finiteBitSize :: VkDebugUtilsMessengerCreateFlagsEXT -> Int # countLeadingZeros :: VkDebugUtilsMessengerCreateFlagsEXT -> Int # countTrailingZeros :: VkDebugUtilsMessengerCreateFlagsEXT -> Int #
type Rep VkDebugUtilsMessengerCreateFlagsEXT Source #
type Rep VkDebugUtilsMessengerCreateFlagsEXT = D1 (MetaData "VkDebugUtilsMessengerCreateFlagsEXT" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkDebugUtilsMessengerCreateFlagsEXT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkDescriptorPoolResetFlags Source #

Constructors

VkDescriptorPoolResetFlags VkFlags

Instances

Bounded VkDescriptorPoolResetFlags Source #
Methods minBound :: VkDescriptorPoolResetFlags # maxBound :: VkDescriptorPoolResetFlags #
Enum VkDescriptorPoolResetFlags Source #
Methods succ :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # pred :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # toEnum :: Int -> VkDescriptorPoolResetFlags # fromEnum :: VkDescriptorPoolResetFlags -> Int # enumFrom :: VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags] # enumFromThen :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags] # enumFromTo :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags] # enumFromThenTo :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> [VkDescriptorPoolResetFlags] #
Eq VkDescriptorPoolResetFlags Source #
Methods (==) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool # (/=) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool #
Integral VkDescriptorPoolResetFlags Source #
Methods quot :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # rem :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # div :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # mod :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # quotRem :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> (VkDescriptorPoolResetFlags, VkDescriptorPoolResetFlags) # divMod :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> (VkDescriptorPoolResetFlags, VkDescriptorPoolResetFlags) # toInteger :: VkDescriptorPoolResetFlags -> Integer #
Data VkDescriptorPoolResetFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkDescriptorPoolResetFlags -> c VkDescriptorPoolResetFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkDescriptorPoolResetFlags # toConstr :: VkDescriptorPoolResetFlags -> Constr # dataTypeOf :: VkDescriptorPoolResetFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkDescriptorPoolResetFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkDescriptorPoolResetFlags) # gmapT :: (forall b. Data b => b -> b) -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkDescriptorPoolResetFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkDescriptorPoolResetFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkDescriptorPoolResetFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkDescriptorPoolResetFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkDescriptorPoolResetFlags -> m VkDescriptorPoolResetFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDescriptorPoolResetFlags -> m VkDescriptorPoolResetFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDescriptorPoolResetFlags -> m VkDescriptorPoolResetFlags #
Num VkDescriptorPoolResetFlags Source #
Methods (+) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # (-) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # (*) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # negate :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # abs :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # signum :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # fromInteger :: Integer -> VkDescriptorPoolResetFlags #
Ord VkDescriptorPoolResetFlags Source #
Methods compare :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Ordering # (<) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool # (<=) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool # (>) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool # (>=) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> Bool # max :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # min :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags #
Read VkDescriptorPoolResetFlags Source #
Methods readsPrec :: Int -> ReadS VkDescriptorPoolResetFlags # readList :: ReadS [VkDescriptorPoolResetFlags] # readPrec :: ReadPrec VkDescriptorPoolResetFlags # readListPrec :: ReadPrec [VkDescriptorPoolResetFlags] #
Real VkDescriptorPoolResetFlags Source #
Methods toRational :: VkDescriptorPoolResetFlags -> Rational #
Show VkDescriptorPoolResetFlags Source #
Methods showsPrec :: Int -> VkDescriptorPoolResetFlags -> ShowS # show :: VkDescriptorPoolResetFlags -> String # showList :: [VkDescriptorPoolResetFlags] -> ShowS #
Generic VkDescriptorPoolResetFlags Source #
Associated Types type Rep VkDescriptorPoolResetFlags :: * -> * # Methods from :: VkDescriptorPoolResetFlags -> Rep VkDescriptorPoolResetFlags x # to :: Rep VkDescriptorPoolResetFlags x -> VkDescriptorPoolResetFlags #
Storable VkDescriptorPoolResetFlags Source #
Methods sizeOf :: VkDescriptorPoolResetFlags -> Int # alignment :: VkDescriptorPoolResetFlags -> Int # peekElemOff :: Ptr VkDescriptorPoolResetFlags -> Int -> IO VkDescriptorPoolResetFlags # pokeElemOff :: Ptr VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDescriptorPoolResetFlags # pokeByteOff :: Ptr b -> Int -> VkDescriptorPoolResetFlags -> IO () # peek :: Ptr VkDescriptorPoolResetFlags -> IO VkDescriptorPoolResetFlags # poke :: Ptr VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> IO () #
Bits VkDescriptorPoolResetFlags Source #
Methods (.&.) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # (.\|.) :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # xor :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # complement :: VkDescriptorPoolResetFlags -> VkDescriptorPoolResetFlags # shift :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # rotate :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # zeroBits :: VkDescriptorPoolResetFlags # bit :: Int -> VkDescriptorPoolResetFlags # setBit :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # clearBit :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # complementBit :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # testBit :: VkDescriptorPoolResetFlags -> Int -> Bool # bitSizeMaybe :: VkDescriptorPoolResetFlags -> Maybe Int # bitSize :: VkDescriptorPoolResetFlags -> Int # isSigned :: VkDescriptorPoolResetFlags -> Bool # shiftL :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # unsafeShiftL :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # shiftR :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # unsafeShiftR :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # rotateL :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # rotateR :: VkDescriptorPoolResetFlags -> Int -> VkDescriptorPoolResetFlags # popCount :: VkDescriptorPoolResetFlags -> Int #
FiniteBits VkDescriptorPoolResetFlags Source #
Methods finiteBitSize :: VkDescriptorPoolResetFlags -> Int # countLeadingZeros :: VkDescriptorPoolResetFlags -> Int # countTrailingZeros :: VkDescriptorPoolResetFlags -> Int #
type Rep VkDescriptorPoolResetFlags Source #
type Rep VkDescriptorPoolResetFlags = D1 (MetaData "VkDescriptorPoolResetFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkDescriptorPoolResetFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkDescriptorUpdateTemplateCreateFlags Source #

Constructors

VkDescriptorUpdateTemplateCreateFlags VkFlags

Instances

Bounded VkDescriptorUpdateTemplateCreateFlags Source #
Methods minBound :: VkDescriptorUpdateTemplateCreateFlags # maxBound :: VkDescriptorUpdateTemplateCreateFlags #
Enum VkDescriptorUpdateTemplateCreateFlags Source #
Methods succ :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # pred :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # toEnum :: Int -> VkDescriptorUpdateTemplateCreateFlags # fromEnum :: VkDescriptorUpdateTemplateCreateFlags -> Int # enumFrom :: VkDescriptorUpdateTemplateCreateFlags -> [VkDescriptorUpdateTemplateCreateFlags] # enumFromThen :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> [VkDescriptorUpdateTemplateCreateFlags] # enumFromTo :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> [VkDescriptorUpdateTemplateCreateFlags] # enumFromThenTo :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> [VkDescriptorUpdateTemplateCreateFlags] #
Eq VkDescriptorUpdateTemplateCreateFlags Source #
Methods (==) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> Bool # (/=) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> Bool #
Integral VkDescriptorUpdateTemplateCreateFlags Source #
Methods quot :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # rem :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # div :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # mod :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # quotRem :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> (VkDescriptorUpdateTemplateCreateFlags, VkDescriptorUpdateTemplateCreateFlags) # divMod :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> (VkDescriptorUpdateTemplateCreateFlags, VkDescriptorUpdateTemplateCreateFlags) # toInteger :: VkDescriptorUpdateTemplateCreateFlags -> Integer #
Data VkDescriptorUpdateTemplateCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkDescriptorUpdateTemplateCreateFlags -> c VkDescriptorUpdateTemplateCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkDescriptorUpdateTemplateCreateFlags # toConstr :: VkDescriptorUpdateTemplateCreateFlags -> Constr # dataTypeOf :: VkDescriptorUpdateTemplateCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkDescriptorUpdateTemplateCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkDescriptorUpdateTemplateCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkDescriptorUpdateTemplateCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkDescriptorUpdateTemplateCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkDescriptorUpdateTemplateCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkDescriptorUpdateTemplateCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkDescriptorUpdateTemplateCreateFlags -> m VkDescriptorUpdateTemplateCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDescriptorUpdateTemplateCreateFlags -> m VkDescriptorUpdateTemplateCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDescriptorUpdateTemplateCreateFlags -> m VkDescriptorUpdateTemplateCreateFlags #
Num VkDescriptorUpdateTemplateCreateFlags Source #
Methods (+) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # (-) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # (*) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # negate :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # abs :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # signum :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # fromInteger :: Integer -> VkDescriptorUpdateTemplateCreateFlags #
Ord VkDescriptorUpdateTemplateCreateFlags Source #
Methods compare :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> Ordering # (<) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> Bool # (<=) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> Bool # (>) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> Bool # (>=) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> Bool # max :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # min :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags #
Read VkDescriptorUpdateTemplateCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkDescriptorUpdateTemplateCreateFlags # readList :: ReadS [VkDescriptorUpdateTemplateCreateFlags] # readPrec :: ReadPrec VkDescriptorUpdateTemplateCreateFlags # readListPrec :: ReadPrec [VkDescriptorUpdateTemplateCreateFlags] #
Real VkDescriptorUpdateTemplateCreateFlags Source #
Methods toRational :: VkDescriptorUpdateTemplateCreateFlags -> Rational #
Show VkDescriptorUpdateTemplateCreateFlags Source #
Methods showsPrec :: Int -> VkDescriptorUpdateTemplateCreateFlags -> ShowS # show :: VkDescriptorUpdateTemplateCreateFlags -> String # showList :: [VkDescriptorUpdateTemplateCreateFlags] -> ShowS #
Generic VkDescriptorUpdateTemplateCreateFlags Source #
Associated Types type Rep VkDescriptorUpdateTemplateCreateFlags :: * -> * # Methods from :: VkDescriptorUpdateTemplateCreateFlags -> Rep VkDescriptorUpdateTemplateCreateFlags x # to :: Rep VkDescriptorUpdateTemplateCreateFlags x -> VkDescriptorUpdateTemplateCreateFlags #
Storable VkDescriptorUpdateTemplateCreateFlags Source #
Methods sizeOf :: VkDescriptorUpdateTemplateCreateFlags -> Int # alignment :: VkDescriptorUpdateTemplateCreateFlags -> Int # peekElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlags -> Int -> IO VkDescriptorUpdateTemplateCreateFlags # pokeElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDescriptorUpdateTemplateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkDescriptorUpdateTemplateCreateFlags -> IO () # peek :: Ptr VkDescriptorUpdateTemplateCreateFlags -> IO VkDescriptorUpdateTemplateCreateFlags # poke :: Ptr VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> IO () #
Bits VkDescriptorUpdateTemplateCreateFlags Source #
Methods (.&.) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # (.\|.) :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # xor :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # complement :: VkDescriptorUpdateTemplateCreateFlags -> VkDescriptorUpdateTemplateCreateFlags # shift :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # rotate :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # zeroBits :: VkDescriptorUpdateTemplateCreateFlags # bit :: Int -> VkDescriptorUpdateTemplateCreateFlags # setBit :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # clearBit :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # complementBit :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # testBit :: VkDescriptorUpdateTemplateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkDescriptorUpdateTemplateCreateFlags -> Maybe Int # bitSize :: VkDescriptorUpdateTemplateCreateFlags -> Int # isSigned :: VkDescriptorUpdateTemplateCreateFlags -> Bool # shiftL :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # unsafeShiftL :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # shiftR :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # unsafeShiftR :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # rotateL :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # rotateR :: VkDescriptorUpdateTemplateCreateFlags -> Int -> VkDescriptorUpdateTemplateCreateFlags # popCount :: VkDescriptorUpdateTemplateCreateFlags -> Int #
FiniteBits VkDescriptorUpdateTemplateCreateFlags Source #
Methods finiteBitSize :: VkDescriptorUpdateTemplateCreateFlags -> Int # countLeadingZeros :: VkDescriptorUpdateTemplateCreateFlags -> Int # countTrailingZeros :: VkDescriptorUpdateTemplateCreateFlags -> Int #
type Rep VkDescriptorUpdateTemplateCreateFlags Source #
type Rep VkDescriptorUpdateTemplateCreateFlags = D1 (MetaData "VkDescriptorUpdateTemplateCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkDescriptorUpdateTemplateCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkDescriptorUpdateTemplateCreateFlagsKHR Source #

Constructors

VkDescriptorUpdateTemplateCreateFlagsKHR VkFlags

Instances

Bounded VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods minBound :: VkDescriptorUpdateTemplateCreateFlagsKHR # maxBound :: VkDescriptorUpdateTemplateCreateFlagsKHR #
Enum VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods succ :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # pred :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # toEnum :: Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # fromEnum :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int # enumFrom :: VkDescriptorUpdateTemplateCreateFlagsKHR -> [VkDescriptorUpdateTemplateCreateFlagsKHR] # enumFromThen :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> [VkDescriptorUpdateTemplateCreateFlagsKHR] # enumFromTo :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> [VkDescriptorUpdateTemplateCreateFlagsKHR] # enumFromThenTo :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> [VkDescriptorUpdateTemplateCreateFlagsKHR] #
Eq VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods (==) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool # (/=) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool #
Integral VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods quot :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # rem :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # div :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # mod :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # quotRem :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> (VkDescriptorUpdateTemplateCreateFlagsKHR, VkDescriptorUpdateTemplateCreateFlagsKHR) # divMod :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> (VkDescriptorUpdateTemplateCreateFlagsKHR, VkDescriptorUpdateTemplateCreateFlagsKHR) # toInteger :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Integer #
Data VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkDescriptorUpdateTemplateCreateFlagsKHR -> c VkDescriptorUpdateTemplateCreateFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkDescriptorUpdateTemplateCreateFlagsKHR # toConstr :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Constr # dataTypeOf :: VkDescriptorUpdateTemplateCreateFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkDescriptorUpdateTemplateCreateFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkDescriptorUpdateTemplateCreateFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkDescriptorUpdateTemplateCreateFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkDescriptorUpdateTemplateCreateFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkDescriptorUpdateTemplateCreateFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkDescriptorUpdateTemplateCreateFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkDescriptorUpdateTemplateCreateFlagsKHR -> m VkDescriptorUpdateTemplateCreateFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDescriptorUpdateTemplateCreateFlagsKHR -> m VkDescriptorUpdateTemplateCreateFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDescriptorUpdateTemplateCreateFlagsKHR -> m VkDescriptorUpdateTemplateCreateFlagsKHR #
Num VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods (+) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # (-) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # (*) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # negate :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # abs :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # signum :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # fromInteger :: Integer -> VkDescriptorUpdateTemplateCreateFlagsKHR #
Ord VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods compare :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Ordering # (<) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool # (<=) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool # (>) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool # (>=) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool # max :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # min :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR #
Read VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkDescriptorUpdateTemplateCreateFlagsKHR # readList :: ReadS [VkDescriptorUpdateTemplateCreateFlagsKHR] # readPrec :: ReadPrec VkDescriptorUpdateTemplateCreateFlagsKHR # readListPrec :: ReadPrec [VkDescriptorUpdateTemplateCreateFlagsKHR] #
Real VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods toRational :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Rational #
Show VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods showsPrec :: Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> ShowS # show :: VkDescriptorUpdateTemplateCreateFlagsKHR -> String # showList :: [VkDescriptorUpdateTemplateCreateFlagsKHR] -> ShowS #
Generic VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Associated Types type Rep VkDescriptorUpdateTemplateCreateFlagsKHR :: * -> * # Methods from :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Rep VkDescriptorUpdateTemplateCreateFlagsKHR x # to :: Rep VkDescriptorUpdateTemplateCreateFlagsKHR x -> VkDescriptorUpdateTemplateCreateFlagsKHR #
Storable VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods sizeOf :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int # alignment :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int # peekElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> IO VkDescriptorUpdateTemplateCreateFlagsKHR # pokeElemOff :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDescriptorUpdateTemplateCreateFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO () # peek :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR -> IO VkDescriptorUpdateTemplateCreateFlagsKHR # poke :: Ptr VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> IO () #
Bits VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods (.&.) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # (.\|.) :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # xor :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # complement :: VkDescriptorUpdateTemplateCreateFlagsKHR -> VkDescriptorUpdateTemplateCreateFlagsKHR # shift :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # rotate :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # zeroBits :: VkDescriptorUpdateTemplateCreateFlagsKHR # bit :: Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # setBit :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # clearBit :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # complementBit :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # testBit :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Maybe Int # bitSize :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int # isSigned :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Bool # shiftL :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # unsafeShiftL :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # shiftR :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # unsafeShiftR :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # rotateL :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # rotateR :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int -> VkDescriptorUpdateTemplateCreateFlagsKHR # popCount :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int #
FiniteBits VkDescriptorUpdateTemplateCreateFlagsKHR Source #
Methods finiteBitSize :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int # countLeadingZeros :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int # countTrailingZeros :: VkDescriptorUpdateTemplateCreateFlagsKHR -> Int #
type Rep VkDescriptorUpdateTemplateCreateFlagsKHR Source #
type Rep VkDescriptorUpdateTemplateCreateFlagsKHR = D1 (MetaData "VkDescriptorUpdateTemplateCreateFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkDescriptorUpdateTemplateCreateFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkDeviceCreateFlags Source #

Constructors

VkDeviceCreateFlags VkFlags

Instances

Bounded VkDeviceCreateFlags Source #
Methods minBound :: VkDeviceCreateFlags # maxBound :: VkDeviceCreateFlags #
Enum VkDeviceCreateFlags Source #
Methods succ :: VkDeviceCreateFlags -> VkDeviceCreateFlags # pred :: VkDeviceCreateFlags -> VkDeviceCreateFlags # toEnum :: Int -> VkDeviceCreateFlags # fromEnum :: VkDeviceCreateFlags -> Int # enumFrom :: VkDeviceCreateFlags -> [VkDeviceCreateFlags] # enumFromThen :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> [VkDeviceCreateFlags] # enumFromTo :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> [VkDeviceCreateFlags] # enumFromThenTo :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags -> [VkDeviceCreateFlags] #
Eq VkDeviceCreateFlags Source #
Methods (==) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool # (/=) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool #
Integral VkDeviceCreateFlags Source #
Methods quot :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # rem :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # div :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # mod :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # quotRem :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> (VkDeviceCreateFlags, VkDeviceCreateFlags) # divMod :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> (VkDeviceCreateFlags, VkDeviceCreateFlags) # toInteger :: VkDeviceCreateFlags -> Integer #
Data VkDeviceCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkDeviceCreateFlags -> c VkDeviceCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkDeviceCreateFlags # toConstr :: VkDeviceCreateFlags -> Constr # dataTypeOf :: VkDeviceCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkDeviceCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkDeviceCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkDeviceCreateFlags -> VkDeviceCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkDeviceCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkDeviceCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkDeviceCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkDeviceCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkDeviceCreateFlags -> m VkDeviceCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDeviceCreateFlags -> m VkDeviceCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDeviceCreateFlags -> m VkDeviceCreateFlags #
Num VkDeviceCreateFlags Source #
Methods (+) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # (-) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # (*) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # negate :: VkDeviceCreateFlags -> VkDeviceCreateFlags # abs :: VkDeviceCreateFlags -> VkDeviceCreateFlags # signum :: VkDeviceCreateFlags -> VkDeviceCreateFlags # fromInteger :: Integer -> VkDeviceCreateFlags #
Ord VkDeviceCreateFlags Source #
Methods compare :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Ordering # (<) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool # (<=) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool # (>) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool # (>=) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> Bool # max :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # min :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags #
Read VkDeviceCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkDeviceCreateFlags # readList :: ReadS [VkDeviceCreateFlags] # readPrec :: ReadPrec VkDeviceCreateFlags # readListPrec :: ReadPrec [VkDeviceCreateFlags] #
Real VkDeviceCreateFlags Source #
Methods toRational :: VkDeviceCreateFlags -> Rational #
Show VkDeviceCreateFlags Source #
Methods showsPrec :: Int -> VkDeviceCreateFlags -> ShowS # show :: VkDeviceCreateFlags -> String # showList :: [VkDeviceCreateFlags] -> ShowS #
Generic VkDeviceCreateFlags Source #
Associated Types type Rep VkDeviceCreateFlags :: * -> * # Methods from :: VkDeviceCreateFlags -> Rep VkDeviceCreateFlags x # to :: Rep VkDeviceCreateFlags x -> VkDeviceCreateFlags #
Storable VkDeviceCreateFlags Source #
Methods sizeOf :: VkDeviceCreateFlags -> Int # alignment :: VkDeviceCreateFlags -> Int # peekElemOff :: Ptr VkDeviceCreateFlags -> Int -> IO VkDeviceCreateFlags # pokeElemOff :: Ptr VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDeviceCreateFlags # pokeByteOff :: Ptr b -> Int -> VkDeviceCreateFlags -> IO () # peek :: Ptr VkDeviceCreateFlags -> IO VkDeviceCreateFlags # poke :: Ptr VkDeviceCreateFlags -> VkDeviceCreateFlags -> IO () #
Bits VkDeviceCreateFlags Source #
Methods (.&.) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # (.\|.) :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # xor :: VkDeviceCreateFlags -> VkDeviceCreateFlags -> VkDeviceCreateFlags # complement :: VkDeviceCreateFlags -> VkDeviceCreateFlags # shift :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # rotate :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # zeroBits :: VkDeviceCreateFlags # bit :: Int -> VkDeviceCreateFlags # setBit :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # clearBit :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # complementBit :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # testBit :: VkDeviceCreateFlags -> Int -> Bool # bitSizeMaybe :: VkDeviceCreateFlags -> Maybe Int # bitSize :: VkDeviceCreateFlags -> Int # isSigned :: VkDeviceCreateFlags -> Bool # shiftL :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # unsafeShiftL :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # shiftR :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # unsafeShiftR :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # rotateL :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # rotateR :: VkDeviceCreateFlags -> Int -> VkDeviceCreateFlags # popCount :: VkDeviceCreateFlags -> Int #
FiniteBits VkDeviceCreateFlags Source #
Methods finiteBitSize :: VkDeviceCreateFlags -> Int # countLeadingZeros :: VkDeviceCreateFlags -> Int # countTrailingZeros :: VkDeviceCreateFlags -> Int #
type Rep VkDeviceCreateFlags Source #
type Rep VkDeviceCreateFlags = D1 (MetaData "VkDeviceCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkDeviceCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkDisplayModeCreateFlagsKHR Source #

Constructors

VkDisplayModeCreateFlagsKHR VkFlags

Instances

Bounded VkDisplayModeCreateFlagsKHR Source #
Methods minBound :: VkDisplayModeCreateFlagsKHR # maxBound :: VkDisplayModeCreateFlagsKHR #
Enum VkDisplayModeCreateFlagsKHR Source #
Methods succ :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # pred :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # toEnum :: Int -> VkDisplayModeCreateFlagsKHR # fromEnum :: VkDisplayModeCreateFlagsKHR -> Int # enumFrom :: VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR] # enumFromThen :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR] # enumFromTo :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR] # enumFromThenTo :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> [VkDisplayModeCreateFlagsKHR] #
Eq VkDisplayModeCreateFlagsKHR Source #
Methods (==) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool # (/=) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool #
Integral VkDisplayModeCreateFlagsKHR Source #
Methods quot :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # rem :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # div :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # mod :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # quotRem :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> (VkDisplayModeCreateFlagsKHR, VkDisplayModeCreateFlagsKHR) # divMod :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> (VkDisplayModeCreateFlagsKHR, VkDisplayModeCreateFlagsKHR) # toInteger :: VkDisplayModeCreateFlagsKHR -> Integer #
Data VkDisplayModeCreateFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkDisplayModeCreateFlagsKHR -> c VkDisplayModeCreateFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkDisplayModeCreateFlagsKHR # toConstr :: VkDisplayModeCreateFlagsKHR -> Constr # dataTypeOf :: VkDisplayModeCreateFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkDisplayModeCreateFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkDisplayModeCreateFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkDisplayModeCreateFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkDisplayModeCreateFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkDisplayModeCreateFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkDisplayModeCreateFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkDisplayModeCreateFlagsKHR -> m VkDisplayModeCreateFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDisplayModeCreateFlagsKHR -> m VkDisplayModeCreateFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDisplayModeCreateFlagsKHR -> m VkDisplayModeCreateFlagsKHR #
Num VkDisplayModeCreateFlagsKHR Source #
Methods (+) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # (-) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # (*) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # negate :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # abs :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # signum :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # fromInteger :: Integer -> VkDisplayModeCreateFlagsKHR #
Ord VkDisplayModeCreateFlagsKHR Source #
Methods compare :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Ordering # (<) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool # (<=) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool # (>) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool # (>=) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> Bool # max :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # min :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR #
Read VkDisplayModeCreateFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkDisplayModeCreateFlagsKHR # readList :: ReadS [VkDisplayModeCreateFlagsKHR] # readPrec :: ReadPrec VkDisplayModeCreateFlagsKHR # readListPrec :: ReadPrec [VkDisplayModeCreateFlagsKHR] #
Real VkDisplayModeCreateFlagsKHR Source #
Methods toRational :: VkDisplayModeCreateFlagsKHR -> Rational #
Show VkDisplayModeCreateFlagsKHR Source #
Methods showsPrec :: Int -> VkDisplayModeCreateFlagsKHR -> ShowS # show :: VkDisplayModeCreateFlagsKHR -> String # showList :: [VkDisplayModeCreateFlagsKHR] -> ShowS #
Generic VkDisplayModeCreateFlagsKHR Source #
Associated Types type Rep VkDisplayModeCreateFlagsKHR :: * -> * # Methods from :: VkDisplayModeCreateFlagsKHR -> Rep VkDisplayModeCreateFlagsKHR x # to :: Rep VkDisplayModeCreateFlagsKHR x -> VkDisplayModeCreateFlagsKHR #
Storable VkDisplayModeCreateFlagsKHR Source #
Methods sizeOf :: VkDisplayModeCreateFlagsKHR -> Int # alignment :: VkDisplayModeCreateFlagsKHR -> Int # peekElemOff :: Ptr VkDisplayModeCreateFlagsKHR -> Int -> IO VkDisplayModeCreateFlagsKHR # pokeElemOff :: Ptr VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDisplayModeCreateFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkDisplayModeCreateFlagsKHR -> IO () # peek :: Ptr VkDisplayModeCreateFlagsKHR -> IO VkDisplayModeCreateFlagsKHR # poke :: Ptr VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> IO () #
Bits VkDisplayModeCreateFlagsKHR Source #
Methods (.&.) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # (.\|.) :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # xor :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # complement :: VkDisplayModeCreateFlagsKHR -> VkDisplayModeCreateFlagsKHR # shift :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # rotate :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # zeroBits :: VkDisplayModeCreateFlagsKHR # bit :: Int -> VkDisplayModeCreateFlagsKHR # setBit :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # clearBit :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # complementBit :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # testBit :: VkDisplayModeCreateFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkDisplayModeCreateFlagsKHR -> Maybe Int # bitSize :: VkDisplayModeCreateFlagsKHR -> Int # isSigned :: VkDisplayModeCreateFlagsKHR -> Bool # shiftL :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # unsafeShiftL :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # shiftR :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # unsafeShiftR :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # rotateL :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # rotateR :: VkDisplayModeCreateFlagsKHR -> Int -> VkDisplayModeCreateFlagsKHR # popCount :: VkDisplayModeCreateFlagsKHR -> Int #
FiniteBits VkDisplayModeCreateFlagsKHR Source #
Methods finiteBitSize :: VkDisplayModeCreateFlagsKHR -> Int # countLeadingZeros :: VkDisplayModeCreateFlagsKHR -> Int # countTrailingZeros :: VkDisplayModeCreateFlagsKHR -> Int #
type Rep VkDisplayModeCreateFlagsKHR Source #
type Rep VkDisplayModeCreateFlagsKHR = D1 (MetaData "VkDisplayModeCreateFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkDisplayModeCreateFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkDisplaySurfaceCreateFlagsKHR Source #

Constructors

VkDisplaySurfaceCreateFlagsKHR VkFlags

Instances

Bounded VkDisplaySurfaceCreateFlagsKHR Source #
Methods minBound :: VkDisplaySurfaceCreateFlagsKHR # maxBound :: VkDisplaySurfaceCreateFlagsKHR #
Enum VkDisplaySurfaceCreateFlagsKHR Source #
Methods succ :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # pred :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # toEnum :: Int -> VkDisplaySurfaceCreateFlagsKHR # fromEnum :: VkDisplaySurfaceCreateFlagsKHR -> Int # enumFrom :: VkDisplaySurfaceCreateFlagsKHR -> [VkDisplaySurfaceCreateFlagsKHR] # enumFromThen :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> [VkDisplaySurfaceCreateFlagsKHR] # enumFromTo :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> [VkDisplaySurfaceCreateFlagsKHR] # enumFromThenTo :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> [VkDisplaySurfaceCreateFlagsKHR] #
Eq VkDisplaySurfaceCreateFlagsKHR Source #
Methods (==) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> Bool # (/=) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> Bool #
Integral VkDisplaySurfaceCreateFlagsKHR Source #
Methods quot :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # rem :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # div :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # mod :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # quotRem :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> (VkDisplaySurfaceCreateFlagsKHR, VkDisplaySurfaceCreateFlagsKHR) # divMod :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> (VkDisplaySurfaceCreateFlagsKHR, VkDisplaySurfaceCreateFlagsKHR) # toInteger :: VkDisplaySurfaceCreateFlagsKHR -> Integer #
Data VkDisplaySurfaceCreateFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkDisplaySurfaceCreateFlagsKHR -> c VkDisplaySurfaceCreateFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkDisplaySurfaceCreateFlagsKHR # toConstr :: VkDisplaySurfaceCreateFlagsKHR -> Constr # dataTypeOf :: VkDisplaySurfaceCreateFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkDisplaySurfaceCreateFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkDisplaySurfaceCreateFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkDisplaySurfaceCreateFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkDisplaySurfaceCreateFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkDisplaySurfaceCreateFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkDisplaySurfaceCreateFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkDisplaySurfaceCreateFlagsKHR -> m VkDisplaySurfaceCreateFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDisplaySurfaceCreateFlagsKHR -> m VkDisplaySurfaceCreateFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDisplaySurfaceCreateFlagsKHR -> m VkDisplaySurfaceCreateFlagsKHR #
Num VkDisplaySurfaceCreateFlagsKHR Source #
Methods (+) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # (-) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # (*) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # negate :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # abs :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # signum :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # fromInteger :: Integer -> VkDisplaySurfaceCreateFlagsKHR #
Ord VkDisplaySurfaceCreateFlagsKHR Source #
Methods compare :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> Ordering # (<) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> Bool # (<=) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> Bool # (>) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> Bool # (>=) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> Bool # max :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # min :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR #
Read VkDisplaySurfaceCreateFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkDisplaySurfaceCreateFlagsKHR # readList :: ReadS [VkDisplaySurfaceCreateFlagsKHR] # readPrec :: ReadPrec VkDisplaySurfaceCreateFlagsKHR # readListPrec :: ReadPrec [VkDisplaySurfaceCreateFlagsKHR] #
Real VkDisplaySurfaceCreateFlagsKHR Source #
Methods toRational :: VkDisplaySurfaceCreateFlagsKHR -> Rational #
Show VkDisplaySurfaceCreateFlagsKHR Source #
Methods showsPrec :: Int -> VkDisplaySurfaceCreateFlagsKHR -> ShowS # show :: VkDisplaySurfaceCreateFlagsKHR -> String # showList :: [VkDisplaySurfaceCreateFlagsKHR] -> ShowS #
Generic VkDisplaySurfaceCreateFlagsKHR Source #
Associated Types type Rep VkDisplaySurfaceCreateFlagsKHR :: * -> * # Methods from :: VkDisplaySurfaceCreateFlagsKHR -> Rep VkDisplaySurfaceCreateFlagsKHR x # to :: Rep VkDisplaySurfaceCreateFlagsKHR x -> VkDisplaySurfaceCreateFlagsKHR #
Storable VkDisplaySurfaceCreateFlagsKHR Source #
Methods sizeOf :: VkDisplaySurfaceCreateFlagsKHR -> Int # alignment :: VkDisplaySurfaceCreateFlagsKHR -> Int # peekElemOff :: Ptr VkDisplaySurfaceCreateFlagsKHR -> Int -> IO VkDisplaySurfaceCreateFlagsKHR # pokeElemOff :: Ptr VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDisplaySurfaceCreateFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkDisplaySurfaceCreateFlagsKHR -> IO () # peek :: Ptr VkDisplaySurfaceCreateFlagsKHR -> IO VkDisplaySurfaceCreateFlagsKHR # poke :: Ptr VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> IO () #
Bits VkDisplaySurfaceCreateFlagsKHR Source #
Methods (.&.) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # (.\|.) :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # xor :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # complement :: VkDisplaySurfaceCreateFlagsKHR -> VkDisplaySurfaceCreateFlagsKHR # shift :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # rotate :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # zeroBits :: VkDisplaySurfaceCreateFlagsKHR # bit :: Int -> VkDisplaySurfaceCreateFlagsKHR # setBit :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # clearBit :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # complementBit :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # testBit :: VkDisplaySurfaceCreateFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkDisplaySurfaceCreateFlagsKHR -> Maybe Int # bitSize :: VkDisplaySurfaceCreateFlagsKHR -> Int # isSigned :: VkDisplaySurfaceCreateFlagsKHR -> Bool # shiftL :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # unsafeShiftL :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # shiftR :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # unsafeShiftR :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # rotateL :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # rotateR :: VkDisplaySurfaceCreateFlagsKHR -> Int -> VkDisplaySurfaceCreateFlagsKHR # popCount :: VkDisplaySurfaceCreateFlagsKHR -> Int #
FiniteBits VkDisplaySurfaceCreateFlagsKHR Source #
Methods finiteBitSize :: VkDisplaySurfaceCreateFlagsKHR -> Int # countLeadingZeros :: VkDisplaySurfaceCreateFlagsKHR -> Int # countTrailingZeros :: VkDisplaySurfaceCreateFlagsKHR -> Int #
type Rep VkDisplaySurfaceCreateFlagsKHR Source #
type Rep VkDisplaySurfaceCreateFlagsKHR = D1 (MetaData "VkDisplaySurfaceCreateFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkDisplaySurfaceCreateFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkEventCreateFlags Source #

Constructors

VkEventCreateFlags VkFlags

Instances

Bounded VkEventCreateFlags Source #
Methods minBound :: VkEventCreateFlags # maxBound :: VkEventCreateFlags #
Enum VkEventCreateFlags Source #
Methods succ :: VkEventCreateFlags -> VkEventCreateFlags # pred :: VkEventCreateFlags -> VkEventCreateFlags # toEnum :: Int -> VkEventCreateFlags # fromEnum :: VkEventCreateFlags -> Int # enumFrom :: VkEventCreateFlags -> [VkEventCreateFlags] # enumFromThen :: VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags] # enumFromTo :: VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags] # enumFromThenTo :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags -> [VkEventCreateFlags] #
Eq VkEventCreateFlags Source #
Methods (==) :: VkEventCreateFlags -> VkEventCreateFlags -> Bool # (/=) :: VkEventCreateFlags -> VkEventCreateFlags -> Bool #
Integral VkEventCreateFlags Source #
Methods quot :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # rem :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # div :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # mod :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # quotRem :: VkEventCreateFlags -> VkEventCreateFlags -> (VkEventCreateFlags, VkEventCreateFlags) # divMod :: VkEventCreateFlags -> VkEventCreateFlags -> (VkEventCreateFlags, VkEventCreateFlags) # toInteger :: VkEventCreateFlags -> Integer #
Data VkEventCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkEventCreateFlags -> c VkEventCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkEventCreateFlags # toConstr :: VkEventCreateFlags -> Constr # dataTypeOf :: VkEventCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkEventCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkEventCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkEventCreateFlags -> VkEventCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkEventCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkEventCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkEventCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkEventCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkEventCreateFlags -> m VkEventCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkEventCreateFlags -> m VkEventCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkEventCreateFlags -> m VkEventCreateFlags #
Num VkEventCreateFlags Source #
Methods (+) :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # (-) :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # (*) :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # negate :: VkEventCreateFlags -> VkEventCreateFlags # abs :: VkEventCreateFlags -> VkEventCreateFlags # signum :: VkEventCreateFlags -> VkEventCreateFlags # fromInteger :: Integer -> VkEventCreateFlags #
Ord VkEventCreateFlags Source #
Methods compare :: VkEventCreateFlags -> VkEventCreateFlags -> Ordering # (<) :: VkEventCreateFlags -> VkEventCreateFlags -> Bool # (<=) :: VkEventCreateFlags -> VkEventCreateFlags -> Bool # (>) :: VkEventCreateFlags -> VkEventCreateFlags -> Bool # (>=) :: VkEventCreateFlags -> VkEventCreateFlags -> Bool # max :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # min :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags #
Read VkEventCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkEventCreateFlags # readList :: ReadS [VkEventCreateFlags] # readPrec :: ReadPrec VkEventCreateFlags # readListPrec :: ReadPrec [VkEventCreateFlags] #
Real VkEventCreateFlags Source #
Methods toRational :: VkEventCreateFlags -> Rational #
Show VkEventCreateFlags Source #
Methods showsPrec :: Int -> VkEventCreateFlags -> ShowS # show :: VkEventCreateFlags -> String # showList :: [VkEventCreateFlags] -> ShowS #
Generic VkEventCreateFlags Source #
Associated Types type Rep VkEventCreateFlags :: * -> * # Methods from :: VkEventCreateFlags -> Rep VkEventCreateFlags x # to :: Rep VkEventCreateFlags x -> VkEventCreateFlags #
Storable VkEventCreateFlags Source #
Methods sizeOf :: VkEventCreateFlags -> Int # alignment :: VkEventCreateFlags -> Int # peekElemOff :: Ptr VkEventCreateFlags -> Int -> IO VkEventCreateFlags # pokeElemOff :: Ptr VkEventCreateFlags -> Int -> VkEventCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkEventCreateFlags # pokeByteOff :: Ptr b -> Int -> VkEventCreateFlags -> IO () # peek :: Ptr VkEventCreateFlags -> IO VkEventCreateFlags # poke :: Ptr VkEventCreateFlags -> VkEventCreateFlags -> IO () #
Bits VkEventCreateFlags Source #
Methods (.&.) :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # (.\|.) :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # xor :: VkEventCreateFlags -> VkEventCreateFlags -> VkEventCreateFlags # complement :: VkEventCreateFlags -> VkEventCreateFlags # shift :: VkEventCreateFlags -> Int -> VkEventCreateFlags # rotate :: VkEventCreateFlags -> Int -> VkEventCreateFlags # zeroBits :: VkEventCreateFlags # bit :: Int -> VkEventCreateFlags # setBit :: VkEventCreateFlags -> Int -> VkEventCreateFlags # clearBit :: VkEventCreateFlags -> Int -> VkEventCreateFlags # complementBit :: VkEventCreateFlags -> Int -> VkEventCreateFlags # testBit :: VkEventCreateFlags -> Int -> Bool # bitSizeMaybe :: VkEventCreateFlags -> Maybe Int # bitSize :: VkEventCreateFlags -> Int # isSigned :: VkEventCreateFlags -> Bool # shiftL :: VkEventCreateFlags -> Int -> VkEventCreateFlags # unsafeShiftL :: VkEventCreateFlags -> Int -> VkEventCreateFlags # shiftR :: VkEventCreateFlags -> Int -> VkEventCreateFlags # unsafeShiftR :: VkEventCreateFlags -> Int -> VkEventCreateFlags # rotateL :: VkEventCreateFlags -> Int -> VkEventCreateFlags # rotateR :: VkEventCreateFlags -> Int -> VkEventCreateFlags # popCount :: VkEventCreateFlags -> Int #
FiniteBits VkEventCreateFlags Source #
Methods finiteBitSize :: VkEventCreateFlags -> Int # countLeadingZeros :: VkEventCreateFlags -> Int # countTrailingZeros :: VkEventCreateFlags -> Int #
type Rep VkEventCreateFlags Source #
type Rep VkEventCreateFlags = D1 (MetaData "VkEventCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkEventCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkExternalFenceFeatureFlagsKHR Source #

Constructors

VkExternalFenceFeatureFlagsKHR VkFlags

Instances

Bounded VkExternalFenceFeatureFlagsKHR Source #
Methods minBound :: VkExternalFenceFeatureFlagsKHR # maxBound :: VkExternalFenceFeatureFlagsKHR #
Enum VkExternalFenceFeatureFlagsKHR Source #
Methods succ :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # pred :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # toEnum :: Int -> VkExternalFenceFeatureFlagsKHR # fromEnum :: VkExternalFenceFeatureFlagsKHR -> Int # enumFrom :: VkExternalFenceFeatureFlagsKHR -> [VkExternalFenceFeatureFlagsKHR] # enumFromThen :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> [VkExternalFenceFeatureFlagsKHR] # enumFromTo :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> [VkExternalFenceFeatureFlagsKHR] # enumFromThenTo :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> [VkExternalFenceFeatureFlagsKHR] #
Eq VkExternalFenceFeatureFlagsKHR Source #
Methods (==) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> Bool # (/=) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> Bool #
Integral VkExternalFenceFeatureFlagsKHR Source #
Methods quot :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # rem :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # div :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # mod :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # quotRem :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> (VkExternalFenceFeatureFlagsKHR, VkExternalFenceFeatureFlagsKHR) # divMod :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> (VkExternalFenceFeatureFlagsKHR, VkExternalFenceFeatureFlagsKHR) # toInteger :: VkExternalFenceFeatureFlagsKHR -> Integer #
Data VkExternalFenceFeatureFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkExternalFenceFeatureFlagsKHR -> c VkExternalFenceFeatureFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkExternalFenceFeatureFlagsKHR # toConstr :: VkExternalFenceFeatureFlagsKHR -> Constr # dataTypeOf :: VkExternalFenceFeatureFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkExternalFenceFeatureFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkExternalFenceFeatureFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalFenceFeatureFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalFenceFeatureFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkExternalFenceFeatureFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkExternalFenceFeatureFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkExternalFenceFeatureFlagsKHR -> m VkExternalFenceFeatureFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalFenceFeatureFlagsKHR -> m VkExternalFenceFeatureFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalFenceFeatureFlagsKHR -> m VkExternalFenceFeatureFlagsKHR #
Num VkExternalFenceFeatureFlagsKHR Source #
Methods (+) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # (-) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # (*) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # negate :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # abs :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # signum :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # fromInteger :: Integer -> VkExternalFenceFeatureFlagsKHR #
Ord VkExternalFenceFeatureFlagsKHR Source #
Methods compare :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> Ordering # (<) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> Bool # (<=) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> Bool # (>) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> Bool # (>=) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> Bool # max :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # min :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR #
Read VkExternalFenceFeatureFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkExternalFenceFeatureFlagsKHR # readList :: ReadS [VkExternalFenceFeatureFlagsKHR] # readPrec :: ReadPrec VkExternalFenceFeatureFlagsKHR # readListPrec :: ReadPrec [VkExternalFenceFeatureFlagsKHR] #
Real VkExternalFenceFeatureFlagsKHR Source #
Methods toRational :: VkExternalFenceFeatureFlagsKHR -> Rational #
Show VkExternalFenceFeatureFlagsKHR Source #
Methods showsPrec :: Int -> VkExternalFenceFeatureFlagsKHR -> ShowS # show :: VkExternalFenceFeatureFlagsKHR -> String # showList :: [VkExternalFenceFeatureFlagsKHR] -> ShowS #
Generic VkExternalFenceFeatureFlagsKHR Source #
Associated Types type Rep VkExternalFenceFeatureFlagsKHR :: * -> * # Methods from :: VkExternalFenceFeatureFlagsKHR -> Rep VkExternalFenceFeatureFlagsKHR x # to :: Rep VkExternalFenceFeatureFlagsKHR x -> VkExternalFenceFeatureFlagsKHR #
Storable VkExternalFenceFeatureFlagsKHR Source #
Methods sizeOf :: VkExternalFenceFeatureFlagsKHR -> Int # alignment :: VkExternalFenceFeatureFlagsKHR -> Int # peekElemOff :: Ptr VkExternalFenceFeatureFlagsKHR -> Int -> IO VkExternalFenceFeatureFlagsKHR # pokeElemOff :: Ptr VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkExternalFenceFeatureFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkExternalFenceFeatureFlagsKHR -> IO () # peek :: Ptr VkExternalFenceFeatureFlagsKHR -> IO VkExternalFenceFeatureFlagsKHR # poke :: Ptr VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> IO () #
Bits VkExternalFenceFeatureFlagsKHR Source #
Methods (.&.) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # (.\|.) :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # xor :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # complement :: VkExternalFenceFeatureFlagsKHR -> VkExternalFenceFeatureFlagsKHR # shift :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # rotate :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # zeroBits :: VkExternalFenceFeatureFlagsKHR # bit :: Int -> VkExternalFenceFeatureFlagsKHR # setBit :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # clearBit :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # complementBit :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # testBit :: VkExternalFenceFeatureFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkExternalFenceFeatureFlagsKHR -> Maybe Int # bitSize :: VkExternalFenceFeatureFlagsKHR -> Int # isSigned :: VkExternalFenceFeatureFlagsKHR -> Bool # shiftL :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # unsafeShiftL :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # shiftR :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # unsafeShiftR :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # rotateL :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # rotateR :: VkExternalFenceFeatureFlagsKHR -> Int -> VkExternalFenceFeatureFlagsKHR # popCount :: VkExternalFenceFeatureFlagsKHR -> Int #
FiniteBits VkExternalFenceFeatureFlagsKHR Source #
Methods finiteBitSize :: VkExternalFenceFeatureFlagsKHR -> Int # countLeadingZeros :: VkExternalFenceFeatureFlagsKHR -> Int # countTrailingZeros :: VkExternalFenceFeatureFlagsKHR -> Int #
type Rep VkExternalFenceFeatureFlagsKHR Source #
type Rep VkExternalFenceFeatureFlagsKHR = D1 (MetaData "VkExternalFenceFeatureFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkExternalFenceFeatureFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkExternalFenceHandleTypeFlagsKHR Source #

Constructors

VkExternalFenceHandleTypeFlagsKHR VkFlags

Instances

Bounded VkExternalFenceHandleTypeFlagsKHR Source #
Methods minBound :: VkExternalFenceHandleTypeFlagsKHR # maxBound :: VkExternalFenceHandleTypeFlagsKHR #
Enum VkExternalFenceHandleTypeFlagsKHR Source #
Methods succ :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # pred :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # toEnum :: Int -> VkExternalFenceHandleTypeFlagsKHR # fromEnum :: VkExternalFenceHandleTypeFlagsKHR -> Int # enumFrom :: VkExternalFenceHandleTypeFlagsKHR -> [VkExternalFenceHandleTypeFlagsKHR] # enumFromThen :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> [VkExternalFenceHandleTypeFlagsKHR] # enumFromTo :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> [VkExternalFenceHandleTypeFlagsKHR] # enumFromThenTo :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> [VkExternalFenceHandleTypeFlagsKHR] #
Eq VkExternalFenceHandleTypeFlagsKHR Source #
Methods (==) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> Bool # (/=) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> Bool #
Integral VkExternalFenceHandleTypeFlagsKHR Source #
Methods quot :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # rem :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # div :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # mod :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # quotRem :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> (VkExternalFenceHandleTypeFlagsKHR, VkExternalFenceHandleTypeFlagsKHR) # divMod :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> (VkExternalFenceHandleTypeFlagsKHR, VkExternalFenceHandleTypeFlagsKHR) # toInteger :: VkExternalFenceHandleTypeFlagsKHR -> Integer #
Data VkExternalFenceHandleTypeFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkExternalFenceHandleTypeFlagsKHR -> c VkExternalFenceHandleTypeFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkExternalFenceHandleTypeFlagsKHR # toConstr :: VkExternalFenceHandleTypeFlagsKHR -> Constr # dataTypeOf :: VkExternalFenceHandleTypeFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkExternalFenceHandleTypeFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkExternalFenceHandleTypeFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalFenceHandleTypeFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalFenceHandleTypeFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkExternalFenceHandleTypeFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkExternalFenceHandleTypeFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkExternalFenceHandleTypeFlagsKHR -> m VkExternalFenceHandleTypeFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalFenceHandleTypeFlagsKHR -> m VkExternalFenceHandleTypeFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalFenceHandleTypeFlagsKHR -> m VkExternalFenceHandleTypeFlagsKHR #
Num VkExternalFenceHandleTypeFlagsKHR Source #
Methods (+) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # (-) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # (*) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # negate :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # abs :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # signum :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # fromInteger :: Integer -> VkExternalFenceHandleTypeFlagsKHR #
Ord VkExternalFenceHandleTypeFlagsKHR Source #
Methods compare :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> Ordering # (<) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> Bool # (<=) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> Bool # (>) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> Bool # (>=) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> Bool # max :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # min :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR #
Read VkExternalFenceHandleTypeFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkExternalFenceHandleTypeFlagsKHR # readList :: ReadS [VkExternalFenceHandleTypeFlagsKHR] # readPrec :: ReadPrec VkExternalFenceHandleTypeFlagsKHR # readListPrec :: ReadPrec [VkExternalFenceHandleTypeFlagsKHR] #
Real VkExternalFenceHandleTypeFlagsKHR Source #
Methods toRational :: VkExternalFenceHandleTypeFlagsKHR -> Rational #
Show VkExternalFenceHandleTypeFlagsKHR Source #
Methods showsPrec :: Int -> VkExternalFenceHandleTypeFlagsKHR -> ShowS # show :: VkExternalFenceHandleTypeFlagsKHR -> String # showList :: [VkExternalFenceHandleTypeFlagsKHR] -> ShowS #
Generic VkExternalFenceHandleTypeFlagsKHR Source #
Associated Types type Rep VkExternalFenceHandleTypeFlagsKHR :: * -> * # Methods from :: VkExternalFenceHandleTypeFlagsKHR -> Rep VkExternalFenceHandleTypeFlagsKHR x # to :: Rep VkExternalFenceHandleTypeFlagsKHR x -> VkExternalFenceHandleTypeFlagsKHR #
Storable VkExternalFenceHandleTypeFlagsKHR Source #
Methods sizeOf :: VkExternalFenceHandleTypeFlagsKHR -> Int # alignment :: VkExternalFenceHandleTypeFlagsKHR -> Int # peekElemOff :: Ptr VkExternalFenceHandleTypeFlagsKHR -> Int -> IO VkExternalFenceHandleTypeFlagsKHR # pokeElemOff :: Ptr VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkExternalFenceHandleTypeFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkExternalFenceHandleTypeFlagsKHR -> IO () # peek :: Ptr VkExternalFenceHandleTypeFlagsKHR -> IO VkExternalFenceHandleTypeFlagsKHR # poke :: Ptr VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> IO () #
Bits VkExternalFenceHandleTypeFlagsKHR Source #
Methods (.&.) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # (.\|.) :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # xor :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # complement :: VkExternalFenceHandleTypeFlagsKHR -> VkExternalFenceHandleTypeFlagsKHR # shift :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # rotate :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # zeroBits :: VkExternalFenceHandleTypeFlagsKHR # bit :: Int -> VkExternalFenceHandleTypeFlagsKHR # setBit :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # clearBit :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # complementBit :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # testBit :: VkExternalFenceHandleTypeFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkExternalFenceHandleTypeFlagsKHR -> Maybe Int # bitSize :: VkExternalFenceHandleTypeFlagsKHR -> Int # isSigned :: VkExternalFenceHandleTypeFlagsKHR -> Bool # shiftL :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # unsafeShiftL :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # shiftR :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # unsafeShiftR :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # rotateL :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # rotateR :: VkExternalFenceHandleTypeFlagsKHR -> Int -> VkExternalFenceHandleTypeFlagsKHR # popCount :: VkExternalFenceHandleTypeFlagsKHR -> Int #
FiniteBits VkExternalFenceHandleTypeFlagsKHR Source #
Methods finiteBitSize :: VkExternalFenceHandleTypeFlagsKHR -> Int # countLeadingZeros :: VkExternalFenceHandleTypeFlagsKHR -> Int # countTrailingZeros :: VkExternalFenceHandleTypeFlagsKHR -> Int #
type Rep VkExternalFenceHandleTypeFlagsKHR Source #
type Rep VkExternalFenceHandleTypeFlagsKHR = D1 (MetaData "VkExternalFenceHandleTypeFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkExternalFenceHandleTypeFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkExternalMemoryFeatureFlagsKHR Source #

Constructors

VkExternalMemoryFeatureFlagsKHR VkFlags

Instances

Bounded VkExternalMemoryFeatureFlagsKHR Source #
Methods minBound :: VkExternalMemoryFeatureFlagsKHR # maxBound :: VkExternalMemoryFeatureFlagsKHR #
Enum VkExternalMemoryFeatureFlagsKHR Source #
Methods succ :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # pred :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # toEnum :: Int -> VkExternalMemoryFeatureFlagsKHR # fromEnum :: VkExternalMemoryFeatureFlagsKHR -> Int # enumFrom :: VkExternalMemoryFeatureFlagsKHR -> [VkExternalMemoryFeatureFlagsKHR] # enumFromThen :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> [VkExternalMemoryFeatureFlagsKHR] # enumFromTo :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> [VkExternalMemoryFeatureFlagsKHR] # enumFromThenTo :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> [VkExternalMemoryFeatureFlagsKHR] #
Eq VkExternalMemoryFeatureFlagsKHR Source #
Methods (==) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> Bool # (/=) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> Bool #
Integral VkExternalMemoryFeatureFlagsKHR Source #
Methods quot :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # rem :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # div :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # mod :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # quotRem :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> (VkExternalMemoryFeatureFlagsKHR, VkExternalMemoryFeatureFlagsKHR) # divMod :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> (VkExternalMemoryFeatureFlagsKHR, VkExternalMemoryFeatureFlagsKHR) # toInteger :: VkExternalMemoryFeatureFlagsKHR -> Integer #
Data VkExternalMemoryFeatureFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkExternalMemoryFeatureFlagsKHR -> c VkExternalMemoryFeatureFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkExternalMemoryFeatureFlagsKHR # toConstr :: VkExternalMemoryFeatureFlagsKHR -> Constr # dataTypeOf :: VkExternalMemoryFeatureFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkExternalMemoryFeatureFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkExternalMemoryFeatureFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalMemoryFeatureFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalMemoryFeatureFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkExternalMemoryFeatureFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkExternalMemoryFeatureFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkExternalMemoryFeatureFlagsKHR -> m VkExternalMemoryFeatureFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalMemoryFeatureFlagsKHR -> m VkExternalMemoryFeatureFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalMemoryFeatureFlagsKHR -> m VkExternalMemoryFeatureFlagsKHR #
Num VkExternalMemoryFeatureFlagsKHR Source #
Methods (+) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # (-) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # (*) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # negate :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # abs :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # signum :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # fromInteger :: Integer -> VkExternalMemoryFeatureFlagsKHR #
Ord VkExternalMemoryFeatureFlagsKHR Source #
Methods compare :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> Ordering # (<) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> Bool # (<=) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> Bool # (>) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> Bool # (>=) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> Bool # max :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # min :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR #
Read VkExternalMemoryFeatureFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkExternalMemoryFeatureFlagsKHR # readList :: ReadS [VkExternalMemoryFeatureFlagsKHR] # readPrec :: ReadPrec VkExternalMemoryFeatureFlagsKHR # readListPrec :: ReadPrec [VkExternalMemoryFeatureFlagsKHR] #
Real VkExternalMemoryFeatureFlagsKHR Source #
Methods toRational :: VkExternalMemoryFeatureFlagsKHR -> Rational #
Show VkExternalMemoryFeatureFlagsKHR Source #
Methods showsPrec :: Int -> VkExternalMemoryFeatureFlagsKHR -> ShowS # show :: VkExternalMemoryFeatureFlagsKHR -> String # showList :: [VkExternalMemoryFeatureFlagsKHR] -> ShowS #
Generic VkExternalMemoryFeatureFlagsKHR Source #
Associated Types type Rep VkExternalMemoryFeatureFlagsKHR :: * -> * # Methods from :: VkExternalMemoryFeatureFlagsKHR -> Rep VkExternalMemoryFeatureFlagsKHR x # to :: Rep VkExternalMemoryFeatureFlagsKHR x -> VkExternalMemoryFeatureFlagsKHR #
Storable VkExternalMemoryFeatureFlagsKHR Source #
Methods sizeOf :: VkExternalMemoryFeatureFlagsKHR -> Int # alignment :: VkExternalMemoryFeatureFlagsKHR -> Int # peekElemOff :: Ptr VkExternalMemoryFeatureFlagsKHR -> Int -> IO VkExternalMemoryFeatureFlagsKHR # pokeElemOff :: Ptr VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkExternalMemoryFeatureFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkExternalMemoryFeatureFlagsKHR -> IO () # peek :: Ptr VkExternalMemoryFeatureFlagsKHR -> IO VkExternalMemoryFeatureFlagsKHR # poke :: Ptr VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> IO () #
Bits VkExternalMemoryFeatureFlagsKHR Source #
Methods (.&.) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # (.\|.) :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # xor :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # complement :: VkExternalMemoryFeatureFlagsKHR -> VkExternalMemoryFeatureFlagsKHR # shift :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # rotate :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # zeroBits :: VkExternalMemoryFeatureFlagsKHR # bit :: Int -> VkExternalMemoryFeatureFlagsKHR # setBit :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # clearBit :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # complementBit :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # testBit :: VkExternalMemoryFeatureFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkExternalMemoryFeatureFlagsKHR -> Maybe Int # bitSize :: VkExternalMemoryFeatureFlagsKHR -> Int # isSigned :: VkExternalMemoryFeatureFlagsKHR -> Bool # shiftL :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # unsafeShiftL :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # shiftR :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # unsafeShiftR :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # rotateL :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # rotateR :: VkExternalMemoryFeatureFlagsKHR -> Int -> VkExternalMemoryFeatureFlagsKHR # popCount :: VkExternalMemoryFeatureFlagsKHR -> Int #
FiniteBits VkExternalMemoryFeatureFlagsKHR Source #
Methods finiteBitSize :: VkExternalMemoryFeatureFlagsKHR -> Int # countLeadingZeros :: VkExternalMemoryFeatureFlagsKHR -> Int # countTrailingZeros :: VkExternalMemoryFeatureFlagsKHR -> Int #
type Rep VkExternalMemoryFeatureFlagsKHR Source #
type Rep VkExternalMemoryFeatureFlagsKHR = D1 (MetaData "VkExternalMemoryFeatureFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkExternalMemoryFeatureFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkExternalMemoryHandleTypeFlagsKHR Source #

Constructors

VkExternalMemoryHandleTypeFlagsKHR VkFlags

Instances

Bounded VkExternalMemoryHandleTypeFlagsKHR Source #
Methods minBound :: VkExternalMemoryHandleTypeFlagsKHR # maxBound :: VkExternalMemoryHandleTypeFlagsKHR #
Enum VkExternalMemoryHandleTypeFlagsKHR Source #
Methods succ :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # pred :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # toEnum :: Int -> VkExternalMemoryHandleTypeFlagsKHR # fromEnum :: VkExternalMemoryHandleTypeFlagsKHR -> Int # enumFrom :: VkExternalMemoryHandleTypeFlagsKHR -> [VkExternalMemoryHandleTypeFlagsKHR] # enumFromThen :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> [VkExternalMemoryHandleTypeFlagsKHR] # enumFromTo :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> [VkExternalMemoryHandleTypeFlagsKHR] # enumFromThenTo :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> [VkExternalMemoryHandleTypeFlagsKHR] #
Eq VkExternalMemoryHandleTypeFlagsKHR Source #
Methods (==) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> Bool # (/=) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> Bool #
Integral VkExternalMemoryHandleTypeFlagsKHR Source #
Methods quot :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # rem :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # div :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # mod :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # quotRem :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> (VkExternalMemoryHandleTypeFlagsKHR, VkExternalMemoryHandleTypeFlagsKHR) # divMod :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> (VkExternalMemoryHandleTypeFlagsKHR, VkExternalMemoryHandleTypeFlagsKHR) # toInteger :: VkExternalMemoryHandleTypeFlagsKHR -> Integer #
Data VkExternalMemoryHandleTypeFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkExternalMemoryHandleTypeFlagsKHR -> c VkExternalMemoryHandleTypeFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkExternalMemoryHandleTypeFlagsKHR # toConstr :: VkExternalMemoryHandleTypeFlagsKHR -> Constr # dataTypeOf :: VkExternalMemoryHandleTypeFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkExternalMemoryHandleTypeFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkExternalMemoryHandleTypeFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalMemoryHandleTypeFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalMemoryHandleTypeFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkExternalMemoryHandleTypeFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkExternalMemoryHandleTypeFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkExternalMemoryHandleTypeFlagsKHR -> m VkExternalMemoryHandleTypeFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalMemoryHandleTypeFlagsKHR -> m VkExternalMemoryHandleTypeFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalMemoryHandleTypeFlagsKHR -> m VkExternalMemoryHandleTypeFlagsKHR #
Num VkExternalMemoryHandleTypeFlagsKHR Source #
Methods (+) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # (-) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # (*) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # negate :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # abs :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # signum :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # fromInteger :: Integer -> VkExternalMemoryHandleTypeFlagsKHR #
Ord VkExternalMemoryHandleTypeFlagsKHR Source #
Methods compare :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> Ordering # (<) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> Bool # (<=) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> Bool # (>) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> Bool # (>=) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> Bool # max :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # min :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR #
Read VkExternalMemoryHandleTypeFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkExternalMemoryHandleTypeFlagsKHR # readList :: ReadS [VkExternalMemoryHandleTypeFlagsKHR] # readPrec :: ReadPrec VkExternalMemoryHandleTypeFlagsKHR # readListPrec :: ReadPrec [VkExternalMemoryHandleTypeFlagsKHR] #
Real VkExternalMemoryHandleTypeFlagsKHR Source #
Methods toRational :: VkExternalMemoryHandleTypeFlagsKHR -> Rational #
Show VkExternalMemoryHandleTypeFlagsKHR Source #
Methods showsPrec :: Int -> VkExternalMemoryHandleTypeFlagsKHR -> ShowS # show :: VkExternalMemoryHandleTypeFlagsKHR -> String # showList :: [VkExternalMemoryHandleTypeFlagsKHR] -> ShowS #
Generic VkExternalMemoryHandleTypeFlagsKHR Source #
Associated Types type Rep VkExternalMemoryHandleTypeFlagsKHR :: * -> * # Methods from :: VkExternalMemoryHandleTypeFlagsKHR -> Rep VkExternalMemoryHandleTypeFlagsKHR x # to :: Rep VkExternalMemoryHandleTypeFlagsKHR x -> VkExternalMemoryHandleTypeFlagsKHR #
Storable VkExternalMemoryHandleTypeFlagsKHR Source #
Methods sizeOf :: VkExternalMemoryHandleTypeFlagsKHR -> Int # alignment :: VkExternalMemoryHandleTypeFlagsKHR -> Int # peekElemOff :: Ptr VkExternalMemoryHandleTypeFlagsKHR -> Int -> IO VkExternalMemoryHandleTypeFlagsKHR # pokeElemOff :: Ptr VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkExternalMemoryHandleTypeFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkExternalMemoryHandleTypeFlagsKHR -> IO () # peek :: Ptr VkExternalMemoryHandleTypeFlagsKHR -> IO VkExternalMemoryHandleTypeFlagsKHR # poke :: Ptr VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> IO () #
Bits VkExternalMemoryHandleTypeFlagsKHR Source #
Methods (.&.) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # (.\|.) :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # xor :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # complement :: VkExternalMemoryHandleTypeFlagsKHR -> VkExternalMemoryHandleTypeFlagsKHR # shift :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # rotate :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # zeroBits :: VkExternalMemoryHandleTypeFlagsKHR # bit :: Int -> VkExternalMemoryHandleTypeFlagsKHR # setBit :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # clearBit :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # complementBit :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # testBit :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkExternalMemoryHandleTypeFlagsKHR -> Maybe Int # bitSize :: VkExternalMemoryHandleTypeFlagsKHR -> Int # isSigned :: VkExternalMemoryHandleTypeFlagsKHR -> Bool # shiftL :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # unsafeShiftL :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # shiftR :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # unsafeShiftR :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # rotateL :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # rotateR :: VkExternalMemoryHandleTypeFlagsKHR -> Int -> VkExternalMemoryHandleTypeFlagsKHR # popCount :: VkExternalMemoryHandleTypeFlagsKHR -> Int #
FiniteBits VkExternalMemoryHandleTypeFlagsKHR Source #
Methods finiteBitSize :: VkExternalMemoryHandleTypeFlagsKHR -> Int # countLeadingZeros :: VkExternalMemoryHandleTypeFlagsKHR -> Int # countTrailingZeros :: VkExternalMemoryHandleTypeFlagsKHR -> Int #
type Rep VkExternalMemoryHandleTypeFlagsKHR Source #
type Rep VkExternalMemoryHandleTypeFlagsKHR = D1 (MetaData "VkExternalMemoryHandleTypeFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkExternalMemoryHandleTypeFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkExternalSemaphoreFeatureFlagsKHR Source #

Constructors

VkExternalSemaphoreFeatureFlagsKHR VkFlags

Instances

Bounded VkExternalSemaphoreFeatureFlagsKHR Source #
Methods minBound :: VkExternalSemaphoreFeatureFlagsKHR # maxBound :: VkExternalSemaphoreFeatureFlagsKHR #
Enum VkExternalSemaphoreFeatureFlagsKHR Source #
Methods succ :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # pred :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # toEnum :: Int -> VkExternalSemaphoreFeatureFlagsKHR # fromEnum :: VkExternalSemaphoreFeatureFlagsKHR -> Int # enumFrom :: VkExternalSemaphoreFeatureFlagsKHR -> [VkExternalSemaphoreFeatureFlagsKHR] # enumFromThen :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> [VkExternalSemaphoreFeatureFlagsKHR] # enumFromTo :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> [VkExternalSemaphoreFeatureFlagsKHR] # enumFromThenTo :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> [VkExternalSemaphoreFeatureFlagsKHR] #
Eq VkExternalSemaphoreFeatureFlagsKHR Source #
Methods (==) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> Bool # (/=) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> Bool #
Integral VkExternalSemaphoreFeatureFlagsKHR Source #
Methods quot :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # rem :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # div :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # mod :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # quotRem :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> (VkExternalSemaphoreFeatureFlagsKHR, VkExternalSemaphoreFeatureFlagsKHR) # divMod :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> (VkExternalSemaphoreFeatureFlagsKHR, VkExternalSemaphoreFeatureFlagsKHR) # toInteger :: VkExternalSemaphoreFeatureFlagsKHR -> Integer #
Data VkExternalSemaphoreFeatureFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkExternalSemaphoreFeatureFlagsKHR -> c VkExternalSemaphoreFeatureFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkExternalSemaphoreFeatureFlagsKHR # toConstr :: VkExternalSemaphoreFeatureFlagsKHR -> Constr # dataTypeOf :: VkExternalSemaphoreFeatureFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkExternalSemaphoreFeatureFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkExternalSemaphoreFeatureFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalSemaphoreFeatureFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalSemaphoreFeatureFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkExternalSemaphoreFeatureFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkExternalSemaphoreFeatureFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkExternalSemaphoreFeatureFlagsKHR -> m VkExternalSemaphoreFeatureFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalSemaphoreFeatureFlagsKHR -> m VkExternalSemaphoreFeatureFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalSemaphoreFeatureFlagsKHR -> m VkExternalSemaphoreFeatureFlagsKHR #
Num VkExternalSemaphoreFeatureFlagsKHR Source #
Methods (+) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # (-) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # (*) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # negate :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # abs :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # signum :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # fromInteger :: Integer -> VkExternalSemaphoreFeatureFlagsKHR #
Ord VkExternalSemaphoreFeatureFlagsKHR Source #
Methods compare :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> Ordering # (<) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> Bool # (<=) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> Bool # (>) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> Bool # (>=) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> Bool # max :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # min :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR #
Read VkExternalSemaphoreFeatureFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkExternalSemaphoreFeatureFlagsKHR # readList :: ReadS [VkExternalSemaphoreFeatureFlagsKHR] # readPrec :: ReadPrec VkExternalSemaphoreFeatureFlagsKHR # readListPrec :: ReadPrec [VkExternalSemaphoreFeatureFlagsKHR] #
Real VkExternalSemaphoreFeatureFlagsKHR Source #
Methods toRational :: VkExternalSemaphoreFeatureFlagsKHR -> Rational #
Show VkExternalSemaphoreFeatureFlagsKHR Source #
Methods showsPrec :: Int -> VkExternalSemaphoreFeatureFlagsKHR -> ShowS # show :: VkExternalSemaphoreFeatureFlagsKHR -> String # showList :: [VkExternalSemaphoreFeatureFlagsKHR] -> ShowS #
Generic VkExternalSemaphoreFeatureFlagsKHR Source #
Associated Types type Rep VkExternalSemaphoreFeatureFlagsKHR :: * -> * # Methods from :: VkExternalSemaphoreFeatureFlagsKHR -> Rep VkExternalSemaphoreFeatureFlagsKHR x # to :: Rep VkExternalSemaphoreFeatureFlagsKHR x -> VkExternalSemaphoreFeatureFlagsKHR #
Storable VkExternalSemaphoreFeatureFlagsKHR Source #
Methods sizeOf :: VkExternalSemaphoreFeatureFlagsKHR -> Int # alignment :: VkExternalSemaphoreFeatureFlagsKHR -> Int # peekElemOff :: Ptr VkExternalSemaphoreFeatureFlagsKHR -> Int -> IO VkExternalSemaphoreFeatureFlagsKHR # pokeElemOff :: Ptr VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkExternalSemaphoreFeatureFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkExternalSemaphoreFeatureFlagsKHR -> IO () # peek :: Ptr VkExternalSemaphoreFeatureFlagsKHR -> IO VkExternalSemaphoreFeatureFlagsKHR # poke :: Ptr VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> IO () #
Bits VkExternalSemaphoreFeatureFlagsKHR Source #
Methods (.&.) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # (.\|.) :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # xor :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # complement :: VkExternalSemaphoreFeatureFlagsKHR -> VkExternalSemaphoreFeatureFlagsKHR # shift :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # rotate :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # zeroBits :: VkExternalSemaphoreFeatureFlagsKHR # bit :: Int -> VkExternalSemaphoreFeatureFlagsKHR # setBit :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # clearBit :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # complementBit :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # testBit :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkExternalSemaphoreFeatureFlagsKHR -> Maybe Int # bitSize :: VkExternalSemaphoreFeatureFlagsKHR -> Int # isSigned :: VkExternalSemaphoreFeatureFlagsKHR -> Bool # shiftL :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # unsafeShiftL :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # shiftR :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # unsafeShiftR :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # rotateL :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # rotateR :: VkExternalSemaphoreFeatureFlagsKHR -> Int -> VkExternalSemaphoreFeatureFlagsKHR # popCount :: VkExternalSemaphoreFeatureFlagsKHR -> Int #
FiniteBits VkExternalSemaphoreFeatureFlagsKHR Source #
Methods finiteBitSize :: VkExternalSemaphoreFeatureFlagsKHR -> Int # countLeadingZeros :: VkExternalSemaphoreFeatureFlagsKHR -> Int # countTrailingZeros :: VkExternalSemaphoreFeatureFlagsKHR -> Int #
type Rep VkExternalSemaphoreFeatureFlagsKHR Source #
type Rep VkExternalSemaphoreFeatureFlagsKHR = D1 (MetaData "VkExternalSemaphoreFeatureFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkExternalSemaphoreFeatureFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkExternalSemaphoreHandleTypeFlagsKHR Source #

Constructors

VkExternalSemaphoreHandleTypeFlagsKHR VkFlags

Instances

Bounded VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods minBound :: VkExternalSemaphoreHandleTypeFlagsKHR # maxBound :: VkExternalSemaphoreHandleTypeFlagsKHR #
Enum VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods succ :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # pred :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # toEnum :: Int -> VkExternalSemaphoreHandleTypeFlagsKHR # fromEnum :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int # enumFrom :: VkExternalSemaphoreHandleTypeFlagsKHR -> [VkExternalSemaphoreHandleTypeFlagsKHR] # enumFromThen :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> [VkExternalSemaphoreHandleTypeFlagsKHR] # enumFromTo :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> [VkExternalSemaphoreHandleTypeFlagsKHR] # enumFromThenTo :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> [VkExternalSemaphoreHandleTypeFlagsKHR] #
Eq VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods (==) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool # (/=) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool #
Integral VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods quot :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # rem :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # div :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # mod :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # quotRem :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> (VkExternalSemaphoreHandleTypeFlagsKHR, VkExternalSemaphoreHandleTypeFlagsKHR) # divMod :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> (VkExternalSemaphoreHandleTypeFlagsKHR, VkExternalSemaphoreHandleTypeFlagsKHR) # toInteger :: VkExternalSemaphoreHandleTypeFlagsKHR -> Integer #
Data VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkExternalSemaphoreHandleTypeFlagsKHR -> c VkExternalSemaphoreHandleTypeFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkExternalSemaphoreHandleTypeFlagsKHR # toConstr :: VkExternalSemaphoreHandleTypeFlagsKHR -> Constr # dataTypeOf :: VkExternalSemaphoreHandleTypeFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkExternalSemaphoreHandleTypeFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkExternalSemaphoreHandleTypeFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalSemaphoreHandleTypeFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkExternalSemaphoreHandleTypeFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkExternalSemaphoreHandleTypeFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkExternalSemaphoreHandleTypeFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkExternalSemaphoreHandleTypeFlagsKHR -> m VkExternalSemaphoreHandleTypeFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalSemaphoreHandleTypeFlagsKHR -> m VkExternalSemaphoreHandleTypeFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkExternalSemaphoreHandleTypeFlagsKHR -> m VkExternalSemaphoreHandleTypeFlagsKHR #
Num VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods (+) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # (-) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # (*) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # negate :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # abs :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # signum :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # fromInteger :: Integer -> VkExternalSemaphoreHandleTypeFlagsKHR #
Ord VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods compare :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> Ordering # (<) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool # (<=) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool # (>) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool # (>=) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> Bool # max :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # min :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR #
Read VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkExternalSemaphoreHandleTypeFlagsKHR # readList :: ReadS [VkExternalSemaphoreHandleTypeFlagsKHR] # readPrec :: ReadPrec VkExternalSemaphoreHandleTypeFlagsKHR # readListPrec :: ReadPrec [VkExternalSemaphoreHandleTypeFlagsKHR] #
Real VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods toRational :: VkExternalSemaphoreHandleTypeFlagsKHR -> Rational #
Show VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods showsPrec :: Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> ShowS # show :: VkExternalSemaphoreHandleTypeFlagsKHR -> String # showList :: [VkExternalSemaphoreHandleTypeFlagsKHR] -> ShowS #
Generic VkExternalSemaphoreHandleTypeFlagsKHR Source #
Associated Types type Rep VkExternalSemaphoreHandleTypeFlagsKHR :: * -> * # Methods from :: VkExternalSemaphoreHandleTypeFlagsKHR -> Rep VkExternalSemaphoreHandleTypeFlagsKHR x # to :: Rep VkExternalSemaphoreHandleTypeFlagsKHR x -> VkExternalSemaphoreHandleTypeFlagsKHR #
Storable VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods sizeOf :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int # alignment :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int # peekElemOff :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> IO VkExternalSemaphoreHandleTypeFlagsKHR # pokeElemOff :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkExternalSemaphoreHandleTypeFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO () # peek :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR -> IO VkExternalSemaphoreHandleTypeFlagsKHR # poke :: Ptr VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> IO () #
Bits VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods (.&.) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # (.\|.) :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # xor :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # complement :: VkExternalSemaphoreHandleTypeFlagsKHR -> VkExternalSemaphoreHandleTypeFlagsKHR # shift :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # rotate :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # zeroBits :: VkExternalSemaphoreHandleTypeFlagsKHR # bit :: Int -> VkExternalSemaphoreHandleTypeFlagsKHR # setBit :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # clearBit :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # complementBit :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # testBit :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkExternalSemaphoreHandleTypeFlagsKHR -> Maybe Int # bitSize :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int # isSigned :: VkExternalSemaphoreHandleTypeFlagsKHR -> Bool # shiftL :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # unsafeShiftL :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # shiftR :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # unsafeShiftR :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # rotateL :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # rotateR :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int -> VkExternalSemaphoreHandleTypeFlagsKHR # popCount :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int #
FiniteBits VkExternalSemaphoreHandleTypeFlagsKHR Source #
Methods finiteBitSize :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int # countLeadingZeros :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int # countTrailingZeros :: VkExternalSemaphoreHandleTypeFlagsKHR -> Int #
type Rep VkExternalSemaphoreHandleTypeFlagsKHR Source #
type Rep VkExternalSemaphoreHandleTypeFlagsKHR = D1 (MetaData "VkExternalSemaphoreHandleTypeFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkExternalSemaphoreHandleTypeFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkFenceImportFlagsKHR Source #

Constructors

VkFenceImportFlagsKHR VkFlags

Instances

Bounded VkFenceImportFlagsKHR Source #
Methods minBound :: VkFenceImportFlagsKHR # maxBound :: VkFenceImportFlagsKHR #
Enum VkFenceImportFlagsKHR Source #
Methods succ :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # pred :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # toEnum :: Int -> VkFenceImportFlagsKHR # fromEnum :: VkFenceImportFlagsKHR -> Int # enumFrom :: VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR] # enumFromThen :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR] # enumFromTo :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR] # enumFromThenTo :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> [VkFenceImportFlagsKHR] #
Eq VkFenceImportFlagsKHR Source #
Methods (==) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool # (/=) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool #
Integral VkFenceImportFlagsKHR Source #
Methods quot :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # rem :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # div :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # mod :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # quotRem :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> (VkFenceImportFlagsKHR, VkFenceImportFlagsKHR) # divMod :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> (VkFenceImportFlagsKHR, VkFenceImportFlagsKHR) # toInteger :: VkFenceImportFlagsKHR -> Integer #
Data VkFenceImportFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkFenceImportFlagsKHR -> c VkFenceImportFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkFenceImportFlagsKHR # toConstr :: VkFenceImportFlagsKHR -> Constr # dataTypeOf :: VkFenceImportFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkFenceImportFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkFenceImportFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkFenceImportFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkFenceImportFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkFenceImportFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkFenceImportFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkFenceImportFlagsKHR -> m VkFenceImportFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkFenceImportFlagsKHR -> m VkFenceImportFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkFenceImportFlagsKHR -> m VkFenceImportFlagsKHR #
Num VkFenceImportFlagsKHR Source #
Methods (+) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # (-) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # (*) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # negate :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # abs :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # signum :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # fromInteger :: Integer -> VkFenceImportFlagsKHR #
Ord VkFenceImportFlagsKHR Source #
Methods compare :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Ordering # (<) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool # (<=) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool # (>) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool # (>=) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> Bool # max :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # min :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR #
Read VkFenceImportFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkFenceImportFlagsKHR # readList :: ReadS [VkFenceImportFlagsKHR] # readPrec :: ReadPrec VkFenceImportFlagsKHR # readListPrec :: ReadPrec [VkFenceImportFlagsKHR] #
Real VkFenceImportFlagsKHR Source #
Methods toRational :: VkFenceImportFlagsKHR -> Rational #
Show VkFenceImportFlagsKHR Source #
Methods showsPrec :: Int -> VkFenceImportFlagsKHR -> ShowS # show :: VkFenceImportFlagsKHR -> String # showList :: [VkFenceImportFlagsKHR] -> ShowS #
Generic VkFenceImportFlagsKHR Source #
Associated Types type Rep VkFenceImportFlagsKHR :: * -> * # Methods from :: VkFenceImportFlagsKHR -> Rep VkFenceImportFlagsKHR x # to :: Rep VkFenceImportFlagsKHR x -> VkFenceImportFlagsKHR #
Storable VkFenceImportFlagsKHR Source #
Methods sizeOf :: VkFenceImportFlagsKHR -> Int # alignment :: VkFenceImportFlagsKHR -> Int # peekElemOff :: Ptr VkFenceImportFlagsKHR -> Int -> IO VkFenceImportFlagsKHR # pokeElemOff :: Ptr VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkFenceImportFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkFenceImportFlagsKHR -> IO () # peek :: Ptr VkFenceImportFlagsKHR -> IO VkFenceImportFlagsKHR # poke :: Ptr VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> IO () #
Bits VkFenceImportFlagsKHR Source #
Methods (.&.) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # (.\|.) :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # xor :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # complement :: VkFenceImportFlagsKHR -> VkFenceImportFlagsKHR # shift :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # rotate :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # zeroBits :: VkFenceImportFlagsKHR # bit :: Int -> VkFenceImportFlagsKHR # setBit :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # clearBit :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # complementBit :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # testBit :: VkFenceImportFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkFenceImportFlagsKHR -> Maybe Int # bitSize :: VkFenceImportFlagsKHR -> Int # isSigned :: VkFenceImportFlagsKHR -> Bool # shiftL :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # unsafeShiftL :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # shiftR :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # unsafeShiftR :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # rotateL :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # rotateR :: VkFenceImportFlagsKHR -> Int -> VkFenceImportFlagsKHR # popCount :: VkFenceImportFlagsKHR -> Int #
FiniteBits VkFenceImportFlagsKHR Source #
Methods finiteBitSize :: VkFenceImportFlagsKHR -> Int # countLeadingZeros :: VkFenceImportFlagsKHR -> Int # countTrailingZeros :: VkFenceImportFlagsKHR -> Int #
type Rep VkFenceImportFlagsKHR Source #
type Rep VkFenceImportFlagsKHR = D1 (MetaData "VkFenceImportFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkFenceImportFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkFramebufferCreateFlags Source #

Constructors

VkFramebufferCreateFlags VkFlags

Instances

Bounded VkFramebufferCreateFlags Source #
Methods minBound :: VkFramebufferCreateFlags # maxBound :: VkFramebufferCreateFlags #
Enum VkFramebufferCreateFlags Source #
Methods succ :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags # pred :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags # toEnum :: Int -> VkFramebufferCreateFlags # fromEnum :: VkFramebufferCreateFlags -> Int # enumFrom :: VkFramebufferCreateFlags -> [VkFramebufferCreateFlags] # enumFromThen :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> [VkFramebufferCreateFlags] # enumFromTo :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> [VkFramebufferCreateFlags] # enumFromThenTo :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> [VkFramebufferCreateFlags] #
Eq VkFramebufferCreateFlags Source #
Methods (==) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool # (/=) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool #
Integral VkFramebufferCreateFlags Source #
Methods quot :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # rem :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # div :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # mod :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # quotRem :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> (VkFramebufferCreateFlags, VkFramebufferCreateFlags) # divMod :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> (VkFramebufferCreateFlags, VkFramebufferCreateFlags) # toInteger :: VkFramebufferCreateFlags -> Integer #
Data VkFramebufferCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkFramebufferCreateFlags -> c VkFramebufferCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkFramebufferCreateFlags # toConstr :: VkFramebufferCreateFlags -> Constr # dataTypeOf :: VkFramebufferCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkFramebufferCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkFramebufferCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkFramebufferCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkFramebufferCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkFramebufferCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkFramebufferCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkFramebufferCreateFlags -> m VkFramebufferCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkFramebufferCreateFlags -> m VkFramebufferCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkFramebufferCreateFlags -> m VkFramebufferCreateFlags #
Num VkFramebufferCreateFlags Source #
Methods (+) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # (-) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # (*) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # negate :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags # abs :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags # signum :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags # fromInteger :: Integer -> VkFramebufferCreateFlags #
Ord VkFramebufferCreateFlags Source #
Methods compare :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Ordering # (<) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool # (<=) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool # (>) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool # (>=) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> Bool # max :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # min :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags #
Read VkFramebufferCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkFramebufferCreateFlags # readList :: ReadS [VkFramebufferCreateFlags] # readPrec :: ReadPrec VkFramebufferCreateFlags # readListPrec :: ReadPrec [VkFramebufferCreateFlags] #
Real VkFramebufferCreateFlags Source #
Methods toRational :: VkFramebufferCreateFlags -> Rational #
Show VkFramebufferCreateFlags Source #
Methods showsPrec :: Int -> VkFramebufferCreateFlags -> ShowS # show :: VkFramebufferCreateFlags -> String # showList :: [VkFramebufferCreateFlags] -> ShowS #
Generic VkFramebufferCreateFlags Source #
Associated Types type Rep VkFramebufferCreateFlags :: * -> * # Methods from :: VkFramebufferCreateFlags -> Rep VkFramebufferCreateFlags x # to :: Rep VkFramebufferCreateFlags x -> VkFramebufferCreateFlags #
Storable VkFramebufferCreateFlags Source #
Methods sizeOf :: VkFramebufferCreateFlags -> Int # alignment :: VkFramebufferCreateFlags -> Int # peekElemOff :: Ptr VkFramebufferCreateFlags -> Int -> IO VkFramebufferCreateFlags # pokeElemOff :: Ptr VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkFramebufferCreateFlags # pokeByteOff :: Ptr b -> Int -> VkFramebufferCreateFlags -> IO () # peek :: Ptr VkFramebufferCreateFlags -> IO VkFramebufferCreateFlags # poke :: Ptr VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> IO () #
Bits VkFramebufferCreateFlags Source #
Methods (.&.) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # (.\|.) :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # xor :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags -> VkFramebufferCreateFlags # complement :: VkFramebufferCreateFlags -> VkFramebufferCreateFlags # shift :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # rotate :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # zeroBits :: VkFramebufferCreateFlags # bit :: Int -> VkFramebufferCreateFlags # setBit :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # clearBit :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # complementBit :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # testBit :: VkFramebufferCreateFlags -> Int -> Bool # bitSizeMaybe :: VkFramebufferCreateFlags -> Maybe Int # bitSize :: VkFramebufferCreateFlags -> Int # isSigned :: VkFramebufferCreateFlags -> Bool # shiftL :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # unsafeShiftL :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # shiftR :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # unsafeShiftR :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # rotateL :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # rotateR :: VkFramebufferCreateFlags -> Int -> VkFramebufferCreateFlags # popCount :: VkFramebufferCreateFlags -> Int #
FiniteBits VkFramebufferCreateFlags Source #
Methods finiteBitSize :: VkFramebufferCreateFlags -> Int # countLeadingZeros :: VkFramebufferCreateFlags -> Int # countTrailingZeros :: VkFramebufferCreateFlags -> Int #
type Rep VkFramebufferCreateFlags Source #
type Rep VkFramebufferCreateFlags = D1 (MetaData "VkFramebufferCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkFramebufferCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkIOSSurfaceCreateFlagsMVK Source #

Constructors

VkIOSSurfaceCreateFlagsMVK VkFlags

Instances

Bounded VkIOSSurfaceCreateFlagsMVK Source #
Methods minBound :: VkIOSSurfaceCreateFlagsMVK # maxBound :: VkIOSSurfaceCreateFlagsMVK #
Enum VkIOSSurfaceCreateFlagsMVK Source #
Methods succ :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # pred :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # toEnum :: Int -> VkIOSSurfaceCreateFlagsMVK # fromEnum :: VkIOSSurfaceCreateFlagsMVK -> Int # enumFrom :: VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK] # enumFromThen :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK] # enumFromTo :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK] # enumFromThenTo :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> [VkIOSSurfaceCreateFlagsMVK] #
Eq VkIOSSurfaceCreateFlagsMVK Source #
Methods (==) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool # (/=) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool #
Integral VkIOSSurfaceCreateFlagsMVK Source #
Methods quot :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # rem :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # div :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # mod :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # quotRem :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> (VkIOSSurfaceCreateFlagsMVK, VkIOSSurfaceCreateFlagsMVK) # divMod :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> (VkIOSSurfaceCreateFlagsMVK, VkIOSSurfaceCreateFlagsMVK) # toInteger :: VkIOSSurfaceCreateFlagsMVK -> Integer #
Data VkIOSSurfaceCreateFlagsMVK Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkIOSSurfaceCreateFlagsMVK -> c VkIOSSurfaceCreateFlagsMVK # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkIOSSurfaceCreateFlagsMVK # toConstr :: VkIOSSurfaceCreateFlagsMVK -> Constr # dataTypeOf :: VkIOSSurfaceCreateFlagsMVK -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkIOSSurfaceCreateFlagsMVK) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkIOSSurfaceCreateFlagsMVK) # gmapT :: (forall b. Data b => b -> b) -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkIOSSurfaceCreateFlagsMVK -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkIOSSurfaceCreateFlagsMVK -> r # gmapQ :: (forall d. Data d => d -> u) -> VkIOSSurfaceCreateFlagsMVK -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkIOSSurfaceCreateFlagsMVK -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkIOSSurfaceCreateFlagsMVK -> m VkIOSSurfaceCreateFlagsMVK # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkIOSSurfaceCreateFlagsMVK -> m VkIOSSurfaceCreateFlagsMVK # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkIOSSurfaceCreateFlagsMVK -> m VkIOSSurfaceCreateFlagsMVK #
Num VkIOSSurfaceCreateFlagsMVK Source #
Methods (+) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # (-) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # (*) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # negate :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # abs :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # signum :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # fromInteger :: Integer -> VkIOSSurfaceCreateFlagsMVK #
Ord VkIOSSurfaceCreateFlagsMVK Source #
Methods compare :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Ordering # (<) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool # (<=) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool # (>) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool # (>=) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> Bool # max :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # min :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK #
Read VkIOSSurfaceCreateFlagsMVK Source #
Methods readsPrec :: Int -> ReadS VkIOSSurfaceCreateFlagsMVK # readList :: ReadS [VkIOSSurfaceCreateFlagsMVK] # readPrec :: ReadPrec VkIOSSurfaceCreateFlagsMVK # readListPrec :: ReadPrec [VkIOSSurfaceCreateFlagsMVK] #
Real VkIOSSurfaceCreateFlagsMVK Source #
Methods toRational :: VkIOSSurfaceCreateFlagsMVK -> Rational #
Show VkIOSSurfaceCreateFlagsMVK Source #
Methods showsPrec :: Int -> VkIOSSurfaceCreateFlagsMVK -> ShowS # show :: VkIOSSurfaceCreateFlagsMVK -> String # showList :: [VkIOSSurfaceCreateFlagsMVK] -> ShowS #
Generic VkIOSSurfaceCreateFlagsMVK Source #
Associated Types type Rep VkIOSSurfaceCreateFlagsMVK :: * -> * # Methods from :: VkIOSSurfaceCreateFlagsMVK -> Rep VkIOSSurfaceCreateFlagsMVK x # to :: Rep VkIOSSurfaceCreateFlagsMVK x -> VkIOSSurfaceCreateFlagsMVK #
Storable VkIOSSurfaceCreateFlagsMVK Source #
Methods sizeOf :: VkIOSSurfaceCreateFlagsMVK -> Int # alignment :: VkIOSSurfaceCreateFlagsMVK -> Int # peekElemOff :: Ptr VkIOSSurfaceCreateFlagsMVK -> Int -> IO VkIOSSurfaceCreateFlagsMVK # pokeElemOff :: Ptr VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK -> IO () # peekByteOff :: Ptr b -> Int -> IO VkIOSSurfaceCreateFlagsMVK # pokeByteOff :: Ptr b -> Int -> VkIOSSurfaceCreateFlagsMVK -> IO () # peek :: Ptr VkIOSSurfaceCreateFlagsMVK -> IO VkIOSSurfaceCreateFlagsMVK # poke :: Ptr VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> IO () #
Bits VkIOSSurfaceCreateFlagsMVK Source #
Methods (.&.) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # (.\|.) :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # xor :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # complement :: VkIOSSurfaceCreateFlagsMVK -> VkIOSSurfaceCreateFlagsMVK # shift :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # rotate :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # zeroBits :: VkIOSSurfaceCreateFlagsMVK # bit :: Int -> VkIOSSurfaceCreateFlagsMVK # setBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # clearBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # complementBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # testBit :: VkIOSSurfaceCreateFlagsMVK -> Int -> Bool # bitSizeMaybe :: VkIOSSurfaceCreateFlagsMVK -> Maybe Int # bitSize :: VkIOSSurfaceCreateFlagsMVK -> Int # isSigned :: VkIOSSurfaceCreateFlagsMVK -> Bool # shiftL :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # unsafeShiftL :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # shiftR :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # unsafeShiftR :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # rotateL :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # rotateR :: VkIOSSurfaceCreateFlagsMVK -> Int -> VkIOSSurfaceCreateFlagsMVK # popCount :: VkIOSSurfaceCreateFlagsMVK -> Int #
FiniteBits VkIOSSurfaceCreateFlagsMVK Source #
Methods finiteBitSize :: VkIOSSurfaceCreateFlagsMVK -> Int # countLeadingZeros :: VkIOSSurfaceCreateFlagsMVK -> Int # countTrailingZeros :: VkIOSSurfaceCreateFlagsMVK -> Int #
type Rep VkIOSSurfaceCreateFlagsMVK Source #
type Rep VkIOSSurfaceCreateFlagsMVK = D1 (MetaData "VkIOSSurfaceCreateFlagsMVK" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkIOSSurfaceCreateFlagsMVK" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkImageViewCreateFlags Source #

Constructors

VkImageViewCreateFlags VkFlags

Instances

Bounded VkImageViewCreateFlags Source #
Methods minBound :: VkImageViewCreateFlags # maxBound :: VkImageViewCreateFlags #
Enum VkImageViewCreateFlags Source #
Methods succ :: VkImageViewCreateFlags -> VkImageViewCreateFlags # pred :: VkImageViewCreateFlags -> VkImageViewCreateFlags # toEnum :: Int -> VkImageViewCreateFlags # fromEnum :: VkImageViewCreateFlags -> Int # enumFrom :: VkImageViewCreateFlags -> [VkImageViewCreateFlags] # enumFromThen :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> [VkImageViewCreateFlags] # enumFromTo :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> [VkImageViewCreateFlags] # enumFromThenTo :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags -> [VkImageViewCreateFlags] #
Eq VkImageViewCreateFlags Source #
Methods (==) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> Bool # (/=) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> Bool #
Integral VkImageViewCreateFlags Source #
Methods quot :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # rem :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # div :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # mod :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # quotRem :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> (VkImageViewCreateFlags, VkImageViewCreateFlags) # divMod :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> (VkImageViewCreateFlags, VkImageViewCreateFlags) # toInteger :: VkImageViewCreateFlags -> Integer #
Data VkImageViewCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkImageViewCreateFlags -> c VkImageViewCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkImageViewCreateFlags # toConstr :: VkImageViewCreateFlags -> Constr # dataTypeOf :: VkImageViewCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkImageViewCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkImageViewCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkImageViewCreateFlags -> VkImageViewCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkImageViewCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkImageViewCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkImageViewCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkImageViewCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkImageViewCreateFlags -> m VkImageViewCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkImageViewCreateFlags -> m VkImageViewCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkImageViewCreateFlags -> m VkImageViewCreateFlags #
Num VkImageViewCreateFlags Source #
Methods (+) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # (-) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # (*) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # negate :: VkImageViewCreateFlags -> VkImageViewCreateFlags # abs :: VkImageViewCreateFlags -> VkImageViewCreateFlags # signum :: VkImageViewCreateFlags -> VkImageViewCreateFlags # fromInteger :: Integer -> VkImageViewCreateFlags #
Ord VkImageViewCreateFlags Source #
Methods compare :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> Ordering # (<) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> Bool # (<=) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> Bool # (>) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> Bool # (>=) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> Bool # max :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # min :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags #
Read VkImageViewCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkImageViewCreateFlags # readList :: ReadS [VkImageViewCreateFlags] # readPrec :: ReadPrec VkImageViewCreateFlags # readListPrec :: ReadPrec [VkImageViewCreateFlags] #
Real VkImageViewCreateFlags Source #
Methods toRational :: VkImageViewCreateFlags -> Rational #
Show VkImageViewCreateFlags Source #
Methods showsPrec :: Int -> VkImageViewCreateFlags -> ShowS # show :: VkImageViewCreateFlags -> String # showList :: [VkImageViewCreateFlags] -> ShowS #
Generic VkImageViewCreateFlags Source #
Associated Types type Rep VkImageViewCreateFlags :: * -> * # Methods from :: VkImageViewCreateFlags -> Rep VkImageViewCreateFlags x # to :: Rep VkImageViewCreateFlags x -> VkImageViewCreateFlags #
Storable VkImageViewCreateFlags Source #
Methods sizeOf :: VkImageViewCreateFlags -> Int # alignment :: VkImageViewCreateFlags -> Int # peekElemOff :: Ptr VkImageViewCreateFlags -> Int -> IO VkImageViewCreateFlags # pokeElemOff :: Ptr VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkImageViewCreateFlags # pokeByteOff :: Ptr b -> Int -> VkImageViewCreateFlags -> IO () # peek :: Ptr VkImageViewCreateFlags -> IO VkImageViewCreateFlags # poke :: Ptr VkImageViewCreateFlags -> VkImageViewCreateFlags -> IO () #
Bits VkImageViewCreateFlags Source #
Methods (.&.) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # (.\|.) :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # xor :: VkImageViewCreateFlags -> VkImageViewCreateFlags -> VkImageViewCreateFlags # complement :: VkImageViewCreateFlags -> VkImageViewCreateFlags # shift :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # rotate :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # zeroBits :: VkImageViewCreateFlags # bit :: Int -> VkImageViewCreateFlags # setBit :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # clearBit :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # complementBit :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # testBit :: VkImageViewCreateFlags -> Int -> Bool # bitSizeMaybe :: VkImageViewCreateFlags -> Maybe Int # bitSize :: VkImageViewCreateFlags -> Int # isSigned :: VkImageViewCreateFlags -> Bool # shiftL :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # unsafeShiftL :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # shiftR :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # unsafeShiftR :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # rotateL :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # rotateR :: VkImageViewCreateFlags -> Int -> VkImageViewCreateFlags # popCount :: VkImageViewCreateFlags -> Int #
FiniteBits VkImageViewCreateFlags Source #
Methods finiteBitSize :: VkImageViewCreateFlags -> Int # countLeadingZeros :: VkImageViewCreateFlags -> Int # countTrailingZeros :: VkImageViewCreateFlags -> Int #
type Rep VkImageViewCreateFlags Source #
type Rep VkImageViewCreateFlags = D1 (MetaData "VkImageViewCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkImageViewCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkInstanceCreateFlags Source #

Constructors

VkInstanceCreateFlags VkFlags

Instances

Bounded VkInstanceCreateFlags Source #
Methods minBound :: VkInstanceCreateFlags # maxBound :: VkInstanceCreateFlags #
Enum VkInstanceCreateFlags Source #
Methods succ :: VkInstanceCreateFlags -> VkInstanceCreateFlags # pred :: VkInstanceCreateFlags -> VkInstanceCreateFlags # toEnum :: Int -> VkInstanceCreateFlags # fromEnum :: VkInstanceCreateFlags -> Int # enumFrom :: VkInstanceCreateFlags -> [VkInstanceCreateFlags] # enumFromThen :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> [VkInstanceCreateFlags] # enumFromTo :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> [VkInstanceCreateFlags] # enumFromThenTo :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags -> [VkInstanceCreateFlags] #
Eq VkInstanceCreateFlags Source #
Methods (==) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool # (/=) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool #
Integral VkInstanceCreateFlags Source #
Methods quot :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # rem :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # div :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # mod :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # quotRem :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> (VkInstanceCreateFlags, VkInstanceCreateFlags) # divMod :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> (VkInstanceCreateFlags, VkInstanceCreateFlags) # toInteger :: VkInstanceCreateFlags -> Integer #
Data VkInstanceCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkInstanceCreateFlags -> c VkInstanceCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkInstanceCreateFlags # toConstr :: VkInstanceCreateFlags -> Constr # dataTypeOf :: VkInstanceCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkInstanceCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkInstanceCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkInstanceCreateFlags -> VkInstanceCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkInstanceCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkInstanceCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkInstanceCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkInstanceCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkInstanceCreateFlags -> m VkInstanceCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkInstanceCreateFlags -> m VkInstanceCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkInstanceCreateFlags -> m VkInstanceCreateFlags #
Num VkInstanceCreateFlags Source #
Methods (+) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # (-) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # (*) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # negate :: VkInstanceCreateFlags -> VkInstanceCreateFlags # abs :: VkInstanceCreateFlags -> VkInstanceCreateFlags # signum :: VkInstanceCreateFlags -> VkInstanceCreateFlags # fromInteger :: Integer -> VkInstanceCreateFlags #
Ord VkInstanceCreateFlags Source #
Methods compare :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Ordering # (<) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool # (<=) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool # (>) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool # (>=) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> Bool # max :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # min :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags #
Read VkInstanceCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkInstanceCreateFlags # readList :: ReadS [VkInstanceCreateFlags] # readPrec :: ReadPrec VkInstanceCreateFlags # readListPrec :: ReadPrec [VkInstanceCreateFlags] #
Real VkInstanceCreateFlags Source #
Methods toRational :: VkInstanceCreateFlags -> Rational #
Show VkInstanceCreateFlags Source #
Methods showsPrec :: Int -> VkInstanceCreateFlags -> ShowS # show :: VkInstanceCreateFlags -> String # showList :: [VkInstanceCreateFlags] -> ShowS #
Generic VkInstanceCreateFlags Source #
Associated Types type Rep VkInstanceCreateFlags :: * -> * # Methods from :: VkInstanceCreateFlags -> Rep VkInstanceCreateFlags x # to :: Rep VkInstanceCreateFlags x -> VkInstanceCreateFlags #
Storable VkInstanceCreateFlags Source #
Methods sizeOf :: VkInstanceCreateFlags -> Int # alignment :: VkInstanceCreateFlags -> Int # peekElemOff :: Ptr VkInstanceCreateFlags -> Int -> IO VkInstanceCreateFlags # pokeElemOff :: Ptr VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkInstanceCreateFlags # pokeByteOff :: Ptr b -> Int -> VkInstanceCreateFlags -> IO () # peek :: Ptr VkInstanceCreateFlags -> IO VkInstanceCreateFlags # poke :: Ptr VkInstanceCreateFlags -> VkInstanceCreateFlags -> IO () #
Bits VkInstanceCreateFlags Source #
Methods (.&.) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # (.\|.) :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # xor :: VkInstanceCreateFlags -> VkInstanceCreateFlags -> VkInstanceCreateFlags # complement :: VkInstanceCreateFlags -> VkInstanceCreateFlags # shift :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # rotate :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # zeroBits :: VkInstanceCreateFlags # bit :: Int -> VkInstanceCreateFlags # setBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # clearBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # complementBit :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # testBit :: VkInstanceCreateFlags -> Int -> Bool # bitSizeMaybe :: VkInstanceCreateFlags -> Maybe Int # bitSize :: VkInstanceCreateFlags -> Int # isSigned :: VkInstanceCreateFlags -> Bool # shiftL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # unsafeShiftL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # shiftR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # unsafeShiftR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # rotateL :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # rotateR :: VkInstanceCreateFlags -> Int -> VkInstanceCreateFlags # popCount :: VkInstanceCreateFlags -> Int #
FiniteBits VkInstanceCreateFlags Source #
Methods finiteBitSize :: VkInstanceCreateFlags -> Int # countLeadingZeros :: VkInstanceCreateFlags -> Int # countTrailingZeros :: VkInstanceCreateFlags -> Int #
type Rep VkInstanceCreateFlags Source #
type Rep VkInstanceCreateFlags = D1 (MetaData "VkInstanceCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkInstanceCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkMacOSSurfaceCreateFlagsMVK Source #

Constructors

VkMacOSSurfaceCreateFlagsMVK VkFlags

Instances

Bounded VkMacOSSurfaceCreateFlagsMVK Source #
Methods minBound :: VkMacOSSurfaceCreateFlagsMVK # maxBound :: VkMacOSSurfaceCreateFlagsMVK #
Enum VkMacOSSurfaceCreateFlagsMVK Source #
Methods succ :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # pred :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # toEnum :: Int -> VkMacOSSurfaceCreateFlagsMVK # fromEnum :: VkMacOSSurfaceCreateFlagsMVK -> Int # enumFrom :: VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK] # enumFromThen :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK] # enumFromTo :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK] # enumFromThenTo :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> [VkMacOSSurfaceCreateFlagsMVK] #
Eq VkMacOSSurfaceCreateFlagsMVK Source #
Methods (==) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> Bool # (/=) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> Bool #
Integral VkMacOSSurfaceCreateFlagsMVK Source #
Methods quot :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # rem :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # div :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # mod :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # quotRem :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> (VkMacOSSurfaceCreateFlagsMVK, VkMacOSSurfaceCreateFlagsMVK) # divMod :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> (VkMacOSSurfaceCreateFlagsMVK, VkMacOSSurfaceCreateFlagsMVK) # toInteger :: VkMacOSSurfaceCreateFlagsMVK -> Integer #
Data VkMacOSSurfaceCreateFlagsMVK Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkMacOSSurfaceCreateFlagsMVK -> c VkMacOSSurfaceCreateFlagsMVK # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkMacOSSurfaceCreateFlagsMVK # toConstr :: VkMacOSSurfaceCreateFlagsMVK -> Constr # dataTypeOf :: VkMacOSSurfaceCreateFlagsMVK -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkMacOSSurfaceCreateFlagsMVK) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkMacOSSurfaceCreateFlagsMVK) # gmapT :: (forall b. Data b => b -> b) -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkMacOSSurfaceCreateFlagsMVK -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkMacOSSurfaceCreateFlagsMVK -> r # gmapQ :: (forall d. Data d => d -> u) -> VkMacOSSurfaceCreateFlagsMVK -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkMacOSSurfaceCreateFlagsMVK -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkMacOSSurfaceCreateFlagsMVK -> m VkMacOSSurfaceCreateFlagsMVK # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkMacOSSurfaceCreateFlagsMVK -> m VkMacOSSurfaceCreateFlagsMVK # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkMacOSSurfaceCreateFlagsMVK -> m VkMacOSSurfaceCreateFlagsMVK #
Num VkMacOSSurfaceCreateFlagsMVK Source #
Methods (+) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # (-) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # (*) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # negate :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # abs :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # signum :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # fromInteger :: Integer -> VkMacOSSurfaceCreateFlagsMVK #
Ord VkMacOSSurfaceCreateFlagsMVK Source #
Methods compare :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> Ordering # (<) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> Bool # (<=) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> Bool # (>) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> Bool # (>=) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> Bool # max :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # min :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK #
Read VkMacOSSurfaceCreateFlagsMVK Source #
Methods readsPrec :: Int -> ReadS VkMacOSSurfaceCreateFlagsMVK # readList :: ReadS [VkMacOSSurfaceCreateFlagsMVK] # readPrec :: ReadPrec VkMacOSSurfaceCreateFlagsMVK # readListPrec :: ReadPrec [VkMacOSSurfaceCreateFlagsMVK] #
Real VkMacOSSurfaceCreateFlagsMVK Source #
Methods toRational :: VkMacOSSurfaceCreateFlagsMVK -> Rational #
Show VkMacOSSurfaceCreateFlagsMVK Source #
Methods showsPrec :: Int -> VkMacOSSurfaceCreateFlagsMVK -> ShowS # show :: VkMacOSSurfaceCreateFlagsMVK -> String # showList :: [VkMacOSSurfaceCreateFlagsMVK] -> ShowS #
Generic VkMacOSSurfaceCreateFlagsMVK Source #
Associated Types type Rep VkMacOSSurfaceCreateFlagsMVK :: * -> * # Methods from :: VkMacOSSurfaceCreateFlagsMVK -> Rep VkMacOSSurfaceCreateFlagsMVK x # to :: Rep VkMacOSSurfaceCreateFlagsMVK x -> VkMacOSSurfaceCreateFlagsMVK #
Storable VkMacOSSurfaceCreateFlagsMVK Source #
Methods sizeOf :: VkMacOSSurfaceCreateFlagsMVK -> Int # alignment :: VkMacOSSurfaceCreateFlagsMVK -> Int # peekElemOff :: Ptr VkMacOSSurfaceCreateFlagsMVK -> Int -> IO VkMacOSSurfaceCreateFlagsMVK # pokeElemOff :: Ptr VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK -> IO () # peekByteOff :: Ptr b -> Int -> IO VkMacOSSurfaceCreateFlagsMVK # pokeByteOff :: Ptr b -> Int -> VkMacOSSurfaceCreateFlagsMVK -> IO () # peek :: Ptr VkMacOSSurfaceCreateFlagsMVK -> IO VkMacOSSurfaceCreateFlagsMVK # poke :: Ptr VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> IO () #
Bits VkMacOSSurfaceCreateFlagsMVK Source #
Methods (.&.) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # (.\|.) :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # xor :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # complement :: VkMacOSSurfaceCreateFlagsMVK -> VkMacOSSurfaceCreateFlagsMVK # shift :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # rotate :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # zeroBits :: VkMacOSSurfaceCreateFlagsMVK # bit :: Int -> VkMacOSSurfaceCreateFlagsMVK # setBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # clearBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # complementBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # testBit :: VkMacOSSurfaceCreateFlagsMVK -> Int -> Bool # bitSizeMaybe :: VkMacOSSurfaceCreateFlagsMVK -> Maybe Int # bitSize :: VkMacOSSurfaceCreateFlagsMVK -> Int # isSigned :: VkMacOSSurfaceCreateFlagsMVK -> Bool # shiftL :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # unsafeShiftL :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # shiftR :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # unsafeShiftR :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # rotateL :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # rotateR :: VkMacOSSurfaceCreateFlagsMVK -> Int -> VkMacOSSurfaceCreateFlagsMVK # popCount :: VkMacOSSurfaceCreateFlagsMVK -> Int #
FiniteBits VkMacOSSurfaceCreateFlagsMVK Source #
Methods finiteBitSize :: VkMacOSSurfaceCreateFlagsMVK -> Int # countLeadingZeros :: VkMacOSSurfaceCreateFlagsMVK -> Int # countTrailingZeros :: VkMacOSSurfaceCreateFlagsMVK -> Int #
type Rep VkMacOSSurfaceCreateFlagsMVK Source #
type Rep VkMacOSSurfaceCreateFlagsMVK = D1 (MetaData "VkMacOSSurfaceCreateFlagsMVK" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkMacOSSurfaceCreateFlagsMVK" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkMemoryAllocateFlagsKHR Source #

Constructors

VkMemoryAllocateFlagsKHR VkFlags

Instances

Bounded VkMemoryAllocateFlagsKHR Source #
Methods minBound :: VkMemoryAllocateFlagsKHR # maxBound :: VkMemoryAllocateFlagsKHR #
Enum VkMemoryAllocateFlagsKHR Source #
Methods succ :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # pred :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # toEnum :: Int -> VkMemoryAllocateFlagsKHR # fromEnum :: VkMemoryAllocateFlagsKHR -> Int # enumFrom :: VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR] # enumFromThen :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR] # enumFromTo :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR] # enumFromThenTo :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> [VkMemoryAllocateFlagsKHR] #
Eq VkMemoryAllocateFlagsKHR Source #
Methods (==) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool # (/=) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool #
Integral VkMemoryAllocateFlagsKHR Source #
Methods quot :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # rem :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # div :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # mod :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # quotRem :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> (VkMemoryAllocateFlagsKHR, VkMemoryAllocateFlagsKHR) # divMod :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> (VkMemoryAllocateFlagsKHR, VkMemoryAllocateFlagsKHR) # toInteger :: VkMemoryAllocateFlagsKHR -> Integer #
Data VkMemoryAllocateFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkMemoryAllocateFlagsKHR -> c VkMemoryAllocateFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkMemoryAllocateFlagsKHR # toConstr :: VkMemoryAllocateFlagsKHR -> Constr # dataTypeOf :: VkMemoryAllocateFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkMemoryAllocateFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkMemoryAllocateFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkMemoryAllocateFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkMemoryAllocateFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkMemoryAllocateFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkMemoryAllocateFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkMemoryAllocateFlagsKHR -> m VkMemoryAllocateFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkMemoryAllocateFlagsKHR -> m VkMemoryAllocateFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkMemoryAllocateFlagsKHR -> m VkMemoryAllocateFlagsKHR #
Num VkMemoryAllocateFlagsKHR Source #
Methods (+) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # (-) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # (*) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # negate :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # abs :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # signum :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # fromInteger :: Integer -> VkMemoryAllocateFlagsKHR #
Ord VkMemoryAllocateFlagsKHR Source #
Methods compare :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Ordering # (<) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool # (<=) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool # (>) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool # (>=) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> Bool # max :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # min :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR #
Read VkMemoryAllocateFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkMemoryAllocateFlagsKHR # readList :: ReadS [VkMemoryAllocateFlagsKHR] # readPrec :: ReadPrec VkMemoryAllocateFlagsKHR # readListPrec :: ReadPrec [VkMemoryAllocateFlagsKHR] #
Real VkMemoryAllocateFlagsKHR Source #
Methods toRational :: VkMemoryAllocateFlagsKHR -> Rational #
Show VkMemoryAllocateFlagsKHR Source #
Methods showsPrec :: Int -> VkMemoryAllocateFlagsKHR -> ShowS # show :: VkMemoryAllocateFlagsKHR -> String # showList :: [VkMemoryAllocateFlagsKHR] -> ShowS #
Generic VkMemoryAllocateFlagsKHR Source #
Associated Types type Rep VkMemoryAllocateFlagsKHR :: * -> * # Methods from :: VkMemoryAllocateFlagsKHR -> Rep VkMemoryAllocateFlagsKHR x # to :: Rep VkMemoryAllocateFlagsKHR x -> VkMemoryAllocateFlagsKHR #
Storable VkMemoryAllocateFlagsKHR Source #
Methods sizeOf :: VkMemoryAllocateFlagsKHR -> Int # alignment :: VkMemoryAllocateFlagsKHR -> Int # peekElemOff :: Ptr VkMemoryAllocateFlagsKHR -> Int -> IO VkMemoryAllocateFlagsKHR # pokeElemOff :: Ptr VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkMemoryAllocateFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkMemoryAllocateFlagsKHR -> IO () # peek :: Ptr VkMemoryAllocateFlagsKHR -> IO VkMemoryAllocateFlagsKHR # poke :: Ptr VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> IO () #
Bits VkMemoryAllocateFlagsKHR Source #
Methods (.&.) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # (.\|.) :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # xor :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # complement :: VkMemoryAllocateFlagsKHR -> VkMemoryAllocateFlagsKHR # shift :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # rotate :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # zeroBits :: VkMemoryAllocateFlagsKHR # bit :: Int -> VkMemoryAllocateFlagsKHR # setBit :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # clearBit :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # complementBit :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # testBit :: VkMemoryAllocateFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkMemoryAllocateFlagsKHR -> Maybe Int # bitSize :: VkMemoryAllocateFlagsKHR -> Int # isSigned :: VkMemoryAllocateFlagsKHR -> Bool # shiftL :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # unsafeShiftL :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # shiftR :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # unsafeShiftR :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # rotateL :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # rotateR :: VkMemoryAllocateFlagsKHR -> Int -> VkMemoryAllocateFlagsKHR # popCount :: VkMemoryAllocateFlagsKHR -> Int #
FiniteBits VkMemoryAllocateFlagsKHR Source #
Methods finiteBitSize :: VkMemoryAllocateFlagsKHR -> Int # countLeadingZeros :: VkMemoryAllocateFlagsKHR -> Int # countTrailingZeros :: VkMemoryAllocateFlagsKHR -> Int #
type Rep VkMemoryAllocateFlagsKHR Source #
type Rep VkMemoryAllocateFlagsKHR = D1 (MetaData "VkMemoryAllocateFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkMemoryAllocateFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkMemoryMapFlags Source #

Constructors

VkMemoryMapFlags VkFlags

Instances

Bounded VkMemoryMapFlags Source #
Methods minBound :: VkMemoryMapFlags # maxBound :: VkMemoryMapFlags #
Enum VkMemoryMapFlags Source #
Methods succ :: VkMemoryMapFlags -> VkMemoryMapFlags # pred :: VkMemoryMapFlags -> VkMemoryMapFlags # toEnum :: Int -> VkMemoryMapFlags # fromEnum :: VkMemoryMapFlags -> Int # enumFrom :: VkMemoryMapFlags -> [VkMemoryMapFlags] # enumFromThen :: VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags] # enumFromTo :: VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags] # enumFromThenTo :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags -> [VkMemoryMapFlags] #
Eq VkMemoryMapFlags Source #
Methods (==) :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool # (/=) :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool #
Integral VkMemoryMapFlags Source #
Methods quot :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # rem :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # div :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # mod :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # quotRem :: VkMemoryMapFlags -> VkMemoryMapFlags -> (VkMemoryMapFlags, VkMemoryMapFlags) # divMod :: VkMemoryMapFlags -> VkMemoryMapFlags -> (VkMemoryMapFlags, VkMemoryMapFlags) # toInteger :: VkMemoryMapFlags -> Integer #
Data VkMemoryMapFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkMemoryMapFlags -> c VkMemoryMapFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkMemoryMapFlags # toConstr :: VkMemoryMapFlags -> Constr # dataTypeOf :: VkMemoryMapFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkMemoryMapFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkMemoryMapFlags) # gmapT :: (forall b. Data b => b -> b) -> VkMemoryMapFlags -> VkMemoryMapFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkMemoryMapFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkMemoryMapFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkMemoryMapFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkMemoryMapFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkMemoryMapFlags -> m VkMemoryMapFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkMemoryMapFlags -> m VkMemoryMapFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkMemoryMapFlags -> m VkMemoryMapFlags #
Num VkMemoryMapFlags Source #
Methods (+) :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # (-) :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # (*) :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # negate :: VkMemoryMapFlags -> VkMemoryMapFlags # abs :: VkMemoryMapFlags -> VkMemoryMapFlags # signum :: VkMemoryMapFlags -> VkMemoryMapFlags # fromInteger :: Integer -> VkMemoryMapFlags #
Ord VkMemoryMapFlags Source #
Methods compare :: VkMemoryMapFlags -> VkMemoryMapFlags -> Ordering # (<) :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool # (<=) :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool # (>) :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool # (>=) :: VkMemoryMapFlags -> VkMemoryMapFlags -> Bool # max :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # min :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags #
Read VkMemoryMapFlags Source #
Methods readsPrec :: Int -> ReadS VkMemoryMapFlags # readList :: ReadS [VkMemoryMapFlags] # readPrec :: ReadPrec VkMemoryMapFlags # readListPrec :: ReadPrec [VkMemoryMapFlags] #
Real VkMemoryMapFlags Source #
Methods toRational :: VkMemoryMapFlags -> Rational #
Show VkMemoryMapFlags Source #
Methods showsPrec :: Int -> VkMemoryMapFlags -> ShowS # show :: VkMemoryMapFlags -> String # showList :: [VkMemoryMapFlags] -> ShowS #
Generic VkMemoryMapFlags Source #
Associated Types type Rep VkMemoryMapFlags :: * -> * # Methods from :: VkMemoryMapFlags -> Rep VkMemoryMapFlags x # to :: Rep VkMemoryMapFlags x -> VkMemoryMapFlags #
Storable VkMemoryMapFlags Source #
Methods sizeOf :: VkMemoryMapFlags -> Int # alignment :: VkMemoryMapFlags -> Int # peekElemOff :: Ptr VkMemoryMapFlags -> Int -> IO VkMemoryMapFlags # pokeElemOff :: Ptr VkMemoryMapFlags -> Int -> VkMemoryMapFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkMemoryMapFlags # pokeByteOff :: Ptr b -> Int -> VkMemoryMapFlags -> IO () # peek :: Ptr VkMemoryMapFlags -> IO VkMemoryMapFlags # poke :: Ptr VkMemoryMapFlags -> VkMemoryMapFlags -> IO () #
Bits VkMemoryMapFlags Source #
Methods (.&.) :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # (.\|.) :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # xor :: VkMemoryMapFlags -> VkMemoryMapFlags -> VkMemoryMapFlags # complement :: VkMemoryMapFlags -> VkMemoryMapFlags # shift :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # rotate :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # zeroBits :: VkMemoryMapFlags # bit :: Int -> VkMemoryMapFlags # setBit :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # clearBit :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # complementBit :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # testBit :: VkMemoryMapFlags -> Int -> Bool # bitSizeMaybe :: VkMemoryMapFlags -> Maybe Int # bitSize :: VkMemoryMapFlags -> Int # isSigned :: VkMemoryMapFlags -> Bool # shiftL :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # unsafeShiftL :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # shiftR :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # unsafeShiftR :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # rotateL :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # rotateR :: VkMemoryMapFlags -> Int -> VkMemoryMapFlags # popCount :: VkMemoryMapFlags -> Int #
FiniteBits VkMemoryMapFlags Source #
Methods finiteBitSize :: VkMemoryMapFlags -> Int # countLeadingZeros :: VkMemoryMapFlags -> Int # countTrailingZeros :: VkMemoryMapFlags -> Int #
type Rep VkMemoryMapFlags Source #
type Rep VkMemoryMapFlags = D1 (MetaData "VkMemoryMapFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkMemoryMapFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkMirSurfaceCreateFlagsKHR Source #

Constructors

VkMirSurfaceCreateFlagsKHR VkFlags

Instances

Bounded VkMirSurfaceCreateFlagsKHR Source #
Methods minBound :: VkMirSurfaceCreateFlagsKHR # maxBound :: VkMirSurfaceCreateFlagsKHR #
Enum VkMirSurfaceCreateFlagsKHR Source #
Methods succ :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # pred :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # toEnum :: Int -> VkMirSurfaceCreateFlagsKHR # fromEnum :: VkMirSurfaceCreateFlagsKHR -> Int # enumFrom :: VkMirSurfaceCreateFlagsKHR -> [VkMirSurfaceCreateFlagsKHR] # enumFromThen :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> [VkMirSurfaceCreateFlagsKHR] # enumFromTo :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> [VkMirSurfaceCreateFlagsKHR] # enumFromThenTo :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> [VkMirSurfaceCreateFlagsKHR] #
Eq VkMirSurfaceCreateFlagsKHR Source #
Methods (==) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> Bool # (/=) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> Bool #
Integral VkMirSurfaceCreateFlagsKHR Source #
Methods quot :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # rem :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # div :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # mod :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # quotRem :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> (VkMirSurfaceCreateFlagsKHR, VkMirSurfaceCreateFlagsKHR) # divMod :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> (VkMirSurfaceCreateFlagsKHR, VkMirSurfaceCreateFlagsKHR) # toInteger :: VkMirSurfaceCreateFlagsKHR -> Integer #
Data VkMirSurfaceCreateFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkMirSurfaceCreateFlagsKHR -> c VkMirSurfaceCreateFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkMirSurfaceCreateFlagsKHR # toConstr :: VkMirSurfaceCreateFlagsKHR -> Constr # dataTypeOf :: VkMirSurfaceCreateFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkMirSurfaceCreateFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkMirSurfaceCreateFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkMirSurfaceCreateFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkMirSurfaceCreateFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkMirSurfaceCreateFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkMirSurfaceCreateFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkMirSurfaceCreateFlagsKHR -> m VkMirSurfaceCreateFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkMirSurfaceCreateFlagsKHR -> m VkMirSurfaceCreateFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkMirSurfaceCreateFlagsKHR -> m VkMirSurfaceCreateFlagsKHR #
Num VkMirSurfaceCreateFlagsKHR Source #
Methods (+) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # (-) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # (*) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # negate :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # abs :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # signum :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # fromInteger :: Integer -> VkMirSurfaceCreateFlagsKHR #
Ord VkMirSurfaceCreateFlagsKHR Source #
Methods compare :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> Ordering # (<) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> Bool # (<=) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> Bool # (>) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> Bool # (>=) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> Bool # max :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # min :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR #
Read VkMirSurfaceCreateFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkMirSurfaceCreateFlagsKHR # readList :: ReadS [VkMirSurfaceCreateFlagsKHR] # readPrec :: ReadPrec VkMirSurfaceCreateFlagsKHR # readListPrec :: ReadPrec [VkMirSurfaceCreateFlagsKHR] #
Real VkMirSurfaceCreateFlagsKHR Source #
Methods toRational :: VkMirSurfaceCreateFlagsKHR -> Rational #
Show VkMirSurfaceCreateFlagsKHR Source #
Methods showsPrec :: Int -> VkMirSurfaceCreateFlagsKHR -> ShowS # show :: VkMirSurfaceCreateFlagsKHR -> String # showList :: [VkMirSurfaceCreateFlagsKHR] -> ShowS #
Generic VkMirSurfaceCreateFlagsKHR Source #
Associated Types type Rep VkMirSurfaceCreateFlagsKHR :: * -> * # Methods from :: VkMirSurfaceCreateFlagsKHR -> Rep VkMirSurfaceCreateFlagsKHR x # to :: Rep VkMirSurfaceCreateFlagsKHR x -> VkMirSurfaceCreateFlagsKHR #
Storable VkMirSurfaceCreateFlagsKHR Source #
Methods sizeOf :: VkMirSurfaceCreateFlagsKHR -> Int # alignment :: VkMirSurfaceCreateFlagsKHR -> Int # peekElemOff :: Ptr VkMirSurfaceCreateFlagsKHR -> Int -> IO VkMirSurfaceCreateFlagsKHR # pokeElemOff :: Ptr VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkMirSurfaceCreateFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkMirSurfaceCreateFlagsKHR -> IO () # peek :: Ptr VkMirSurfaceCreateFlagsKHR -> IO VkMirSurfaceCreateFlagsKHR # poke :: Ptr VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> IO () #
Bits VkMirSurfaceCreateFlagsKHR Source #
Methods (.&.) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # (.\|.) :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # xor :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # complement :: VkMirSurfaceCreateFlagsKHR -> VkMirSurfaceCreateFlagsKHR # shift :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # rotate :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # zeroBits :: VkMirSurfaceCreateFlagsKHR # bit :: Int -> VkMirSurfaceCreateFlagsKHR # setBit :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # clearBit :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # complementBit :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # testBit :: VkMirSurfaceCreateFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkMirSurfaceCreateFlagsKHR -> Maybe Int # bitSize :: VkMirSurfaceCreateFlagsKHR -> Int # isSigned :: VkMirSurfaceCreateFlagsKHR -> Bool # shiftL :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # unsafeShiftL :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # shiftR :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # unsafeShiftR :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # rotateL :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # rotateR :: VkMirSurfaceCreateFlagsKHR -> Int -> VkMirSurfaceCreateFlagsKHR # popCount :: VkMirSurfaceCreateFlagsKHR -> Int #
FiniteBits VkMirSurfaceCreateFlagsKHR Source #
Methods finiteBitSize :: VkMirSurfaceCreateFlagsKHR -> Int # countLeadingZeros :: VkMirSurfaceCreateFlagsKHR -> Int # countTrailingZeros :: VkMirSurfaceCreateFlagsKHR -> Int #
type Rep VkMirSurfaceCreateFlagsKHR Source #
type Rep VkMirSurfaceCreateFlagsKHR = D1 (MetaData "VkMirSurfaceCreateFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkMirSurfaceCreateFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPeerMemoryFeatureFlagsKHR Source #

Constructors

VkPeerMemoryFeatureFlagsKHR VkFlags

Instances

Bounded VkPeerMemoryFeatureFlagsKHR Source #
Methods minBound :: VkPeerMemoryFeatureFlagsKHR # maxBound :: VkPeerMemoryFeatureFlagsKHR #
Enum VkPeerMemoryFeatureFlagsKHR Source #
Methods succ :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # pred :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # toEnum :: Int -> VkPeerMemoryFeatureFlagsKHR # fromEnum :: VkPeerMemoryFeatureFlagsKHR -> Int # enumFrom :: VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR] # enumFromThen :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR] # enumFromTo :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR] # enumFromThenTo :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> [VkPeerMemoryFeatureFlagsKHR] #
Eq VkPeerMemoryFeatureFlagsKHR Source #
Methods (==) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool # (/=) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool #
Integral VkPeerMemoryFeatureFlagsKHR Source #
Methods quot :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # rem :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # div :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # mod :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # quotRem :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> (VkPeerMemoryFeatureFlagsKHR, VkPeerMemoryFeatureFlagsKHR) # divMod :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> (VkPeerMemoryFeatureFlagsKHR, VkPeerMemoryFeatureFlagsKHR) # toInteger :: VkPeerMemoryFeatureFlagsKHR -> Integer #
Data VkPeerMemoryFeatureFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPeerMemoryFeatureFlagsKHR -> c VkPeerMemoryFeatureFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPeerMemoryFeatureFlagsKHR # toConstr :: VkPeerMemoryFeatureFlagsKHR -> Constr # dataTypeOf :: VkPeerMemoryFeatureFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPeerMemoryFeatureFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPeerMemoryFeatureFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPeerMemoryFeatureFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPeerMemoryFeatureFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPeerMemoryFeatureFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPeerMemoryFeatureFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPeerMemoryFeatureFlagsKHR -> m VkPeerMemoryFeatureFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPeerMemoryFeatureFlagsKHR -> m VkPeerMemoryFeatureFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPeerMemoryFeatureFlagsKHR -> m VkPeerMemoryFeatureFlagsKHR #
Num VkPeerMemoryFeatureFlagsKHR Source #
Methods (+) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # (-) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # (*) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # negate :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # abs :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # signum :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # fromInteger :: Integer -> VkPeerMemoryFeatureFlagsKHR #
Ord VkPeerMemoryFeatureFlagsKHR Source #
Methods compare :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Ordering # (<) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool # (<=) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool # (>) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool # (>=) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> Bool # max :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # min :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR #
Read VkPeerMemoryFeatureFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkPeerMemoryFeatureFlagsKHR # readList :: ReadS [VkPeerMemoryFeatureFlagsKHR] # readPrec :: ReadPrec VkPeerMemoryFeatureFlagsKHR # readListPrec :: ReadPrec [VkPeerMemoryFeatureFlagsKHR] #
Real VkPeerMemoryFeatureFlagsKHR Source #
Methods toRational :: VkPeerMemoryFeatureFlagsKHR -> Rational #
Show VkPeerMemoryFeatureFlagsKHR Source #
Methods showsPrec :: Int -> VkPeerMemoryFeatureFlagsKHR -> ShowS # show :: VkPeerMemoryFeatureFlagsKHR -> String # showList :: [VkPeerMemoryFeatureFlagsKHR] -> ShowS #
Generic VkPeerMemoryFeatureFlagsKHR Source #
Associated Types type Rep VkPeerMemoryFeatureFlagsKHR :: * -> * # Methods from :: VkPeerMemoryFeatureFlagsKHR -> Rep VkPeerMemoryFeatureFlagsKHR x # to :: Rep VkPeerMemoryFeatureFlagsKHR x -> VkPeerMemoryFeatureFlagsKHR #
Storable VkPeerMemoryFeatureFlagsKHR Source #
Methods sizeOf :: VkPeerMemoryFeatureFlagsKHR -> Int # alignment :: VkPeerMemoryFeatureFlagsKHR -> Int # peekElemOff :: Ptr VkPeerMemoryFeatureFlagsKHR -> Int -> IO VkPeerMemoryFeatureFlagsKHR # pokeElemOff :: Ptr VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPeerMemoryFeatureFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkPeerMemoryFeatureFlagsKHR -> IO () # peek :: Ptr VkPeerMemoryFeatureFlagsKHR -> IO VkPeerMemoryFeatureFlagsKHR # poke :: Ptr VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> IO () #
Bits VkPeerMemoryFeatureFlagsKHR Source #
Methods (.&.) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # (.\|.) :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # xor :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # complement :: VkPeerMemoryFeatureFlagsKHR -> VkPeerMemoryFeatureFlagsKHR # shift :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # rotate :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # zeroBits :: VkPeerMemoryFeatureFlagsKHR # bit :: Int -> VkPeerMemoryFeatureFlagsKHR # setBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # clearBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # complementBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # testBit :: VkPeerMemoryFeatureFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkPeerMemoryFeatureFlagsKHR -> Maybe Int # bitSize :: VkPeerMemoryFeatureFlagsKHR -> Int # isSigned :: VkPeerMemoryFeatureFlagsKHR -> Bool # shiftL :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # unsafeShiftL :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # shiftR :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # unsafeShiftR :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # rotateL :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # rotateR :: VkPeerMemoryFeatureFlagsKHR -> Int -> VkPeerMemoryFeatureFlagsKHR # popCount :: VkPeerMemoryFeatureFlagsKHR -> Int #
FiniteBits VkPeerMemoryFeatureFlagsKHR Source #
Methods finiteBitSize :: VkPeerMemoryFeatureFlagsKHR -> Int # countLeadingZeros :: VkPeerMemoryFeatureFlagsKHR -> Int # countTrailingZeros :: VkPeerMemoryFeatureFlagsKHR -> Int #
type Rep VkPeerMemoryFeatureFlagsKHR Source #
type Rep VkPeerMemoryFeatureFlagsKHR = D1 (MetaData "VkPeerMemoryFeatureFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPeerMemoryFeatureFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineCacheCreateFlags Source #

Constructors

VkPipelineCacheCreateFlags VkFlags

Instances

Bounded VkPipelineCacheCreateFlags Source #
Methods minBound :: VkPipelineCacheCreateFlags # maxBound :: VkPipelineCacheCreateFlags #
Enum VkPipelineCacheCreateFlags Source #
Methods succ :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # pred :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # toEnum :: Int -> VkPipelineCacheCreateFlags # fromEnum :: VkPipelineCacheCreateFlags -> Int # enumFrom :: VkPipelineCacheCreateFlags -> [VkPipelineCacheCreateFlags] # enumFromThen :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> [VkPipelineCacheCreateFlags] # enumFromTo :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> [VkPipelineCacheCreateFlags] # enumFromThenTo :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> [VkPipelineCacheCreateFlags] #
Eq VkPipelineCacheCreateFlags Source #
Methods (==) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool # (/=) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool #
Integral VkPipelineCacheCreateFlags Source #
Methods quot :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # rem :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # div :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # mod :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # quotRem :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> (VkPipelineCacheCreateFlags, VkPipelineCacheCreateFlags) # divMod :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> (VkPipelineCacheCreateFlags, VkPipelineCacheCreateFlags) # toInteger :: VkPipelineCacheCreateFlags -> Integer #
Data VkPipelineCacheCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineCacheCreateFlags -> c VkPipelineCacheCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineCacheCreateFlags # toConstr :: VkPipelineCacheCreateFlags -> Constr # dataTypeOf :: VkPipelineCacheCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineCacheCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineCacheCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineCacheCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineCacheCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineCacheCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineCacheCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineCacheCreateFlags -> m VkPipelineCacheCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineCacheCreateFlags -> m VkPipelineCacheCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineCacheCreateFlags -> m VkPipelineCacheCreateFlags #
Num VkPipelineCacheCreateFlags Source #
Methods (+) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # (-) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # (*) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # negate :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # abs :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # signum :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # fromInteger :: Integer -> VkPipelineCacheCreateFlags #
Ord VkPipelineCacheCreateFlags Source #
Methods compare :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Ordering # (<) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool # (<=) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool # (>) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool # (>=) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> Bool # max :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # min :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags #
Read VkPipelineCacheCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineCacheCreateFlags # readList :: ReadS [VkPipelineCacheCreateFlags] # readPrec :: ReadPrec VkPipelineCacheCreateFlags # readListPrec :: ReadPrec [VkPipelineCacheCreateFlags] #
Real VkPipelineCacheCreateFlags Source #
Methods toRational :: VkPipelineCacheCreateFlags -> Rational #
Show VkPipelineCacheCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineCacheCreateFlags -> ShowS # show :: VkPipelineCacheCreateFlags -> String # showList :: [VkPipelineCacheCreateFlags] -> ShowS #
Generic VkPipelineCacheCreateFlags Source #
Associated Types type Rep VkPipelineCacheCreateFlags :: * -> * # Methods from :: VkPipelineCacheCreateFlags -> Rep VkPipelineCacheCreateFlags x # to :: Rep VkPipelineCacheCreateFlags x -> VkPipelineCacheCreateFlags #
Storable VkPipelineCacheCreateFlags Source #
Methods sizeOf :: VkPipelineCacheCreateFlags -> Int # alignment :: VkPipelineCacheCreateFlags -> Int # peekElemOff :: Ptr VkPipelineCacheCreateFlags -> Int -> IO VkPipelineCacheCreateFlags # pokeElemOff :: Ptr VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineCacheCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineCacheCreateFlags -> IO () # peek :: Ptr VkPipelineCacheCreateFlags -> IO VkPipelineCacheCreateFlags # poke :: Ptr VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> IO () #
Bits VkPipelineCacheCreateFlags Source #
Methods (.&.) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # (.\|.) :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # xor :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # complement :: VkPipelineCacheCreateFlags -> VkPipelineCacheCreateFlags # shift :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # rotate :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # zeroBits :: VkPipelineCacheCreateFlags # bit :: Int -> VkPipelineCacheCreateFlags # setBit :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # clearBit :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # complementBit :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # testBit :: VkPipelineCacheCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineCacheCreateFlags -> Maybe Int # bitSize :: VkPipelineCacheCreateFlags -> Int # isSigned :: VkPipelineCacheCreateFlags -> Bool # shiftL :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # unsafeShiftL :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # shiftR :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # unsafeShiftR :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # rotateL :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # rotateR :: VkPipelineCacheCreateFlags -> Int -> VkPipelineCacheCreateFlags # popCount :: VkPipelineCacheCreateFlags -> Int #
FiniteBits VkPipelineCacheCreateFlags Source #
Methods finiteBitSize :: VkPipelineCacheCreateFlags -> Int # countLeadingZeros :: VkPipelineCacheCreateFlags -> Int # countTrailingZeros :: VkPipelineCacheCreateFlags -> Int #
type Rep VkPipelineCacheCreateFlags Source #
type Rep VkPipelineCacheCreateFlags = D1 (MetaData "VkPipelineCacheCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineCacheCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineColorBlendStateCreateFlags Source #

Constructors

VkPipelineColorBlendStateCreateFlags VkFlags

Instances

Bounded VkPipelineColorBlendStateCreateFlags Source #
Methods minBound :: VkPipelineColorBlendStateCreateFlags # maxBound :: VkPipelineColorBlendStateCreateFlags #
Enum VkPipelineColorBlendStateCreateFlags Source #
Methods succ :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # pred :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # toEnum :: Int -> VkPipelineColorBlendStateCreateFlags # fromEnum :: VkPipelineColorBlendStateCreateFlags -> Int # enumFrom :: VkPipelineColorBlendStateCreateFlags -> [VkPipelineColorBlendStateCreateFlags] # enumFromThen :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> [VkPipelineColorBlendStateCreateFlags] # enumFromTo :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> [VkPipelineColorBlendStateCreateFlags] # enumFromThenTo :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> [VkPipelineColorBlendStateCreateFlags] #
Eq VkPipelineColorBlendStateCreateFlags Source #
Methods (==) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # (/=) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool #
Integral VkPipelineColorBlendStateCreateFlags Source #
Methods quot :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # rem :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # div :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # mod :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # quotRem :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> (VkPipelineColorBlendStateCreateFlags, VkPipelineColorBlendStateCreateFlags) # divMod :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> (VkPipelineColorBlendStateCreateFlags, VkPipelineColorBlendStateCreateFlags) # toInteger :: VkPipelineColorBlendStateCreateFlags -> Integer #
Data VkPipelineColorBlendStateCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineColorBlendStateCreateFlags -> c VkPipelineColorBlendStateCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineColorBlendStateCreateFlags # toConstr :: VkPipelineColorBlendStateCreateFlags -> Constr # dataTypeOf :: VkPipelineColorBlendStateCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineColorBlendStateCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineColorBlendStateCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineColorBlendStateCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineColorBlendStateCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineColorBlendStateCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineColorBlendStateCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineColorBlendStateCreateFlags -> m VkPipelineColorBlendStateCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineColorBlendStateCreateFlags -> m VkPipelineColorBlendStateCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineColorBlendStateCreateFlags -> m VkPipelineColorBlendStateCreateFlags #
Num VkPipelineColorBlendStateCreateFlags Source #
Methods (+) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # (-) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # (*) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # negate :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # abs :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # signum :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # fromInteger :: Integer -> VkPipelineColorBlendStateCreateFlags #
Ord VkPipelineColorBlendStateCreateFlags Source #
Methods compare :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Ordering # (<) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # (<=) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # (>) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # (>=) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # max :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # min :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags #
Read VkPipelineColorBlendStateCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineColorBlendStateCreateFlags # readList :: ReadS [VkPipelineColorBlendStateCreateFlags] # readPrec :: ReadPrec VkPipelineColorBlendStateCreateFlags # readListPrec :: ReadPrec [VkPipelineColorBlendStateCreateFlags] #
Real VkPipelineColorBlendStateCreateFlags Source #
Methods toRational :: VkPipelineColorBlendStateCreateFlags -> Rational #
Show VkPipelineColorBlendStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineColorBlendStateCreateFlags -> ShowS # show :: VkPipelineColorBlendStateCreateFlags -> String # showList :: [VkPipelineColorBlendStateCreateFlags] -> ShowS #
Generic VkPipelineColorBlendStateCreateFlags Source #
Associated Types type Rep VkPipelineColorBlendStateCreateFlags :: * -> * # Methods from :: VkPipelineColorBlendStateCreateFlags -> Rep VkPipelineColorBlendStateCreateFlags x # to :: Rep VkPipelineColorBlendStateCreateFlags x -> VkPipelineColorBlendStateCreateFlags #
Storable VkPipelineColorBlendStateCreateFlags Source #
Methods sizeOf :: VkPipelineColorBlendStateCreateFlags -> Int # alignment :: VkPipelineColorBlendStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineColorBlendStateCreateFlags -> Int -> IO VkPipelineColorBlendStateCreateFlags # pokeElemOff :: Ptr VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineColorBlendStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineColorBlendStateCreateFlags -> IO () # peek :: Ptr VkPipelineColorBlendStateCreateFlags -> IO VkPipelineColorBlendStateCreateFlags # poke :: Ptr VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> IO () #
Bits VkPipelineColorBlendStateCreateFlags Source #
Methods (.&.) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # (.\|.) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # xor :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # complement :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # shift :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # rotate :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # zeroBits :: VkPipelineColorBlendStateCreateFlags # bit :: Int -> VkPipelineColorBlendStateCreateFlags # setBit :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # clearBit :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # complementBit :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # testBit :: VkPipelineColorBlendStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineColorBlendStateCreateFlags -> Maybe Int # bitSize :: VkPipelineColorBlendStateCreateFlags -> Int # isSigned :: VkPipelineColorBlendStateCreateFlags -> Bool # shiftL :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # unsafeShiftL :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # shiftR :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # unsafeShiftR :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # rotateL :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # rotateR :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # popCount :: VkPipelineColorBlendStateCreateFlags -> Int #
FiniteBits VkPipelineColorBlendStateCreateFlags Source #
Methods finiteBitSize :: VkPipelineColorBlendStateCreateFlags -> Int # countLeadingZeros :: VkPipelineColorBlendStateCreateFlags -> Int # countTrailingZeros :: VkPipelineColorBlendStateCreateFlags -> Int #
type Rep VkPipelineColorBlendStateCreateFlags Source #
type Rep VkPipelineColorBlendStateCreateFlags = D1 (MetaData "VkPipelineColorBlendStateCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineColorBlendStateCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineCoverageModulationStateCreateFlagsNV Source #

Constructors

VkPipelineCoverageModulationStateCreateFlagsNV VkFlags

Instances

Bounded VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods minBound :: VkPipelineCoverageModulationStateCreateFlagsNV # maxBound :: VkPipelineCoverageModulationStateCreateFlagsNV #
Enum VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods succ :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # pred :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # toEnum :: Int -> VkPipelineCoverageModulationStateCreateFlagsNV # fromEnum :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int # enumFrom :: VkPipelineCoverageModulationStateCreateFlagsNV -> [VkPipelineCoverageModulationStateCreateFlagsNV] # enumFromThen :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> [VkPipelineCoverageModulationStateCreateFlagsNV] # enumFromTo :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> [VkPipelineCoverageModulationStateCreateFlagsNV] # enumFromThenTo :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> [VkPipelineCoverageModulationStateCreateFlagsNV] #
Eq VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods (==) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool # (/=) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool #
Integral VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods quot :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # rem :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # div :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # mod :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # quotRem :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> (VkPipelineCoverageModulationStateCreateFlagsNV, VkPipelineCoverageModulationStateCreateFlagsNV) # divMod :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> (VkPipelineCoverageModulationStateCreateFlagsNV, VkPipelineCoverageModulationStateCreateFlagsNV) # toInteger :: VkPipelineCoverageModulationStateCreateFlagsNV -> Integer #
Data VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineCoverageModulationStateCreateFlagsNV -> c VkPipelineCoverageModulationStateCreateFlagsNV # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineCoverageModulationStateCreateFlagsNV # toConstr :: VkPipelineCoverageModulationStateCreateFlagsNV -> Constr # dataTypeOf :: VkPipelineCoverageModulationStateCreateFlagsNV -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineCoverageModulationStateCreateFlagsNV) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineCoverageModulationStateCreateFlagsNV) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineCoverageModulationStateCreateFlagsNV -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineCoverageModulationStateCreateFlagsNV -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineCoverageModulationStateCreateFlagsNV -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineCoverageModulationStateCreateFlagsNV -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineCoverageModulationStateCreateFlagsNV -> m VkPipelineCoverageModulationStateCreateFlagsNV # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineCoverageModulationStateCreateFlagsNV -> m VkPipelineCoverageModulationStateCreateFlagsNV # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineCoverageModulationStateCreateFlagsNV -> m VkPipelineCoverageModulationStateCreateFlagsNV #
Num VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods (+) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # (-) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # (*) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # negate :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # abs :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # signum :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # fromInteger :: Integer -> VkPipelineCoverageModulationStateCreateFlagsNV #
Ord VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods compare :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> Ordering # (<) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool # (<=) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool # (>) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool # (>=) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> Bool # max :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # min :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV #
Read VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods readsPrec :: Int -> ReadS VkPipelineCoverageModulationStateCreateFlagsNV # readList :: ReadS [VkPipelineCoverageModulationStateCreateFlagsNV] # readPrec :: ReadPrec VkPipelineCoverageModulationStateCreateFlagsNV # readListPrec :: ReadPrec [VkPipelineCoverageModulationStateCreateFlagsNV] #
Real VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods toRational :: VkPipelineCoverageModulationStateCreateFlagsNV -> Rational #
Show VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods showsPrec :: Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> ShowS # show :: VkPipelineCoverageModulationStateCreateFlagsNV -> String # showList :: [VkPipelineCoverageModulationStateCreateFlagsNV] -> ShowS #
Generic VkPipelineCoverageModulationStateCreateFlagsNV Source #
Associated Types type Rep VkPipelineCoverageModulationStateCreateFlagsNV :: * -> * # Methods from :: VkPipelineCoverageModulationStateCreateFlagsNV -> Rep VkPipelineCoverageModulationStateCreateFlagsNV x # to :: Rep VkPipelineCoverageModulationStateCreateFlagsNV x -> VkPipelineCoverageModulationStateCreateFlagsNV #
Storable VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods sizeOf :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int # alignment :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int # peekElemOff :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> IO VkPipelineCoverageModulationStateCreateFlagsNV # pokeElemOff :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineCoverageModulationStateCreateFlagsNV # pokeByteOff :: Ptr b -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO () # peek :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV -> IO VkPipelineCoverageModulationStateCreateFlagsNV # poke :: Ptr VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> IO () #
Bits VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods (.&.) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # (.\|.) :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # xor :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # complement :: VkPipelineCoverageModulationStateCreateFlagsNV -> VkPipelineCoverageModulationStateCreateFlagsNV # shift :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # rotate :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # zeroBits :: VkPipelineCoverageModulationStateCreateFlagsNV # bit :: Int -> VkPipelineCoverageModulationStateCreateFlagsNV # setBit :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # clearBit :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # complementBit :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # testBit :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> Bool # bitSizeMaybe :: VkPipelineCoverageModulationStateCreateFlagsNV -> Maybe Int # bitSize :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int # isSigned :: VkPipelineCoverageModulationStateCreateFlagsNV -> Bool # shiftL :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # unsafeShiftL :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # shiftR :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # unsafeShiftR :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # rotateL :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # rotateR :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int -> VkPipelineCoverageModulationStateCreateFlagsNV # popCount :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int #
FiniteBits VkPipelineCoverageModulationStateCreateFlagsNV Source #
Methods finiteBitSize :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int # countLeadingZeros :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int # countTrailingZeros :: VkPipelineCoverageModulationStateCreateFlagsNV -> Int #
type Rep VkPipelineCoverageModulationStateCreateFlagsNV Source #
type Rep VkPipelineCoverageModulationStateCreateFlagsNV = D1 (MetaData "VkPipelineCoverageModulationStateCreateFlagsNV" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineCoverageModulationStateCreateFlagsNV" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineCoverageToColorStateCreateFlagsNV Source #

Constructors

VkPipelineCoverageToColorStateCreateFlagsNV VkFlags

Instances

Bounded VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods minBound :: VkPipelineCoverageToColorStateCreateFlagsNV # maxBound :: VkPipelineCoverageToColorStateCreateFlagsNV #
Enum VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods succ :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # pred :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # toEnum :: Int -> VkPipelineCoverageToColorStateCreateFlagsNV # fromEnum :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int # enumFrom :: VkPipelineCoverageToColorStateCreateFlagsNV -> [VkPipelineCoverageToColorStateCreateFlagsNV] # enumFromThen :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> [VkPipelineCoverageToColorStateCreateFlagsNV] # enumFromTo :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> [VkPipelineCoverageToColorStateCreateFlagsNV] # enumFromThenTo :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> [VkPipelineCoverageToColorStateCreateFlagsNV] #
Eq VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods (==) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool # (/=) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool #
Integral VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods quot :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # rem :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # div :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # mod :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # quotRem :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> (VkPipelineCoverageToColorStateCreateFlagsNV, VkPipelineCoverageToColorStateCreateFlagsNV) # divMod :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> (VkPipelineCoverageToColorStateCreateFlagsNV, VkPipelineCoverageToColorStateCreateFlagsNV) # toInteger :: VkPipelineCoverageToColorStateCreateFlagsNV -> Integer #
Data VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineCoverageToColorStateCreateFlagsNV -> c VkPipelineCoverageToColorStateCreateFlagsNV # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineCoverageToColorStateCreateFlagsNV # toConstr :: VkPipelineCoverageToColorStateCreateFlagsNV -> Constr # dataTypeOf :: VkPipelineCoverageToColorStateCreateFlagsNV -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineCoverageToColorStateCreateFlagsNV) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineCoverageToColorStateCreateFlagsNV) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineCoverageToColorStateCreateFlagsNV -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineCoverageToColorStateCreateFlagsNV -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineCoverageToColorStateCreateFlagsNV -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineCoverageToColorStateCreateFlagsNV -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineCoverageToColorStateCreateFlagsNV -> m VkPipelineCoverageToColorStateCreateFlagsNV # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineCoverageToColorStateCreateFlagsNV -> m VkPipelineCoverageToColorStateCreateFlagsNV # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineCoverageToColorStateCreateFlagsNV -> m VkPipelineCoverageToColorStateCreateFlagsNV #
Num VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods (+) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # (-) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # (*) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # negate :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # abs :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # signum :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # fromInteger :: Integer -> VkPipelineCoverageToColorStateCreateFlagsNV #
Ord VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods compare :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> Ordering # (<) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool # (<=) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool # (>) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool # (>=) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> Bool # max :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # min :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV #
Read VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods readsPrec :: Int -> ReadS VkPipelineCoverageToColorStateCreateFlagsNV # readList :: ReadS [VkPipelineCoverageToColorStateCreateFlagsNV] # readPrec :: ReadPrec VkPipelineCoverageToColorStateCreateFlagsNV # readListPrec :: ReadPrec [VkPipelineCoverageToColorStateCreateFlagsNV] #
Real VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods toRational :: VkPipelineCoverageToColorStateCreateFlagsNV -> Rational #
Show VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods showsPrec :: Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> ShowS # show :: VkPipelineCoverageToColorStateCreateFlagsNV -> String # showList :: [VkPipelineCoverageToColorStateCreateFlagsNV] -> ShowS #
Generic VkPipelineCoverageToColorStateCreateFlagsNV Source #
Associated Types type Rep VkPipelineCoverageToColorStateCreateFlagsNV :: * -> * # Methods from :: VkPipelineCoverageToColorStateCreateFlagsNV -> Rep VkPipelineCoverageToColorStateCreateFlagsNV x # to :: Rep VkPipelineCoverageToColorStateCreateFlagsNV x -> VkPipelineCoverageToColorStateCreateFlagsNV #
Storable VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods sizeOf :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int # alignment :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int # peekElemOff :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> IO VkPipelineCoverageToColorStateCreateFlagsNV # pokeElemOff :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineCoverageToColorStateCreateFlagsNV # pokeByteOff :: Ptr b -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO () # peek :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV -> IO VkPipelineCoverageToColorStateCreateFlagsNV # poke :: Ptr VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> IO () #
Bits VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods (.&.) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # (.\|.) :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # xor :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # complement :: VkPipelineCoverageToColorStateCreateFlagsNV -> VkPipelineCoverageToColorStateCreateFlagsNV # shift :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # rotate :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # zeroBits :: VkPipelineCoverageToColorStateCreateFlagsNV # bit :: Int -> VkPipelineCoverageToColorStateCreateFlagsNV # setBit :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # clearBit :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # complementBit :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # testBit :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> Bool # bitSizeMaybe :: VkPipelineCoverageToColorStateCreateFlagsNV -> Maybe Int # bitSize :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int # isSigned :: VkPipelineCoverageToColorStateCreateFlagsNV -> Bool # shiftL :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # unsafeShiftL :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # shiftR :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # unsafeShiftR :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # rotateL :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # rotateR :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int -> VkPipelineCoverageToColorStateCreateFlagsNV # popCount :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int #
FiniteBits VkPipelineCoverageToColorStateCreateFlagsNV Source #
Methods finiteBitSize :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int # countLeadingZeros :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int # countTrailingZeros :: VkPipelineCoverageToColorStateCreateFlagsNV -> Int #
type Rep VkPipelineCoverageToColorStateCreateFlagsNV Source #
type Rep VkPipelineCoverageToColorStateCreateFlagsNV = D1 (MetaData "VkPipelineCoverageToColorStateCreateFlagsNV" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineCoverageToColorStateCreateFlagsNV" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineDepthStencilStateCreateFlags Source #

Constructors

VkPipelineDepthStencilStateCreateFlags VkFlags

Instances

Bounded VkPipelineDepthStencilStateCreateFlags Source #
Methods minBound :: VkPipelineDepthStencilStateCreateFlags # maxBound :: VkPipelineDepthStencilStateCreateFlags #
Enum VkPipelineDepthStencilStateCreateFlags Source #
Methods succ :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # pred :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # toEnum :: Int -> VkPipelineDepthStencilStateCreateFlags # fromEnum :: VkPipelineDepthStencilStateCreateFlags -> Int # enumFrom :: VkPipelineDepthStencilStateCreateFlags -> [VkPipelineDepthStencilStateCreateFlags] # enumFromThen :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> [VkPipelineDepthStencilStateCreateFlags] # enumFromTo :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> [VkPipelineDepthStencilStateCreateFlags] # enumFromThenTo :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> [VkPipelineDepthStencilStateCreateFlags] #
Eq VkPipelineDepthStencilStateCreateFlags Source #
Methods (==) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # (/=) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool #
Integral VkPipelineDepthStencilStateCreateFlags Source #
Methods quot :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # rem :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # div :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # mod :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # quotRem :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> (VkPipelineDepthStencilStateCreateFlags, VkPipelineDepthStencilStateCreateFlags) # divMod :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> (VkPipelineDepthStencilStateCreateFlags, VkPipelineDepthStencilStateCreateFlags) # toInteger :: VkPipelineDepthStencilStateCreateFlags -> Integer #
Data VkPipelineDepthStencilStateCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineDepthStencilStateCreateFlags -> c VkPipelineDepthStencilStateCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineDepthStencilStateCreateFlags # toConstr :: VkPipelineDepthStencilStateCreateFlags -> Constr # dataTypeOf :: VkPipelineDepthStencilStateCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineDepthStencilStateCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineDepthStencilStateCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineDepthStencilStateCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineDepthStencilStateCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineDepthStencilStateCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineDepthStencilStateCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineDepthStencilStateCreateFlags -> m VkPipelineDepthStencilStateCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineDepthStencilStateCreateFlags -> m VkPipelineDepthStencilStateCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineDepthStencilStateCreateFlags -> m VkPipelineDepthStencilStateCreateFlags #
Num VkPipelineDepthStencilStateCreateFlags Source #
Methods (+) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # (-) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # (*) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # negate :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # abs :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # signum :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # fromInteger :: Integer -> VkPipelineDepthStencilStateCreateFlags #
Ord VkPipelineDepthStencilStateCreateFlags Source #
Methods compare :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Ordering # (<) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # (<=) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # (>) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # (>=) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # max :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # min :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags #
Read VkPipelineDepthStencilStateCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineDepthStencilStateCreateFlags # readList :: ReadS [VkPipelineDepthStencilStateCreateFlags] # readPrec :: ReadPrec VkPipelineDepthStencilStateCreateFlags # readListPrec :: ReadPrec [VkPipelineDepthStencilStateCreateFlags] #
Real VkPipelineDepthStencilStateCreateFlags Source #
Methods toRational :: VkPipelineDepthStencilStateCreateFlags -> Rational #
Show VkPipelineDepthStencilStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineDepthStencilStateCreateFlags -> ShowS # show :: VkPipelineDepthStencilStateCreateFlags -> String # showList :: [VkPipelineDepthStencilStateCreateFlags] -> ShowS #
Generic VkPipelineDepthStencilStateCreateFlags Source #
Associated Types type Rep VkPipelineDepthStencilStateCreateFlags :: * -> * # Methods from :: VkPipelineDepthStencilStateCreateFlags -> Rep VkPipelineDepthStencilStateCreateFlags x # to :: Rep VkPipelineDepthStencilStateCreateFlags x -> VkPipelineDepthStencilStateCreateFlags #
Storable VkPipelineDepthStencilStateCreateFlags Source #
Methods sizeOf :: VkPipelineDepthStencilStateCreateFlags -> Int # alignment :: VkPipelineDepthStencilStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineDepthStencilStateCreateFlags -> Int -> IO VkPipelineDepthStencilStateCreateFlags # pokeElemOff :: Ptr VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineDepthStencilStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineDepthStencilStateCreateFlags -> IO () # peek :: Ptr VkPipelineDepthStencilStateCreateFlags -> IO VkPipelineDepthStencilStateCreateFlags # poke :: Ptr VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> IO () #
Bits VkPipelineDepthStencilStateCreateFlags Source #
Methods (.&.) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # (.\|.) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # xor :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # complement :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # shift :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # rotate :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # zeroBits :: VkPipelineDepthStencilStateCreateFlags # bit :: Int -> VkPipelineDepthStencilStateCreateFlags # setBit :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # clearBit :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # complementBit :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # testBit :: VkPipelineDepthStencilStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineDepthStencilStateCreateFlags -> Maybe Int # bitSize :: VkPipelineDepthStencilStateCreateFlags -> Int # isSigned :: VkPipelineDepthStencilStateCreateFlags -> Bool # shiftL :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # unsafeShiftL :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # shiftR :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # unsafeShiftR :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # rotateL :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # rotateR :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # popCount :: VkPipelineDepthStencilStateCreateFlags -> Int #
FiniteBits VkPipelineDepthStencilStateCreateFlags Source #
Methods finiteBitSize :: VkPipelineDepthStencilStateCreateFlags -> Int # countLeadingZeros :: VkPipelineDepthStencilStateCreateFlags -> Int # countTrailingZeros :: VkPipelineDepthStencilStateCreateFlags -> Int #
type Rep VkPipelineDepthStencilStateCreateFlags Source #
type Rep VkPipelineDepthStencilStateCreateFlags = D1 (MetaData "VkPipelineDepthStencilStateCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineDepthStencilStateCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineDiscardRectangleStateCreateFlagsEXT Source #

Constructors

VkPipelineDiscardRectangleStateCreateFlagsEXT VkFlags

Instances

Bounded VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods minBound :: VkPipelineDiscardRectangleStateCreateFlagsEXT # maxBound :: VkPipelineDiscardRectangleStateCreateFlagsEXT #
Enum VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods succ :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # pred :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # toEnum :: Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # fromEnum :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int # enumFrom :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> [VkPipelineDiscardRectangleStateCreateFlagsEXT] # enumFromThen :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> [VkPipelineDiscardRectangleStateCreateFlagsEXT] # enumFromTo :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> [VkPipelineDiscardRectangleStateCreateFlagsEXT] # enumFromThenTo :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> [VkPipelineDiscardRectangleStateCreateFlagsEXT] #
Eq VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods (==) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool # (/=) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool #
Integral VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods quot :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # rem :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # div :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # mod :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # quotRem :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> (VkPipelineDiscardRectangleStateCreateFlagsEXT, VkPipelineDiscardRectangleStateCreateFlagsEXT) # divMod :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> (VkPipelineDiscardRectangleStateCreateFlagsEXT, VkPipelineDiscardRectangleStateCreateFlagsEXT) # toInteger :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Integer #
Data VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> c VkPipelineDiscardRectangleStateCreateFlagsEXT # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineDiscardRectangleStateCreateFlagsEXT # toConstr :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Constr # dataTypeOf :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineDiscardRectangleStateCreateFlagsEXT) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineDiscardRectangleStateCreateFlagsEXT) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> m VkPipelineDiscardRectangleStateCreateFlagsEXT # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> m VkPipelineDiscardRectangleStateCreateFlagsEXT # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> m VkPipelineDiscardRectangleStateCreateFlagsEXT #
Num VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods (+) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # (-) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # (*) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # negate :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # abs :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # signum :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # fromInteger :: Integer -> VkPipelineDiscardRectangleStateCreateFlagsEXT #
Ord VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods compare :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Ordering # (<) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool # (<=) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool # (>) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool # (>=) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool # max :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # min :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT #
Read VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods readsPrec :: Int -> ReadS VkPipelineDiscardRectangleStateCreateFlagsEXT # readList :: ReadS [VkPipelineDiscardRectangleStateCreateFlagsEXT] # readPrec :: ReadPrec VkPipelineDiscardRectangleStateCreateFlagsEXT # readListPrec :: ReadPrec [VkPipelineDiscardRectangleStateCreateFlagsEXT] #
Real VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods toRational :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Rational #
Show VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods showsPrec :: Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> ShowS # show :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> String # showList :: [VkPipelineDiscardRectangleStateCreateFlagsEXT] -> ShowS #
Generic VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Associated Types type Rep VkPipelineDiscardRectangleStateCreateFlagsEXT :: * -> * # Methods from :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Rep VkPipelineDiscardRectangleStateCreateFlagsEXT x # to :: Rep VkPipelineDiscardRectangleStateCreateFlagsEXT x -> VkPipelineDiscardRectangleStateCreateFlagsEXT #
Storable VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods sizeOf :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int # alignment :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int # peekElemOff :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT # pokeElemOff :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT # pokeByteOff :: Ptr b -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO () # peek :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO VkPipelineDiscardRectangleStateCreateFlagsEXT # poke :: Ptr VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> IO () #
Bits VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods (.&.) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # (.\|.) :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # xor :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # complement :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> VkPipelineDiscardRectangleStateCreateFlagsEXT # shift :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # rotate :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # zeroBits :: VkPipelineDiscardRectangleStateCreateFlagsEXT # bit :: Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # setBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # clearBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # complementBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # testBit :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> Bool # bitSizeMaybe :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Maybe Int # bitSize :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int # isSigned :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Bool # shiftL :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # unsafeShiftL :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # shiftR :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # unsafeShiftR :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # rotateL :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # rotateR :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int -> VkPipelineDiscardRectangleStateCreateFlagsEXT # popCount :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int #
FiniteBits VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
Methods finiteBitSize :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int # countLeadingZeros :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int # countTrailingZeros :: VkPipelineDiscardRectangleStateCreateFlagsEXT -> Int #
type Rep VkPipelineDiscardRectangleStateCreateFlagsEXT Source #
type Rep VkPipelineDiscardRectangleStateCreateFlagsEXT = D1 (MetaData "VkPipelineDiscardRectangleStateCreateFlagsEXT" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineDiscardRectangleStateCreateFlagsEXT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineDynamicStateCreateFlags Source #

Constructors

VkPipelineDynamicStateCreateFlags VkFlags

Instances

Bounded VkPipelineDynamicStateCreateFlags Source #
Methods minBound :: VkPipelineDynamicStateCreateFlags # maxBound :: VkPipelineDynamicStateCreateFlags #
Enum VkPipelineDynamicStateCreateFlags Source #
Methods succ :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # pred :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # toEnum :: Int -> VkPipelineDynamicStateCreateFlags # fromEnum :: VkPipelineDynamicStateCreateFlags -> Int # enumFrom :: VkPipelineDynamicStateCreateFlags -> [VkPipelineDynamicStateCreateFlags] # enumFromThen :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> [VkPipelineDynamicStateCreateFlags] # enumFromTo :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> [VkPipelineDynamicStateCreateFlags] # enumFromThenTo :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> [VkPipelineDynamicStateCreateFlags] #
Eq VkPipelineDynamicStateCreateFlags Source #
Methods (==) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # (/=) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool #
Integral VkPipelineDynamicStateCreateFlags Source #
Methods quot :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # rem :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # div :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # mod :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # quotRem :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> (VkPipelineDynamicStateCreateFlags, VkPipelineDynamicStateCreateFlags) # divMod :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> (VkPipelineDynamicStateCreateFlags, VkPipelineDynamicStateCreateFlags) # toInteger :: VkPipelineDynamicStateCreateFlags -> Integer #
Data VkPipelineDynamicStateCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineDynamicStateCreateFlags -> c VkPipelineDynamicStateCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineDynamicStateCreateFlags # toConstr :: VkPipelineDynamicStateCreateFlags -> Constr # dataTypeOf :: VkPipelineDynamicStateCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineDynamicStateCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineDynamicStateCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineDynamicStateCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineDynamicStateCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineDynamicStateCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineDynamicStateCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineDynamicStateCreateFlags -> m VkPipelineDynamicStateCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineDynamicStateCreateFlags -> m VkPipelineDynamicStateCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineDynamicStateCreateFlags -> m VkPipelineDynamicStateCreateFlags #
Num VkPipelineDynamicStateCreateFlags Source #
Methods (+) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # (-) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # (*) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # negate :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # abs :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # signum :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # fromInteger :: Integer -> VkPipelineDynamicStateCreateFlags #
Ord VkPipelineDynamicStateCreateFlags Source #
Methods compare :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Ordering # (<) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # (<=) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # (>) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # (>=) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # max :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # min :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags #
Read VkPipelineDynamicStateCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineDynamicStateCreateFlags # readList :: ReadS [VkPipelineDynamicStateCreateFlags] # readPrec :: ReadPrec VkPipelineDynamicStateCreateFlags # readListPrec :: ReadPrec [VkPipelineDynamicStateCreateFlags] #
Real VkPipelineDynamicStateCreateFlags Source #
Methods toRational :: VkPipelineDynamicStateCreateFlags -> Rational #
Show VkPipelineDynamicStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineDynamicStateCreateFlags -> ShowS # show :: VkPipelineDynamicStateCreateFlags -> String # showList :: [VkPipelineDynamicStateCreateFlags] -> ShowS #
Generic VkPipelineDynamicStateCreateFlags Source #
Associated Types type Rep VkPipelineDynamicStateCreateFlags :: * -> * # Methods from :: VkPipelineDynamicStateCreateFlags -> Rep VkPipelineDynamicStateCreateFlags x # to :: Rep VkPipelineDynamicStateCreateFlags x -> VkPipelineDynamicStateCreateFlags #
Storable VkPipelineDynamicStateCreateFlags Source #
Methods sizeOf :: VkPipelineDynamicStateCreateFlags -> Int # alignment :: VkPipelineDynamicStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineDynamicStateCreateFlags -> Int -> IO VkPipelineDynamicStateCreateFlags # pokeElemOff :: Ptr VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineDynamicStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineDynamicStateCreateFlags -> IO () # peek :: Ptr VkPipelineDynamicStateCreateFlags -> IO VkPipelineDynamicStateCreateFlags # poke :: Ptr VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> IO () #
Bits VkPipelineDynamicStateCreateFlags Source #
Methods (.&.) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # (.\|.) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # xor :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # complement :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # shift :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # rotate :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # zeroBits :: VkPipelineDynamicStateCreateFlags # bit :: Int -> VkPipelineDynamicStateCreateFlags # setBit :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # clearBit :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # complementBit :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # testBit :: VkPipelineDynamicStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineDynamicStateCreateFlags -> Maybe Int # bitSize :: VkPipelineDynamicStateCreateFlags -> Int # isSigned :: VkPipelineDynamicStateCreateFlags -> Bool # shiftL :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # unsafeShiftL :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # shiftR :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # unsafeShiftR :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # rotateL :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # rotateR :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # popCount :: VkPipelineDynamicStateCreateFlags -> Int #
FiniteBits VkPipelineDynamicStateCreateFlags Source #
Methods finiteBitSize :: VkPipelineDynamicStateCreateFlags -> Int # countLeadingZeros :: VkPipelineDynamicStateCreateFlags -> Int # countTrailingZeros :: VkPipelineDynamicStateCreateFlags -> Int #
type Rep VkPipelineDynamicStateCreateFlags Source #
type Rep VkPipelineDynamicStateCreateFlags = D1 (MetaData "VkPipelineDynamicStateCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineDynamicStateCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineInputAssemblyStateCreateFlags Source #

Constructors

VkPipelineInputAssemblyStateCreateFlags VkFlags

Instances

Bounded VkPipelineInputAssemblyStateCreateFlags Source #
Methods minBound :: VkPipelineInputAssemblyStateCreateFlags # maxBound :: VkPipelineInputAssemblyStateCreateFlags #
Enum VkPipelineInputAssemblyStateCreateFlags Source #
Methods succ :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # pred :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # toEnum :: Int -> VkPipelineInputAssemblyStateCreateFlags # fromEnum :: VkPipelineInputAssemblyStateCreateFlags -> Int # enumFrom :: VkPipelineInputAssemblyStateCreateFlags -> [VkPipelineInputAssemblyStateCreateFlags] # enumFromThen :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> [VkPipelineInputAssemblyStateCreateFlags] # enumFromTo :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> [VkPipelineInputAssemblyStateCreateFlags] # enumFromThenTo :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> [VkPipelineInputAssemblyStateCreateFlags] #
Eq VkPipelineInputAssemblyStateCreateFlags Source #
Methods (==) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # (/=) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool #
Integral VkPipelineInputAssemblyStateCreateFlags Source #
Methods quot :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # rem :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # div :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # mod :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # quotRem :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> (VkPipelineInputAssemblyStateCreateFlags, VkPipelineInputAssemblyStateCreateFlags) # divMod :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> (VkPipelineInputAssemblyStateCreateFlags, VkPipelineInputAssemblyStateCreateFlags) # toInteger :: VkPipelineInputAssemblyStateCreateFlags -> Integer #
Data VkPipelineInputAssemblyStateCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineInputAssemblyStateCreateFlags -> c VkPipelineInputAssemblyStateCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineInputAssemblyStateCreateFlags # toConstr :: VkPipelineInputAssemblyStateCreateFlags -> Constr # dataTypeOf :: VkPipelineInputAssemblyStateCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineInputAssemblyStateCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineInputAssemblyStateCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineInputAssemblyStateCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineInputAssemblyStateCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineInputAssemblyStateCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineInputAssemblyStateCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineInputAssemblyStateCreateFlags -> m VkPipelineInputAssemblyStateCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineInputAssemblyStateCreateFlags -> m VkPipelineInputAssemblyStateCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineInputAssemblyStateCreateFlags -> m VkPipelineInputAssemblyStateCreateFlags #
Num VkPipelineInputAssemblyStateCreateFlags Source #
Methods (+) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # (-) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # (*) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # negate :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # abs :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # signum :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # fromInteger :: Integer -> VkPipelineInputAssemblyStateCreateFlags #
Ord VkPipelineInputAssemblyStateCreateFlags Source #
Methods compare :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Ordering # (<) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # (<=) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # (>) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # (>=) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # max :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # min :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags #
Read VkPipelineInputAssemblyStateCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineInputAssemblyStateCreateFlags # readList :: ReadS [VkPipelineInputAssemblyStateCreateFlags] # readPrec :: ReadPrec VkPipelineInputAssemblyStateCreateFlags # readListPrec :: ReadPrec [VkPipelineInputAssemblyStateCreateFlags] #
Real VkPipelineInputAssemblyStateCreateFlags Source #
Methods toRational :: VkPipelineInputAssemblyStateCreateFlags -> Rational #
Show VkPipelineInputAssemblyStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineInputAssemblyStateCreateFlags -> ShowS # show :: VkPipelineInputAssemblyStateCreateFlags -> String # showList :: [VkPipelineInputAssemblyStateCreateFlags] -> ShowS #
Generic VkPipelineInputAssemblyStateCreateFlags Source #
Associated Types type Rep VkPipelineInputAssemblyStateCreateFlags :: * -> * # Methods from :: VkPipelineInputAssemblyStateCreateFlags -> Rep VkPipelineInputAssemblyStateCreateFlags x # to :: Rep VkPipelineInputAssemblyStateCreateFlags x -> VkPipelineInputAssemblyStateCreateFlags #
Storable VkPipelineInputAssemblyStateCreateFlags Source #
Methods sizeOf :: VkPipelineInputAssemblyStateCreateFlags -> Int # alignment :: VkPipelineInputAssemblyStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineInputAssemblyStateCreateFlags -> Int -> IO VkPipelineInputAssemblyStateCreateFlags # pokeElemOff :: Ptr VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineInputAssemblyStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO () # peek :: Ptr VkPipelineInputAssemblyStateCreateFlags -> IO VkPipelineInputAssemblyStateCreateFlags # poke :: Ptr VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> IO () #
Bits VkPipelineInputAssemblyStateCreateFlags Source #
Methods (.&.) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # (.\|.) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # xor :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # complement :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # shift :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # rotate :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # zeroBits :: VkPipelineInputAssemblyStateCreateFlags # bit :: Int -> VkPipelineInputAssemblyStateCreateFlags # setBit :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # clearBit :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # complementBit :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # testBit :: VkPipelineInputAssemblyStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineInputAssemblyStateCreateFlags -> Maybe Int # bitSize :: VkPipelineInputAssemblyStateCreateFlags -> Int # isSigned :: VkPipelineInputAssemblyStateCreateFlags -> Bool # shiftL :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # unsafeShiftL :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # shiftR :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # unsafeShiftR :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # rotateL :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # rotateR :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # popCount :: VkPipelineInputAssemblyStateCreateFlags -> Int #
FiniteBits VkPipelineInputAssemblyStateCreateFlags Source #
Methods finiteBitSize :: VkPipelineInputAssemblyStateCreateFlags -> Int # countLeadingZeros :: VkPipelineInputAssemblyStateCreateFlags -> Int # countTrailingZeros :: VkPipelineInputAssemblyStateCreateFlags -> Int #
type Rep VkPipelineInputAssemblyStateCreateFlags Source #
type Rep VkPipelineInputAssemblyStateCreateFlags = D1 (MetaData "VkPipelineInputAssemblyStateCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineInputAssemblyStateCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineLayoutCreateFlags Source #

Constructors

VkPipelineLayoutCreateFlags VkFlags

Instances

Bounded VkPipelineLayoutCreateFlags Source #
Methods minBound :: VkPipelineLayoutCreateFlags # maxBound :: VkPipelineLayoutCreateFlags #
Enum VkPipelineLayoutCreateFlags Source #
Methods succ :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # pred :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # toEnum :: Int -> VkPipelineLayoutCreateFlags # fromEnum :: VkPipelineLayoutCreateFlags -> Int # enumFrom :: VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags] # enumFromThen :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags] # enumFromTo :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags] # enumFromThenTo :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> [VkPipelineLayoutCreateFlags] #
Eq VkPipelineLayoutCreateFlags Source #
Methods (==) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool # (/=) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool #
Integral VkPipelineLayoutCreateFlags Source #
Methods quot :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # rem :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # div :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # mod :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # quotRem :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> (VkPipelineLayoutCreateFlags, VkPipelineLayoutCreateFlags) # divMod :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> (VkPipelineLayoutCreateFlags, VkPipelineLayoutCreateFlags) # toInteger :: VkPipelineLayoutCreateFlags -> Integer #
Data VkPipelineLayoutCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineLayoutCreateFlags -> c VkPipelineLayoutCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineLayoutCreateFlags # toConstr :: VkPipelineLayoutCreateFlags -> Constr # dataTypeOf :: VkPipelineLayoutCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineLayoutCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineLayoutCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineLayoutCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineLayoutCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineLayoutCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineLayoutCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineLayoutCreateFlags -> m VkPipelineLayoutCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineLayoutCreateFlags -> m VkPipelineLayoutCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineLayoutCreateFlags -> m VkPipelineLayoutCreateFlags #
Num VkPipelineLayoutCreateFlags Source #
Methods (+) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # (-) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # (*) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # negate :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # abs :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # signum :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # fromInteger :: Integer -> VkPipelineLayoutCreateFlags #
Ord VkPipelineLayoutCreateFlags Source #
Methods compare :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Ordering # (<) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool # (<=) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool # (>) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool # (>=) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> Bool # max :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # min :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags #
Read VkPipelineLayoutCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineLayoutCreateFlags # readList :: ReadS [VkPipelineLayoutCreateFlags] # readPrec :: ReadPrec VkPipelineLayoutCreateFlags # readListPrec :: ReadPrec [VkPipelineLayoutCreateFlags] #
Real VkPipelineLayoutCreateFlags Source #
Methods toRational :: VkPipelineLayoutCreateFlags -> Rational #
Show VkPipelineLayoutCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineLayoutCreateFlags -> ShowS # show :: VkPipelineLayoutCreateFlags -> String # showList :: [VkPipelineLayoutCreateFlags] -> ShowS #
Generic VkPipelineLayoutCreateFlags Source #
Associated Types type Rep VkPipelineLayoutCreateFlags :: * -> * # Methods from :: VkPipelineLayoutCreateFlags -> Rep VkPipelineLayoutCreateFlags x # to :: Rep VkPipelineLayoutCreateFlags x -> VkPipelineLayoutCreateFlags #
Storable VkPipelineLayoutCreateFlags Source #
Methods sizeOf :: VkPipelineLayoutCreateFlags -> Int # alignment :: VkPipelineLayoutCreateFlags -> Int # peekElemOff :: Ptr VkPipelineLayoutCreateFlags -> Int -> IO VkPipelineLayoutCreateFlags # pokeElemOff :: Ptr VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineLayoutCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineLayoutCreateFlags -> IO () # peek :: Ptr VkPipelineLayoutCreateFlags -> IO VkPipelineLayoutCreateFlags # poke :: Ptr VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> IO () #
Bits VkPipelineLayoutCreateFlags Source #
Methods (.&.) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # (.\|.) :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # xor :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # complement :: VkPipelineLayoutCreateFlags -> VkPipelineLayoutCreateFlags # shift :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # rotate :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # zeroBits :: VkPipelineLayoutCreateFlags # bit :: Int -> VkPipelineLayoutCreateFlags # setBit :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # clearBit :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # complementBit :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # testBit :: VkPipelineLayoutCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineLayoutCreateFlags -> Maybe Int # bitSize :: VkPipelineLayoutCreateFlags -> Int # isSigned :: VkPipelineLayoutCreateFlags -> Bool # shiftL :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # unsafeShiftL :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # shiftR :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # unsafeShiftR :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # rotateL :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # rotateR :: VkPipelineLayoutCreateFlags -> Int -> VkPipelineLayoutCreateFlags # popCount :: VkPipelineLayoutCreateFlags -> Int #
FiniteBits VkPipelineLayoutCreateFlags Source #
Methods finiteBitSize :: VkPipelineLayoutCreateFlags -> Int # countLeadingZeros :: VkPipelineLayoutCreateFlags -> Int # countTrailingZeros :: VkPipelineLayoutCreateFlags -> Int #
type Rep VkPipelineLayoutCreateFlags Source #
type Rep VkPipelineLayoutCreateFlags = D1 (MetaData "VkPipelineLayoutCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineLayoutCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineMultisampleStateCreateFlags Source #

Constructors

VkPipelineMultisampleStateCreateFlags VkFlags

Instances

Bounded VkPipelineMultisampleStateCreateFlags Source #
Methods minBound :: VkPipelineMultisampleStateCreateFlags # maxBound :: VkPipelineMultisampleStateCreateFlags #
Enum VkPipelineMultisampleStateCreateFlags Source #
Methods succ :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # pred :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # toEnum :: Int -> VkPipelineMultisampleStateCreateFlags # fromEnum :: VkPipelineMultisampleStateCreateFlags -> Int # enumFrom :: VkPipelineMultisampleStateCreateFlags -> [VkPipelineMultisampleStateCreateFlags] # enumFromThen :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> [VkPipelineMultisampleStateCreateFlags] # enumFromTo :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> [VkPipelineMultisampleStateCreateFlags] # enumFromThenTo :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> [VkPipelineMultisampleStateCreateFlags] #
Eq VkPipelineMultisampleStateCreateFlags Source #
Methods (==) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # (/=) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool #
Integral VkPipelineMultisampleStateCreateFlags Source #
Methods quot :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # rem :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # div :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # mod :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # quotRem :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> (VkPipelineMultisampleStateCreateFlags, VkPipelineMultisampleStateCreateFlags) # divMod :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> (VkPipelineMultisampleStateCreateFlags, VkPipelineMultisampleStateCreateFlags) # toInteger :: VkPipelineMultisampleStateCreateFlags -> Integer #
Data VkPipelineMultisampleStateCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineMultisampleStateCreateFlags -> c VkPipelineMultisampleStateCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineMultisampleStateCreateFlags # toConstr :: VkPipelineMultisampleStateCreateFlags -> Constr # dataTypeOf :: VkPipelineMultisampleStateCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineMultisampleStateCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineMultisampleStateCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineMultisampleStateCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineMultisampleStateCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineMultisampleStateCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineMultisampleStateCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineMultisampleStateCreateFlags -> m VkPipelineMultisampleStateCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineMultisampleStateCreateFlags -> m VkPipelineMultisampleStateCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineMultisampleStateCreateFlags -> m VkPipelineMultisampleStateCreateFlags #
Num VkPipelineMultisampleStateCreateFlags Source #
Methods (+) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # (-) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # (*) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # negate :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # abs :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # signum :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # fromInteger :: Integer -> VkPipelineMultisampleStateCreateFlags #
Ord VkPipelineMultisampleStateCreateFlags Source #
Methods compare :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Ordering # (<) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # (<=) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # (>) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # (>=) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # max :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # min :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags #
Read VkPipelineMultisampleStateCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineMultisampleStateCreateFlags # readList :: ReadS [VkPipelineMultisampleStateCreateFlags] # readPrec :: ReadPrec VkPipelineMultisampleStateCreateFlags # readListPrec :: ReadPrec [VkPipelineMultisampleStateCreateFlags] #
Real VkPipelineMultisampleStateCreateFlags Source #
Methods toRational :: VkPipelineMultisampleStateCreateFlags -> Rational #
Show VkPipelineMultisampleStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineMultisampleStateCreateFlags -> ShowS # show :: VkPipelineMultisampleStateCreateFlags -> String # showList :: [VkPipelineMultisampleStateCreateFlags] -> ShowS #
Generic VkPipelineMultisampleStateCreateFlags Source #
Associated Types type Rep VkPipelineMultisampleStateCreateFlags :: * -> * # Methods from :: VkPipelineMultisampleStateCreateFlags -> Rep VkPipelineMultisampleStateCreateFlags x # to :: Rep VkPipelineMultisampleStateCreateFlags x -> VkPipelineMultisampleStateCreateFlags #
Storable VkPipelineMultisampleStateCreateFlags Source #
Methods sizeOf :: VkPipelineMultisampleStateCreateFlags -> Int # alignment :: VkPipelineMultisampleStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineMultisampleStateCreateFlags -> Int -> IO VkPipelineMultisampleStateCreateFlags # pokeElemOff :: Ptr VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineMultisampleStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineMultisampleStateCreateFlags -> IO () # peek :: Ptr VkPipelineMultisampleStateCreateFlags -> IO VkPipelineMultisampleStateCreateFlags # poke :: Ptr VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> IO () #
Bits VkPipelineMultisampleStateCreateFlags Source #
Methods (.&.) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # (.\|.) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # xor :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # complement :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # shift :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # rotate :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # zeroBits :: VkPipelineMultisampleStateCreateFlags # bit :: Int -> VkPipelineMultisampleStateCreateFlags # setBit :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # clearBit :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # complementBit :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # testBit :: VkPipelineMultisampleStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineMultisampleStateCreateFlags -> Maybe Int # bitSize :: VkPipelineMultisampleStateCreateFlags -> Int # isSigned :: VkPipelineMultisampleStateCreateFlags -> Bool # shiftL :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # unsafeShiftL :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # shiftR :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # unsafeShiftR :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # rotateL :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # rotateR :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # popCount :: VkPipelineMultisampleStateCreateFlags -> Int #
FiniteBits VkPipelineMultisampleStateCreateFlags Source #
Methods finiteBitSize :: VkPipelineMultisampleStateCreateFlags -> Int # countLeadingZeros :: VkPipelineMultisampleStateCreateFlags -> Int # countTrailingZeros :: VkPipelineMultisampleStateCreateFlags -> Int #
type Rep VkPipelineMultisampleStateCreateFlags Source #
type Rep VkPipelineMultisampleStateCreateFlags = D1 (MetaData "VkPipelineMultisampleStateCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineMultisampleStateCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #

Constructors

VkPipelineRasterizationConservativeStateCreateFlagsEXT VkFlags

Instances

Bounded VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods minBound :: VkPipelineRasterizationConservativeStateCreateFlagsEXT # maxBound :: VkPipelineRasterizationConservativeStateCreateFlagsEXT #
Enum VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods succ :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # pred :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # toEnum :: Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # fromEnum :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int # enumFrom :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> [VkPipelineRasterizationConservativeStateCreateFlagsEXT] # enumFromThen :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> [VkPipelineRasterizationConservativeStateCreateFlagsEXT] # enumFromTo :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> [VkPipelineRasterizationConservativeStateCreateFlagsEXT] # enumFromThenTo :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> [VkPipelineRasterizationConservativeStateCreateFlagsEXT] #
Eq VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods (==) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool # (/=) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool #
Integral VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods quot :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # rem :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # div :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # mod :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # quotRem :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> (VkPipelineRasterizationConservativeStateCreateFlagsEXT, VkPipelineRasterizationConservativeStateCreateFlagsEXT) # divMod :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> (VkPipelineRasterizationConservativeStateCreateFlagsEXT, VkPipelineRasterizationConservativeStateCreateFlagsEXT) # toInteger :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Integer #
Data VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> c VkPipelineRasterizationConservativeStateCreateFlagsEXT # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineRasterizationConservativeStateCreateFlagsEXT # toConstr :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Constr # dataTypeOf :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineRasterizationConservativeStateCreateFlagsEXT) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineRasterizationConservativeStateCreateFlagsEXT) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> m VkPipelineRasterizationConservativeStateCreateFlagsEXT # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> m VkPipelineRasterizationConservativeStateCreateFlagsEXT # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> m VkPipelineRasterizationConservativeStateCreateFlagsEXT #
Num VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods (+) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # (-) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # (*) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # negate :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # abs :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # signum :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # fromInteger :: Integer -> VkPipelineRasterizationConservativeStateCreateFlagsEXT #
Ord VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods compare :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Ordering # (<) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool # (<=) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool # (>) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool # (>=) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool # max :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # min :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT #
Read VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods readsPrec :: Int -> ReadS VkPipelineRasterizationConservativeStateCreateFlagsEXT # readList :: ReadS [VkPipelineRasterizationConservativeStateCreateFlagsEXT] # readPrec :: ReadPrec VkPipelineRasterizationConservativeStateCreateFlagsEXT # readListPrec :: ReadPrec [VkPipelineRasterizationConservativeStateCreateFlagsEXT] #
Real VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods toRational :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Rational #
Show VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods showsPrec :: Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> ShowS # show :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> String # showList :: [VkPipelineRasterizationConservativeStateCreateFlagsEXT] -> ShowS #
Generic VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Associated Types type Rep VkPipelineRasterizationConservativeStateCreateFlagsEXT :: * -> * # Methods from :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Rep VkPipelineRasterizationConservativeStateCreateFlagsEXT x # to :: Rep VkPipelineRasterizationConservativeStateCreateFlagsEXT x -> VkPipelineRasterizationConservativeStateCreateFlagsEXT #
Storable VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods sizeOf :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int # alignment :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int # peekElemOff :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT # pokeElemOff :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT # pokeByteOff :: Ptr b -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> IO () # peek :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT -> IO VkPipelineRasterizationConservativeStateCreateFlagsEXT # poke :: Ptr VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> IO () #
Bits VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods (.&.) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # (.\|.) :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # xor :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # complement :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # shift :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # rotate :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # zeroBits :: VkPipelineRasterizationConservativeStateCreateFlagsEXT # bit :: Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # setBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # clearBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # complementBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # testBit :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> Bool # bitSizeMaybe :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Maybe Int # bitSize :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int # isSigned :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Bool # shiftL :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # unsafeShiftL :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # shiftR :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # unsafeShiftR :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # rotateL :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # rotateR :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int -> VkPipelineRasterizationConservativeStateCreateFlagsEXT # popCount :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int #
FiniteBits VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
Methods finiteBitSize :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int # countLeadingZeros :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int # countTrailingZeros :: VkPipelineRasterizationConservativeStateCreateFlagsEXT -> Int #
type Rep VkPipelineRasterizationConservativeStateCreateFlagsEXT Source #
type Rep VkPipelineRasterizationConservativeStateCreateFlagsEXT = D1 (MetaData "VkPipelineRasterizationConservativeStateCreateFlagsEXT" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineRasterizationConservativeStateCreateFlagsEXT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineRasterizationStateCreateFlags Source #

Constructors

VkPipelineRasterizationStateCreateFlags VkFlags

Instances

Bounded VkPipelineRasterizationStateCreateFlags Source #
Methods minBound :: VkPipelineRasterizationStateCreateFlags # maxBound :: VkPipelineRasterizationStateCreateFlags #
Enum VkPipelineRasterizationStateCreateFlags Source #
Methods succ :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # pred :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # toEnum :: Int -> VkPipelineRasterizationStateCreateFlags # fromEnum :: VkPipelineRasterizationStateCreateFlags -> Int # enumFrom :: VkPipelineRasterizationStateCreateFlags -> [VkPipelineRasterizationStateCreateFlags] # enumFromThen :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> [VkPipelineRasterizationStateCreateFlags] # enumFromTo :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> [VkPipelineRasterizationStateCreateFlags] # enumFromThenTo :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> [VkPipelineRasterizationStateCreateFlags] #
Eq VkPipelineRasterizationStateCreateFlags Source #
Methods (==) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # (/=) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool #
Integral VkPipelineRasterizationStateCreateFlags Source #
Methods quot :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # rem :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # div :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # mod :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # quotRem :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> (VkPipelineRasterizationStateCreateFlags, VkPipelineRasterizationStateCreateFlags) # divMod :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> (VkPipelineRasterizationStateCreateFlags, VkPipelineRasterizationStateCreateFlags) # toInteger :: VkPipelineRasterizationStateCreateFlags -> Integer #
Data VkPipelineRasterizationStateCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineRasterizationStateCreateFlags -> c VkPipelineRasterizationStateCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineRasterizationStateCreateFlags # toConstr :: VkPipelineRasterizationStateCreateFlags -> Constr # dataTypeOf :: VkPipelineRasterizationStateCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineRasterizationStateCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineRasterizationStateCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineRasterizationStateCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineRasterizationStateCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineRasterizationStateCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineRasterizationStateCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineRasterizationStateCreateFlags -> m VkPipelineRasterizationStateCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineRasterizationStateCreateFlags -> m VkPipelineRasterizationStateCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineRasterizationStateCreateFlags -> m VkPipelineRasterizationStateCreateFlags #
Num VkPipelineRasterizationStateCreateFlags Source #
Methods (+) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # (-) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # (*) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # negate :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # abs :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # signum :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # fromInteger :: Integer -> VkPipelineRasterizationStateCreateFlags #
Ord VkPipelineRasterizationStateCreateFlags Source #
Methods compare :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Ordering # (<) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # (<=) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # (>) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # (>=) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # max :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # min :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags #
Read VkPipelineRasterizationStateCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineRasterizationStateCreateFlags # readList :: ReadS [VkPipelineRasterizationStateCreateFlags] # readPrec :: ReadPrec VkPipelineRasterizationStateCreateFlags # readListPrec :: ReadPrec [VkPipelineRasterizationStateCreateFlags] #
Real VkPipelineRasterizationStateCreateFlags Source #
Methods toRational :: VkPipelineRasterizationStateCreateFlags -> Rational #
Show VkPipelineRasterizationStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineRasterizationStateCreateFlags -> ShowS # show :: VkPipelineRasterizationStateCreateFlags -> String # showList :: [VkPipelineRasterizationStateCreateFlags] -> ShowS #
Generic VkPipelineRasterizationStateCreateFlags Source #
Associated Types type Rep VkPipelineRasterizationStateCreateFlags :: * -> * # Methods from :: VkPipelineRasterizationStateCreateFlags -> Rep VkPipelineRasterizationStateCreateFlags x # to :: Rep VkPipelineRasterizationStateCreateFlags x -> VkPipelineRasterizationStateCreateFlags #
Storable VkPipelineRasterizationStateCreateFlags Source #
Methods sizeOf :: VkPipelineRasterizationStateCreateFlags -> Int # alignment :: VkPipelineRasterizationStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineRasterizationStateCreateFlags -> Int -> IO VkPipelineRasterizationStateCreateFlags # pokeElemOff :: Ptr VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineRasterizationStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineRasterizationStateCreateFlags -> IO () # peek :: Ptr VkPipelineRasterizationStateCreateFlags -> IO VkPipelineRasterizationStateCreateFlags # poke :: Ptr VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> IO () #
Bits VkPipelineRasterizationStateCreateFlags Source #
Methods (.&.) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # (.\|.) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # xor :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # complement :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # shift :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # rotate :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # zeroBits :: VkPipelineRasterizationStateCreateFlags # bit :: Int -> VkPipelineRasterizationStateCreateFlags # setBit :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # clearBit :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # complementBit :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # testBit :: VkPipelineRasterizationStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineRasterizationStateCreateFlags -> Maybe Int # bitSize :: VkPipelineRasterizationStateCreateFlags -> Int # isSigned :: VkPipelineRasterizationStateCreateFlags -> Bool # shiftL :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # unsafeShiftL :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # shiftR :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # unsafeShiftR :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # rotateL :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # rotateR :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # popCount :: VkPipelineRasterizationStateCreateFlags -> Int #
FiniteBits VkPipelineRasterizationStateCreateFlags Source #
Methods finiteBitSize :: VkPipelineRasterizationStateCreateFlags -> Int # countLeadingZeros :: VkPipelineRasterizationStateCreateFlags -> Int # countTrailingZeros :: VkPipelineRasterizationStateCreateFlags -> Int #
type Rep VkPipelineRasterizationStateCreateFlags Source #
type Rep VkPipelineRasterizationStateCreateFlags = D1 (MetaData "VkPipelineRasterizationStateCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineRasterizationStateCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineShaderStageCreateFlags Source #

Constructors

VkPipelineShaderStageCreateFlags VkFlags

Instances

Bounded VkPipelineShaderStageCreateFlags Source #
Methods minBound :: VkPipelineShaderStageCreateFlags # maxBound :: VkPipelineShaderStageCreateFlags #
Enum VkPipelineShaderStageCreateFlags Source #
Methods succ :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # pred :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # toEnum :: Int -> VkPipelineShaderStageCreateFlags # fromEnum :: VkPipelineShaderStageCreateFlags -> Int # enumFrom :: VkPipelineShaderStageCreateFlags -> [VkPipelineShaderStageCreateFlags] # enumFromThen :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> [VkPipelineShaderStageCreateFlags] # enumFromTo :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> [VkPipelineShaderStageCreateFlags] # enumFromThenTo :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> [VkPipelineShaderStageCreateFlags] #
Eq VkPipelineShaderStageCreateFlags Source #
Methods (==) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # (/=) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool #
Integral VkPipelineShaderStageCreateFlags Source #
Methods quot :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # rem :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # div :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # mod :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # quotRem :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> (VkPipelineShaderStageCreateFlags, VkPipelineShaderStageCreateFlags) # divMod :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> (VkPipelineShaderStageCreateFlags, VkPipelineShaderStageCreateFlags) # toInteger :: VkPipelineShaderStageCreateFlags -> Integer #
Data VkPipelineShaderStageCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineShaderStageCreateFlags -> c VkPipelineShaderStageCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineShaderStageCreateFlags # toConstr :: VkPipelineShaderStageCreateFlags -> Constr # dataTypeOf :: VkPipelineShaderStageCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineShaderStageCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineShaderStageCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineShaderStageCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineShaderStageCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineShaderStageCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineShaderStageCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineShaderStageCreateFlags -> m VkPipelineShaderStageCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineShaderStageCreateFlags -> m VkPipelineShaderStageCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineShaderStageCreateFlags -> m VkPipelineShaderStageCreateFlags #
Num VkPipelineShaderStageCreateFlags Source #
Methods (+) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # (-) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # (*) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # negate :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # abs :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # signum :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # fromInteger :: Integer -> VkPipelineShaderStageCreateFlags #
Ord VkPipelineShaderStageCreateFlags Source #
Methods compare :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Ordering # (<) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # (<=) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # (>) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # (>=) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # max :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # min :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags #
Read VkPipelineShaderStageCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineShaderStageCreateFlags # readList :: ReadS [VkPipelineShaderStageCreateFlags] # readPrec :: ReadPrec VkPipelineShaderStageCreateFlags # readListPrec :: ReadPrec [VkPipelineShaderStageCreateFlags] #
Real VkPipelineShaderStageCreateFlags Source #
Methods toRational :: VkPipelineShaderStageCreateFlags -> Rational #
Show VkPipelineShaderStageCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineShaderStageCreateFlags -> ShowS # show :: VkPipelineShaderStageCreateFlags -> String # showList :: [VkPipelineShaderStageCreateFlags] -> ShowS #
Generic VkPipelineShaderStageCreateFlags Source #
Associated Types type Rep VkPipelineShaderStageCreateFlags :: * -> * # Methods from :: VkPipelineShaderStageCreateFlags -> Rep VkPipelineShaderStageCreateFlags x # to :: Rep VkPipelineShaderStageCreateFlags x -> VkPipelineShaderStageCreateFlags #
Storable VkPipelineShaderStageCreateFlags Source #
Methods sizeOf :: VkPipelineShaderStageCreateFlags -> Int # alignment :: VkPipelineShaderStageCreateFlags -> Int # peekElemOff :: Ptr VkPipelineShaderStageCreateFlags -> Int -> IO VkPipelineShaderStageCreateFlags # pokeElemOff :: Ptr VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineShaderStageCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineShaderStageCreateFlags -> IO () # peek :: Ptr VkPipelineShaderStageCreateFlags -> IO VkPipelineShaderStageCreateFlags # poke :: Ptr VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> IO () #
Bits VkPipelineShaderStageCreateFlags Source #
Methods (.&.) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # (.\|.) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # xor :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # complement :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # shift :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # rotate :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # zeroBits :: VkPipelineShaderStageCreateFlags # bit :: Int -> VkPipelineShaderStageCreateFlags # setBit :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # clearBit :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # complementBit :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # testBit :: VkPipelineShaderStageCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineShaderStageCreateFlags -> Maybe Int # bitSize :: VkPipelineShaderStageCreateFlags -> Int # isSigned :: VkPipelineShaderStageCreateFlags -> Bool # shiftL :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # unsafeShiftL :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # shiftR :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # unsafeShiftR :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # rotateL :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # rotateR :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # popCount :: VkPipelineShaderStageCreateFlags -> Int #
FiniteBits VkPipelineShaderStageCreateFlags Source #
Methods finiteBitSize :: VkPipelineShaderStageCreateFlags -> Int # countLeadingZeros :: VkPipelineShaderStageCreateFlags -> Int # countTrailingZeros :: VkPipelineShaderStageCreateFlags -> Int #
type Rep VkPipelineShaderStageCreateFlags Source #
type Rep VkPipelineShaderStageCreateFlags = D1 (MetaData "VkPipelineShaderStageCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineShaderStageCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineTessellationStateCreateFlags Source #

Constructors

VkPipelineTessellationStateCreateFlags VkFlags

Instances

Bounded VkPipelineTessellationStateCreateFlags Source #
Methods minBound :: VkPipelineTessellationStateCreateFlags # maxBound :: VkPipelineTessellationStateCreateFlags #
Enum VkPipelineTessellationStateCreateFlags Source #
Methods succ :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # pred :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # toEnum :: Int -> VkPipelineTessellationStateCreateFlags # fromEnum :: VkPipelineTessellationStateCreateFlags -> Int # enumFrom :: VkPipelineTessellationStateCreateFlags -> [VkPipelineTessellationStateCreateFlags] # enumFromThen :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> [VkPipelineTessellationStateCreateFlags] # enumFromTo :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> [VkPipelineTessellationStateCreateFlags] # enumFromThenTo :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> [VkPipelineTessellationStateCreateFlags] #
Eq VkPipelineTessellationStateCreateFlags Source #
Methods (==) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # (/=) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool #
Integral VkPipelineTessellationStateCreateFlags Source #
Methods quot :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # rem :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # div :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # mod :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # quotRem :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> (VkPipelineTessellationStateCreateFlags, VkPipelineTessellationStateCreateFlags) # divMod :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> (VkPipelineTessellationStateCreateFlags, VkPipelineTessellationStateCreateFlags) # toInteger :: VkPipelineTessellationStateCreateFlags -> Integer #
Data VkPipelineTessellationStateCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineTessellationStateCreateFlags -> c VkPipelineTessellationStateCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineTessellationStateCreateFlags # toConstr :: VkPipelineTessellationStateCreateFlags -> Constr # dataTypeOf :: VkPipelineTessellationStateCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineTessellationStateCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineTessellationStateCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineTessellationStateCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineTessellationStateCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineTessellationStateCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineTessellationStateCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineTessellationStateCreateFlags -> m VkPipelineTessellationStateCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineTessellationStateCreateFlags -> m VkPipelineTessellationStateCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineTessellationStateCreateFlags -> m VkPipelineTessellationStateCreateFlags #
Num VkPipelineTessellationStateCreateFlags Source #
Methods (+) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # (-) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # (*) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # negate :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # abs :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # signum :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # fromInteger :: Integer -> VkPipelineTessellationStateCreateFlags #
Ord VkPipelineTessellationStateCreateFlags Source #
Methods compare :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Ordering # (<) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # (<=) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # (>) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # (>=) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # max :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # min :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags #
Read VkPipelineTessellationStateCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineTessellationStateCreateFlags # readList :: ReadS [VkPipelineTessellationStateCreateFlags] # readPrec :: ReadPrec VkPipelineTessellationStateCreateFlags # readListPrec :: ReadPrec [VkPipelineTessellationStateCreateFlags] #
Real VkPipelineTessellationStateCreateFlags Source #
Methods toRational :: VkPipelineTessellationStateCreateFlags -> Rational #
Show VkPipelineTessellationStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineTessellationStateCreateFlags -> ShowS # show :: VkPipelineTessellationStateCreateFlags -> String # showList :: [VkPipelineTessellationStateCreateFlags] -> ShowS #
Generic VkPipelineTessellationStateCreateFlags Source #
Associated Types type Rep VkPipelineTessellationStateCreateFlags :: * -> * # Methods from :: VkPipelineTessellationStateCreateFlags -> Rep VkPipelineTessellationStateCreateFlags x # to :: Rep VkPipelineTessellationStateCreateFlags x -> VkPipelineTessellationStateCreateFlags #
Storable VkPipelineTessellationStateCreateFlags Source #
Methods sizeOf :: VkPipelineTessellationStateCreateFlags -> Int # alignment :: VkPipelineTessellationStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineTessellationStateCreateFlags -> Int -> IO VkPipelineTessellationStateCreateFlags # pokeElemOff :: Ptr VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineTessellationStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineTessellationStateCreateFlags -> IO () # peek :: Ptr VkPipelineTessellationStateCreateFlags -> IO VkPipelineTessellationStateCreateFlags # poke :: Ptr VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> IO () #
Bits VkPipelineTessellationStateCreateFlags Source #
Methods (.&.) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # (.\|.) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # xor :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # complement :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # shift :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # rotate :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # zeroBits :: VkPipelineTessellationStateCreateFlags # bit :: Int -> VkPipelineTessellationStateCreateFlags # setBit :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # clearBit :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # complementBit :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # testBit :: VkPipelineTessellationStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineTessellationStateCreateFlags -> Maybe Int # bitSize :: VkPipelineTessellationStateCreateFlags -> Int # isSigned :: VkPipelineTessellationStateCreateFlags -> Bool # shiftL :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # unsafeShiftL :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # shiftR :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # unsafeShiftR :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # rotateL :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # rotateR :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # popCount :: VkPipelineTessellationStateCreateFlags -> Int #
FiniteBits VkPipelineTessellationStateCreateFlags Source #
Methods finiteBitSize :: VkPipelineTessellationStateCreateFlags -> Int # countLeadingZeros :: VkPipelineTessellationStateCreateFlags -> Int # countTrailingZeros :: VkPipelineTessellationStateCreateFlags -> Int #
type Rep VkPipelineTessellationStateCreateFlags Source #
type Rep VkPipelineTessellationStateCreateFlags = D1 (MetaData "VkPipelineTessellationStateCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineTessellationStateCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineVertexInputStateCreateFlags Source #

Constructors

VkPipelineVertexInputStateCreateFlags VkFlags

Instances

Bounded VkPipelineVertexInputStateCreateFlags Source #
Methods minBound :: VkPipelineVertexInputStateCreateFlags # maxBound :: VkPipelineVertexInputStateCreateFlags #
Enum VkPipelineVertexInputStateCreateFlags Source #
Methods succ :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # pred :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # toEnum :: Int -> VkPipelineVertexInputStateCreateFlags # fromEnum :: VkPipelineVertexInputStateCreateFlags -> Int # enumFrom :: VkPipelineVertexInputStateCreateFlags -> [VkPipelineVertexInputStateCreateFlags] # enumFromThen :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> [VkPipelineVertexInputStateCreateFlags] # enumFromTo :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> [VkPipelineVertexInputStateCreateFlags] # enumFromThenTo :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> [VkPipelineVertexInputStateCreateFlags] #
Eq VkPipelineVertexInputStateCreateFlags Source #
Methods (==) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # (/=) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool #
Integral VkPipelineVertexInputStateCreateFlags Source #
Methods quot :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # rem :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # div :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # mod :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # quotRem :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> (VkPipelineVertexInputStateCreateFlags, VkPipelineVertexInputStateCreateFlags) # divMod :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> (VkPipelineVertexInputStateCreateFlags, VkPipelineVertexInputStateCreateFlags) # toInteger :: VkPipelineVertexInputStateCreateFlags -> Integer #
Data VkPipelineVertexInputStateCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineVertexInputStateCreateFlags -> c VkPipelineVertexInputStateCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineVertexInputStateCreateFlags # toConstr :: VkPipelineVertexInputStateCreateFlags -> Constr # dataTypeOf :: VkPipelineVertexInputStateCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineVertexInputStateCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineVertexInputStateCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineVertexInputStateCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineVertexInputStateCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineVertexInputStateCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineVertexInputStateCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineVertexInputStateCreateFlags -> m VkPipelineVertexInputStateCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineVertexInputStateCreateFlags -> m VkPipelineVertexInputStateCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineVertexInputStateCreateFlags -> m VkPipelineVertexInputStateCreateFlags #
Num VkPipelineVertexInputStateCreateFlags Source #
Methods (+) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # (-) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # (*) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # negate :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # abs :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # signum :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # fromInteger :: Integer -> VkPipelineVertexInputStateCreateFlags #
Ord VkPipelineVertexInputStateCreateFlags Source #
Methods compare :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Ordering # (<) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # (<=) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # (>) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # (>=) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # max :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # min :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags #
Read VkPipelineVertexInputStateCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineVertexInputStateCreateFlags # readList :: ReadS [VkPipelineVertexInputStateCreateFlags] # readPrec :: ReadPrec VkPipelineVertexInputStateCreateFlags # readListPrec :: ReadPrec [VkPipelineVertexInputStateCreateFlags] #
Real VkPipelineVertexInputStateCreateFlags Source #
Methods toRational :: VkPipelineVertexInputStateCreateFlags -> Rational #
Show VkPipelineVertexInputStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineVertexInputStateCreateFlags -> ShowS # show :: VkPipelineVertexInputStateCreateFlags -> String # showList :: [VkPipelineVertexInputStateCreateFlags] -> ShowS #
Generic VkPipelineVertexInputStateCreateFlags Source #
Associated Types type Rep VkPipelineVertexInputStateCreateFlags :: * -> * # Methods from :: VkPipelineVertexInputStateCreateFlags -> Rep VkPipelineVertexInputStateCreateFlags x # to :: Rep VkPipelineVertexInputStateCreateFlags x -> VkPipelineVertexInputStateCreateFlags #
Storable VkPipelineVertexInputStateCreateFlags Source #
Methods sizeOf :: VkPipelineVertexInputStateCreateFlags -> Int # alignment :: VkPipelineVertexInputStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineVertexInputStateCreateFlags -> Int -> IO VkPipelineVertexInputStateCreateFlags # pokeElemOff :: Ptr VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineVertexInputStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineVertexInputStateCreateFlags -> IO () # peek :: Ptr VkPipelineVertexInputStateCreateFlags -> IO VkPipelineVertexInputStateCreateFlags # poke :: Ptr VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> IO () #
Bits VkPipelineVertexInputStateCreateFlags Source #
Methods (.&.) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # (.\|.) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # xor :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # complement :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # shift :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # rotate :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # zeroBits :: VkPipelineVertexInputStateCreateFlags # bit :: Int -> VkPipelineVertexInputStateCreateFlags # setBit :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # clearBit :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # complementBit :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # testBit :: VkPipelineVertexInputStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineVertexInputStateCreateFlags -> Maybe Int # bitSize :: VkPipelineVertexInputStateCreateFlags -> Int # isSigned :: VkPipelineVertexInputStateCreateFlags -> Bool # shiftL :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # unsafeShiftL :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # shiftR :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # unsafeShiftR :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # rotateL :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # rotateR :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # popCount :: VkPipelineVertexInputStateCreateFlags -> Int #
FiniteBits VkPipelineVertexInputStateCreateFlags Source #
Methods finiteBitSize :: VkPipelineVertexInputStateCreateFlags -> Int # countLeadingZeros :: VkPipelineVertexInputStateCreateFlags -> Int # countTrailingZeros :: VkPipelineVertexInputStateCreateFlags -> Int #
type Rep VkPipelineVertexInputStateCreateFlags Source #
type Rep VkPipelineVertexInputStateCreateFlags = D1 (MetaData "VkPipelineVertexInputStateCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineVertexInputStateCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineViewportStateCreateFlags Source #

Constructors

VkPipelineViewportStateCreateFlags VkFlags

Instances

Bounded VkPipelineViewportStateCreateFlags Source #
Methods minBound :: VkPipelineViewportStateCreateFlags # maxBound :: VkPipelineViewportStateCreateFlags #
Enum VkPipelineViewportStateCreateFlags Source #
Methods succ :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # pred :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # toEnum :: Int -> VkPipelineViewportStateCreateFlags # fromEnum :: VkPipelineViewportStateCreateFlags -> Int # enumFrom :: VkPipelineViewportStateCreateFlags -> [VkPipelineViewportStateCreateFlags] # enumFromThen :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> [VkPipelineViewportStateCreateFlags] # enumFromTo :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> [VkPipelineViewportStateCreateFlags] # enumFromThenTo :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> [VkPipelineViewportStateCreateFlags] #
Eq VkPipelineViewportStateCreateFlags Source #
Methods (==) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # (/=) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool #
Integral VkPipelineViewportStateCreateFlags Source #
Methods quot :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # rem :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # div :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # mod :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # quotRem :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> (VkPipelineViewportStateCreateFlags, VkPipelineViewportStateCreateFlags) # divMod :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> (VkPipelineViewportStateCreateFlags, VkPipelineViewportStateCreateFlags) # toInteger :: VkPipelineViewportStateCreateFlags -> Integer #
Data VkPipelineViewportStateCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineViewportStateCreateFlags -> c VkPipelineViewportStateCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineViewportStateCreateFlags # toConstr :: VkPipelineViewportStateCreateFlags -> Constr # dataTypeOf :: VkPipelineViewportStateCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineViewportStateCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineViewportStateCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineViewportStateCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineViewportStateCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineViewportStateCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineViewportStateCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineViewportStateCreateFlags -> m VkPipelineViewportStateCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineViewportStateCreateFlags -> m VkPipelineViewportStateCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineViewportStateCreateFlags -> m VkPipelineViewportStateCreateFlags #
Num VkPipelineViewportStateCreateFlags Source #
Methods (+) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # (-) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # (*) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # negate :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # abs :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # signum :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # fromInteger :: Integer -> VkPipelineViewportStateCreateFlags #
Ord VkPipelineViewportStateCreateFlags Source #
Methods compare :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Ordering # (<) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # (<=) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # (>) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # (>=) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # max :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # min :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags #
Read VkPipelineViewportStateCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkPipelineViewportStateCreateFlags # readList :: ReadS [VkPipelineViewportStateCreateFlags] # readPrec :: ReadPrec VkPipelineViewportStateCreateFlags # readListPrec :: ReadPrec [VkPipelineViewportStateCreateFlags] #
Real VkPipelineViewportStateCreateFlags Source #
Methods toRational :: VkPipelineViewportStateCreateFlags -> Rational #
Show VkPipelineViewportStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineViewportStateCreateFlags -> ShowS # show :: VkPipelineViewportStateCreateFlags -> String # showList :: [VkPipelineViewportStateCreateFlags] -> ShowS #
Generic VkPipelineViewportStateCreateFlags Source #
Associated Types type Rep VkPipelineViewportStateCreateFlags :: * -> * # Methods from :: VkPipelineViewportStateCreateFlags -> Rep VkPipelineViewportStateCreateFlags x # to :: Rep VkPipelineViewportStateCreateFlags x -> VkPipelineViewportStateCreateFlags #
Storable VkPipelineViewportStateCreateFlags Source #
Methods sizeOf :: VkPipelineViewportStateCreateFlags -> Int # alignment :: VkPipelineViewportStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineViewportStateCreateFlags -> Int -> IO VkPipelineViewportStateCreateFlags # pokeElemOff :: Ptr VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineViewportStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineViewportStateCreateFlags -> IO () # peek :: Ptr VkPipelineViewportStateCreateFlags -> IO VkPipelineViewportStateCreateFlags # poke :: Ptr VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> IO () #
Bits VkPipelineViewportStateCreateFlags Source #
Methods (.&.) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # (.\|.) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # xor :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # complement :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # shift :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # rotate :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # zeroBits :: VkPipelineViewportStateCreateFlags # bit :: Int -> VkPipelineViewportStateCreateFlags # setBit :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # clearBit :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # complementBit :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # testBit :: VkPipelineViewportStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineViewportStateCreateFlags -> Maybe Int # bitSize :: VkPipelineViewportStateCreateFlags -> Int # isSigned :: VkPipelineViewportStateCreateFlags -> Bool # shiftL :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # unsafeShiftL :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # shiftR :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # unsafeShiftR :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # rotateL :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # rotateR :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # popCount :: VkPipelineViewportStateCreateFlags -> Int #
FiniteBits VkPipelineViewportStateCreateFlags Source #
Methods finiteBitSize :: VkPipelineViewportStateCreateFlags -> Int # countLeadingZeros :: VkPipelineViewportStateCreateFlags -> Int # countTrailingZeros :: VkPipelineViewportStateCreateFlags -> Int #
type Rep VkPipelineViewportStateCreateFlags Source #
type Rep VkPipelineViewportStateCreateFlags = D1 (MetaData "VkPipelineViewportStateCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineViewportStateCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkPipelineViewportSwizzleStateCreateFlagsNV Source #

Constructors

VkPipelineViewportSwizzleStateCreateFlagsNV VkFlags

Instances

Bounded VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods minBound :: VkPipelineViewportSwizzleStateCreateFlagsNV # maxBound :: VkPipelineViewportSwizzleStateCreateFlagsNV #
Enum VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods succ :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # pred :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # toEnum :: Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # fromEnum :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int # enumFrom :: VkPipelineViewportSwizzleStateCreateFlagsNV -> [VkPipelineViewportSwizzleStateCreateFlagsNV] # enumFromThen :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> [VkPipelineViewportSwizzleStateCreateFlagsNV] # enumFromTo :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> [VkPipelineViewportSwizzleStateCreateFlagsNV] # enumFromThenTo :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> [VkPipelineViewportSwizzleStateCreateFlagsNV] #
Eq VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods (==) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool # (/=) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool #
Integral VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods quot :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # rem :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # div :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # mod :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # quotRem :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> (VkPipelineViewportSwizzleStateCreateFlagsNV, VkPipelineViewportSwizzleStateCreateFlagsNV) # divMod :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> (VkPipelineViewportSwizzleStateCreateFlagsNV, VkPipelineViewportSwizzleStateCreateFlagsNV) # toInteger :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Integer #
Data VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkPipelineViewportSwizzleStateCreateFlagsNV -> c VkPipelineViewportSwizzleStateCreateFlagsNV # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkPipelineViewportSwizzleStateCreateFlagsNV # toConstr :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Constr # dataTypeOf :: VkPipelineViewportSwizzleStateCreateFlagsNV -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkPipelineViewportSwizzleStateCreateFlagsNV) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkPipelineViewportSwizzleStateCreateFlagsNV) # gmapT :: (forall b. Data b => b -> b) -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineViewportSwizzleStateCreateFlagsNV -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkPipelineViewportSwizzleStateCreateFlagsNV -> r # gmapQ :: (forall d. Data d => d -> u) -> VkPipelineViewportSwizzleStateCreateFlagsNV -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkPipelineViewportSwizzleStateCreateFlagsNV -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkPipelineViewportSwizzleStateCreateFlagsNV -> m VkPipelineViewportSwizzleStateCreateFlagsNV # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineViewportSwizzleStateCreateFlagsNV -> m VkPipelineViewportSwizzleStateCreateFlagsNV # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkPipelineViewportSwizzleStateCreateFlagsNV -> m VkPipelineViewportSwizzleStateCreateFlagsNV #
Num VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods (+) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # (-) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # (*) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # negate :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # abs :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # signum :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # fromInteger :: Integer -> VkPipelineViewportSwizzleStateCreateFlagsNV #
Ord VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods compare :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Ordering # (<) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool # (<=) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool # (>) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool # (>=) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool # max :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # min :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV #
Read VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods readsPrec :: Int -> ReadS VkPipelineViewportSwizzleStateCreateFlagsNV # readList :: ReadS [VkPipelineViewportSwizzleStateCreateFlagsNV] # readPrec :: ReadPrec VkPipelineViewportSwizzleStateCreateFlagsNV # readListPrec :: ReadPrec [VkPipelineViewportSwizzleStateCreateFlagsNV] #
Real VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods toRational :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Rational #
Show VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods showsPrec :: Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> ShowS # show :: VkPipelineViewportSwizzleStateCreateFlagsNV -> String # showList :: [VkPipelineViewportSwizzleStateCreateFlagsNV] -> ShowS #
Generic VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Associated Types type Rep VkPipelineViewportSwizzleStateCreateFlagsNV :: * -> * # Methods from :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Rep VkPipelineViewportSwizzleStateCreateFlagsNV x # to :: Rep VkPipelineViewportSwizzleStateCreateFlagsNV x -> VkPipelineViewportSwizzleStateCreateFlagsNV #
Storable VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods sizeOf :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int # alignment :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int # peekElemOff :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> IO VkPipelineViewportSwizzleStateCreateFlagsNV # pokeElemOff :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineViewportSwizzleStateCreateFlagsNV # pokeByteOff :: Ptr b -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO () # peek :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV -> IO VkPipelineViewportSwizzleStateCreateFlagsNV # poke :: Ptr VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> IO () #
Bits VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods (.&.) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # (.\|.) :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # xor :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # complement :: VkPipelineViewportSwizzleStateCreateFlagsNV -> VkPipelineViewportSwizzleStateCreateFlagsNV # shift :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # rotate :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # zeroBits :: VkPipelineViewportSwizzleStateCreateFlagsNV # bit :: Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # setBit :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # clearBit :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # complementBit :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # testBit :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> Bool # bitSizeMaybe :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Maybe Int # bitSize :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int # isSigned :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Bool # shiftL :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # unsafeShiftL :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # shiftR :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # unsafeShiftR :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # rotateL :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # rotateR :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int -> VkPipelineViewportSwizzleStateCreateFlagsNV # popCount :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int #
FiniteBits VkPipelineViewportSwizzleStateCreateFlagsNV Source #
Methods finiteBitSize :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int # countLeadingZeros :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int # countTrailingZeros :: VkPipelineViewportSwizzleStateCreateFlagsNV -> Int #
type Rep VkPipelineViewportSwizzleStateCreateFlagsNV Source #
type Rep VkPipelineViewportSwizzleStateCreateFlagsNV = D1 (MetaData "VkPipelineViewportSwizzleStateCreateFlagsNV" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkPipelineViewportSwizzleStateCreateFlagsNV" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkQueryPoolCreateFlags Source #

Constructors

VkQueryPoolCreateFlags VkFlags

Instances

Bounded VkQueryPoolCreateFlags Source #
Methods minBound :: VkQueryPoolCreateFlags # maxBound :: VkQueryPoolCreateFlags #
Enum VkQueryPoolCreateFlags Source #
Methods succ :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # pred :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # toEnum :: Int -> VkQueryPoolCreateFlags # fromEnum :: VkQueryPoolCreateFlags -> Int # enumFrom :: VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags] # enumFromThen :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags] # enumFromTo :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags] # enumFromThenTo :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> [VkQueryPoolCreateFlags] #
Eq VkQueryPoolCreateFlags Source #
Methods (==) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool # (/=) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool #
Integral VkQueryPoolCreateFlags Source #
Methods quot :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # rem :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # div :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # mod :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # quotRem :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> (VkQueryPoolCreateFlags, VkQueryPoolCreateFlags) # divMod :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> (VkQueryPoolCreateFlags, VkQueryPoolCreateFlags) # toInteger :: VkQueryPoolCreateFlags -> Integer #
Data VkQueryPoolCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkQueryPoolCreateFlags -> c VkQueryPoolCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkQueryPoolCreateFlags # toConstr :: VkQueryPoolCreateFlags -> Constr # dataTypeOf :: VkQueryPoolCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkQueryPoolCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkQueryPoolCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkQueryPoolCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkQueryPoolCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkQueryPoolCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkQueryPoolCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkQueryPoolCreateFlags -> m VkQueryPoolCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkQueryPoolCreateFlags -> m VkQueryPoolCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkQueryPoolCreateFlags -> m VkQueryPoolCreateFlags #
Num VkQueryPoolCreateFlags Source #
Methods (+) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # (-) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # (*) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # negate :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # abs :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # signum :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # fromInteger :: Integer -> VkQueryPoolCreateFlags #
Ord VkQueryPoolCreateFlags Source #
Methods compare :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Ordering # (<) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool # (<=) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool # (>) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool # (>=) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> Bool # max :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # min :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags #
Read VkQueryPoolCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkQueryPoolCreateFlags # readList :: ReadS [VkQueryPoolCreateFlags] # readPrec :: ReadPrec VkQueryPoolCreateFlags # readListPrec :: ReadPrec [VkQueryPoolCreateFlags] #
Real VkQueryPoolCreateFlags Source #
Methods toRational :: VkQueryPoolCreateFlags -> Rational #
Show VkQueryPoolCreateFlags Source #
Methods showsPrec :: Int -> VkQueryPoolCreateFlags -> ShowS # show :: VkQueryPoolCreateFlags -> String # showList :: [VkQueryPoolCreateFlags] -> ShowS #
Generic VkQueryPoolCreateFlags Source #
Associated Types type Rep VkQueryPoolCreateFlags :: * -> * # Methods from :: VkQueryPoolCreateFlags -> Rep VkQueryPoolCreateFlags x # to :: Rep VkQueryPoolCreateFlags x -> VkQueryPoolCreateFlags #
Storable VkQueryPoolCreateFlags Source #
Methods sizeOf :: VkQueryPoolCreateFlags -> Int # alignment :: VkQueryPoolCreateFlags -> Int # peekElemOff :: Ptr VkQueryPoolCreateFlags -> Int -> IO VkQueryPoolCreateFlags # pokeElemOff :: Ptr VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkQueryPoolCreateFlags # pokeByteOff :: Ptr b -> Int -> VkQueryPoolCreateFlags -> IO () # peek :: Ptr VkQueryPoolCreateFlags -> IO VkQueryPoolCreateFlags # poke :: Ptr VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> IO () #
Bits VkQueryPoolCreateFlags Source #
Methods (.&.) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # (.\|.) :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # xor :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # complement :: VkQueryPoolCreateFlags -> VkQueryPoolCreateFlags # shift :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # rotate :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # zeroBits :: VkQueryPoolCreateFlags # bit :: Int -> VkQueryPoolCreateFlags # setBit :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # clearBit :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # complementBit :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # testBit :: VkQueryPoolCreateFlags -> Int -> Bool # bitSizeMaybe :: VkQueryPoolCreateFlags -> Maybe Int # bitSize :: VkQueryPoolCreateFlags -> Int # isSigned :: VkQueryPoolCreateFlags -> Bool # shiftL :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # unsafeShiftL :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # shiftR :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # unsafeShiftR :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # rotateL :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # rotateR :: VkQueryPoolCreateFlags -> Int -> VkQueryPoolCreateFlags # popCount :: VkQueryPoolCreateFlags -> Int #
FiniteBits VkQueryPoolCreateFlags Source #
Methods finiteBitSize :: VkQueryPoolCreateFlags -> Int # countLeadingZeros :: VkQueryPoolCreateFlags -> Int # countTrailingZeros :: VkQueryPoolCreateFlags -> Int #
type Rep VkQueryPoolCreateFlags Source #
type Rep VkQueryPoolCreateFlags = D1 (MetaData "VkQueryPoolCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkQueryPoolCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkRenderPassCreateFlags Source #

Constructors

VkRenderPassCreateFlags VkFlags

Instances

Bounded VkRenderPassCreateFlags Source #
Methods minBound :: VkRenderPassCreateFlags # maxBound :: VkRenderPassCreateFlags #
Enum VkRenderPassCreateFlags Source #
Methods succ :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags # pred :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags # toEnum :: Int -> VkRenderPassCreateFlags # fromEnum :: VkRenderPassCreateFlags -> Int # enumFrom :: VkRenderPassCreateFlags -> [VkRenderPassCreateFlags] # enumFromThen :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> [VkRenderPassCreateFlags] # enumFromTo :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> [VkRenderPassCreateFlags] # enumFromThenTo :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> [VkRenderPassCreateFlags] #
Eq VkRenderPassCreateFlags Source #
Methods (==) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool # (/=) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool #
Integral VkRenderPassCreateFlags Source #
Methods quot :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # rem :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # div :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # mod :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # quotRem :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> (VkRenderPassCreateFlags, VkRenderPassCreateFlags) # divMod :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> (VkRenderPassCreateFlags, VkRenderPassCreateFlags) # toInteger :: VkRenderPassCreateFlags -> Integer #
Data VkRenderPassCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkRenderPassCreateFlags -> c VkRenderPassCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkRenderPassCreateFlags # toConstr :: VkRenderPassCreateFlags -> Constr # dataTypeOf :: VkRenderPassCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkRenderPassCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkRenderPassCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkRenderPassCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkRenderPassCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkRenderPassCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkRenderPassCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkRenderPassCreateFlags -> m VkRenderPassCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkRenderPassCreateFlags -> m VkRenderPassCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkRenderPassCreateFlags -> m VkRenderPassCreateFlags #
Num VkRenderPassCreateFlags Source #
Methods (+) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # (-) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # (*) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # negate :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags # abs :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags # signum :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags # fromInteger :: Integer -> VkRenderPassCreateFlags #
Ord VkRenderPassCreateFlags Source #
Methods compare :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Ordering # (<) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool # (<=) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool # (>) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool # (>=) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> Bool # max :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # min :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags #
Read VkRenderPassCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkRenderPassCreateFlags # readList :: ReadS [VkRenderPassCreateFlags] # readPrec :: ReadPrec VkRenderPassCreateFlags # readListPrec :: ReadPrec [VkRenderPassCreateFlags] #
Real VkRenderPassCreateFlags Source #
Methods toRational :: VkRenderPassCreateFlags -> Rational #
Show VkRenderPassCreateFlags Source #
Methods showsPrec :: Int -> VkRenderPassCreateFlags -> ShowS # show :: VkRenderPassCreateFlags -> String # showList :: [VkRenderPassCreateFlags] -> ShowS #
Generic VkRenderPassCreateFlags Source #
Associated Types type Rep VkRenderPassCreateFlags :: * -> * # Methods from :: VkRenderPassCreateFlags -> Rep VkRenderPassCreateFlags x # to :: Rep VkRenderPassCreateFlags x -> VkRenderPassCreateFlags #
Storable VkRenderPassCreateFlags Source #
Methods sizeOf :: VkRenderPassCreateFlags -> Int # alignment :: VkRenderPassCreateFlags -> Int # peekElemOff :: Ptr VkRenderPassCreateFlags -> Int -> IO VkRenderPassCreateFlags # pokeElemOff :: Ptr VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkRenderPassCreateFlags # pokeByteOff :: Ptr b -> Int -> VkRenderPassCreateFlags -> IO () # peek :: Ptr VkRenderPassCreateFlags -> IO VkRenderPassCreateFlags # poke :: Ptr VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> IO () #
Bits VkRenderPassCreateFlags Source #
Methods (.&.) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # (.\|.) :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # xor :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags -> VkRenderPassCreateFlags # complement :: VkRenderPassCreateFlags -> VkRenderPassCreateFlags # shift :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # rotate :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # zeroBits :: VkRenderPassCreateFlags # bit :: Int -> VkRenderPassCreateFlags # setBit :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # clearBit :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # complementBit :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # testBit :: VkRenderPassCreateFlags -> Int -> Bool # bitSizeMaybe :: VkRenderPassCreateFlags -> Maybe Int # bitSize :: VkRenderPassCreateFlags -> Int # isSigned :: VkRenderPassCreateFlags -> Bool # shiftL :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # unsafeShiftL :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # shiftR :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # unsafeShiftR :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # rotateL :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # rotateR :: VkRenderPassCreateFlags -> Int -> VkRenderPassCreateFlags # popCount :: VkRenderPassCreateFlags -> Int #
FiniteBits VkRenderPassCreateFlags Source #
Methods finiteBitSize :: VkRenderPassCreateFlags -> Int # countLeadingZeros :: VkRenderPassCreateFlags -> Int # countTrailingZeros :: VkRenderPassCreateFlags -> Int #
type Rep VkRenderPassCreateFlags Source #
type Rep VkRenderPassCreateFlags = D1 (MetaData "VkRenderPassCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkRenderPassCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkSamplerCreateFlags Source #

Constructors

VkSamplerCreateFlags VkFlags

Instances

Bounded VkSamplerCreateFlags Source #
Methods minBound :: VkSamplerCreateFlags # maxBound :: VkSamplerCreateFlags #
Enum VkSamplerCreateFlags Source #
Methods succ :: VkSamplerCreateFlags -> VkSamplerCreateFlags # pred :: VkSamplerCreateFlags -> VkSamplerCreateFlags # toEnum :: Int -> VkSamplerCreateFlags # fromEnum :: VkSamplerCreateFlags -> Int # enumFrom :: VkSamplerCreateFlags -> [VkSamplerCreateFlags] # enumFromThen :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> [VkSamplerCreateFlags] # enumFromTo :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> [VkSamplerCreateFlags] # enumFromThenTo :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags -> [VkSamplerCreateFlags] #
Eq VkSamplerCreateFlags Source #
Methods (==) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> Bool # (/=) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> Bool #
Integral VkSamplerCreateFlags Source #
Methods quot :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # rem :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # div :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # mod :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # quotRem :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> (VkSamplerCreateFlags, VkSamplerCreateFlags) # divMod :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> (VkSamplerCreateFlags, VkSamplerCreateFlags) # toInteger :: VkSamplerCreateFlags -> Integer #
Data VkSamplerCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkSamplerCreateFlags -> c VkSamplerCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkSamplerCreateFlags # toConstr :: VkSamplerCreateFlags -> Constr # dataTypeOf :: VkSamplerCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkSamplerCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkSamplerCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkSamplerCreateFlags -> VkSamplerCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkSamplerCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkSamplerCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkSamplerCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkSamplerCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkSamplerCreateFlags -> m VkSamplerCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkSamplerCreateFlags -> m VkSamplerCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkSamplerCreateFlags -> m VkSamplerCreateFlags #
Num VkSamplerCreateFlags Source #
Methods (+) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # (-) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # (*) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # negate :: VkSamplerCreateFlags -> VkSamplerCreateFlags # abs :: VkSamplerCreateFlags -> VkSamplerCreateFlags # signum :: VkSamplerCreateFlags -> VkSamplerCreateFlags # fromInteger :: Integer -> VkSamplerCreateFlags #
Ord VkSamplerCreateFlags Source #
Methods compare :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> Ordering # (<) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> Bool # (<=) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> Bool # (>) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> Bool # (>=) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> Bool # max :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # min :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags #
Read VkSamplerCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkSamplerCreateFlags # readList :: ReadS [VkSamplerCreateFlags] # readPrec :: ReadPrec VkSamplerCreateFlags # readListPrec :: ReadPrec [VkSamplerCreateFlags] #
Real VkSamplerCreateFlags Source #
Methods toRational :: VkSamplerCreateFlags -> Rational #
Show VkSamplerCreateFlags Source #
Methods showsPrec :: Int -> VkSamplerCreateFlags -> ShowS # show :: VkSamplerCreateFlags -> String # showList :: [VkSamplerCreateFlags] -> ShowS #
Generic VkSamplerCreateFlags Source #
Associated Types type Rep VkSamplerCreateFlags :: * -> * # Methods from :: VkSamplerCreateFlags -> Rep VkSamplerCreateFlags x # to :: Rep VkSamplerCreateFlags x -> VkSamplerCreateFlags #
Storable VkSamplerCreateFlags Source #
Methods sizeOf :: VkSamplerCreateFlags -> Int # alignment :: VkSamplerCreateFlags -> Int # peekElemOff :: Ptr VkSamplerCreateFlags -> Int -> IO VkSamplerCreateFlags # pokeElemOff :: Ptr VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSamplerCreateFlags # pokeByteOff :: Ptr b -> Int -> VkSamplerCreateFlags -> IO () # peek :: Ptr VkSamplerCreateFlags -> IO VkSamplerCreateFlags # poke :: Ptr VkSamplerCreateFlags -> VkSamplerCreateFlags -> IO () #
Bits VkSamplerCreateFlags Source #
Methods (.&.) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # (.\|.) :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # xor :: VkSamplerCreateFlags -> VkSamplerCreateFlags -> VkSamplerCreateFlags # complement :: VkSamplerCreateFlags -> VkSamplerCreateFlags # shift :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # rotate :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # zeroBits :: VkSamplerCreateFlags # bit :: Int -> VkSamplerCreateFlags # setBit :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # clearBit :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # complementBit :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # testBit :: VkSamplerCreateFlags -> Int -> Bool # bitSizeMaybe :: VkSamplerCreateFlags -> Maybe Int # bitSize :: VkSamplerCreateFlags -> Int # isSigned :: VkSamplerCreateFlags -> Bool # shiftL :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # unsafeShiftL :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # shiftR :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # unsafeShiftR :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # rotateL :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # rotateR :: VkSamplerCreateFlags -> Int -> VkSamplerCreateFlags # popCount :: VkSamplerCreateFlags -> Int #
FiniteBits VkSamplerCreateFlags Source #
Methods finiteBitSize :: VkSamplerCreateFlags -> Int # countLeadingZeros :: VkSamplerCreateFlags -> Int # countTrailingZeros :: VkSamplerCreateFlags -> Int #
type Rep VkSamplerCreateFlags Source #
type Rep VkSamplerCreateFlags = D1 (MetaData "VkSamplerCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkSamplerCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkSemaphoreCreateFlags Source #

Constructors

VkSemaphoreCreateFlags VkFlags

Instances

Bounded VkSemaphoreCreateFlags Source #
Methods minBound :: VkSemaphoreCreateFlags # maxBound :: VkSemaphoreCreateFlags #
Enum VkSemaphoreCreateFlags Source #
Methods succ :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # pred :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # toEnum :: Int -> VkSemaphoreCreateFlags # fromEnum :: VkSemaphoreCreateFlags -> Int # enumFrom :: VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags] # enumFromThen :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags] # enumFromTo :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags] # enumFromThenTo :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> [VkSemaphoreCreateFlags] #
Eq VkSemaphoreCreateFlags Source #
Methods (==) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool # (/=) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool #
Integral VkSemaphoreCreateFlags Source #
Methods quot :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # rem :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # div :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # mod :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # quotRem :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> (VkSemaphoreCreateFlags, VkSemaphoreCreateFlags) # divMod :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> (VkSemaphoreCreateFlags, VkSemaphoreCreateFlags) # toInteger :: VkSemaphoreCreateFlags -> Integer #
Data VkSemaphoreCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkSemaphoreCreateFlags -> c VkSemaphoreCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkSemaphoreCreateFlags # toConstr :: VkSemaphoreCreateFlags -> Constr # dataTypeOf :: VkSemaphoreCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkSemaphoreCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkSemaphoreCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkSemaphoreCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkSemaphoreCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkSemaphoreCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkSemaphoreCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkSemaphoreCreateFlags -> m VkSemaphoreCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkSemaphoreCreateFlags -> m VkSemaphoreCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkSemaphoreCreateFlags -> m VkSemaphoreCreateFlags #
Num VkSemaphoreCreateFlags Source #
Methods (+) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # (-) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # (*) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # negate :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # abs :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # signum :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # fromInteger :: Integer -> VkSemaphoreCreateFlags #
Ord VkSemaphoreCreateFlags Source #
Methods compare :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Ordering # (<) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool # (<=) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool # (>) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool # (>=) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> Bool # max :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # min :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags #
Read VkSemaphoreCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkSemaphoreCreateFlags # readList :: ReadS [VkSemaphoreCreateFlags] # readPrec :: ReadPrec VkSemaphoreCreateFlags # readListPrec :: ReadPrec [VkSemaphoreCreateFlags] #
Real VkSemaphoreCreateFlags Source #
Methods toRational :: VkSemaphoreCreateFlags -> Rational #
Show VkSemaphoreCreateFlags Source #
Methods showsPrec :: Int -> VkSemaphoreCreateFlags -> ShowS # show :: VkSemaphoreCreateFlags -> String # showList :: [VkSemaphoreCreateFlags] -> ShowS #
Generic VkSemaphoreCreateFlags Source #
Associated Types type Rep VkSemaphoreCreateFlags :: * -> * # Methods from :: VkSemaphoreCreateFlags -> Rep VkSemaphoreCreateFlags x # to :: Rep VkSemaphoreCreateFlags x -> VkSemaphoreCreateFlags #
Storable VkSemaphoreCreateFlags Source #
Methods sizeOf :: VkSemaphoreCreateFlags -> Int # alignment :: VkSemaphoreCreateFlags -> Int # peekElemOff :: Ptr VkSemaphoreCreateFlags -> Int -> IO VkSemaphoreCreateFlags # pokeElemOff :: Ptr VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSemaphoreCreateFlags # pokeByteOff :: Ptr b -> Int -> VkSemaphoreCreateFlags -> IO () # peek :: Ptr VkSemaphoreCreateFlags -> IO VkSemaphoreCreateFlags # poke :: Ptr VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> IO () #
Bits VkSemaphoreCreateFlags Source #
Methods (.&.) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # (.\|.) :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # xor :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # complement :: VkSemaphoreCreateFlags -> VkSemaphoreCreateFlags # shift :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # rotate :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # zeroBits :: VkSemaphoreCreateFlags # bit :: Int -> VkSemaphoreCreateFlags # setBit :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # clearBit :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # complementBit :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # testBit :: VkSemaphoreCreateFlags -> Int -> Bool # bitSizeMaybe :: VkSemaphoreCreateFlags -> Maybe Int # bitSize :: VkSemaphoreCreateFlags -> Int # isSigned :: VkSemaphoreCreateFlags -> Bool # shiftL :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # unsafeShiftL :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # shiftR :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # unsafeShiftR :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # rotateL :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # rotateR :: VkSemaphoreCreateFlags -> Int -> VkSemaphoreCreateFlags # popCount :: VkSemaphoreCreateFlags -> Int #
FiniteBits VkSemaphoreCreateFlags Source #
Methods finiteBitSize :: VkSemaphoreCreateFlags -> Int # countLeadingZeros :: VkSemaphoreCreateFlags -> Int # countTrailingZeros :: VkSemaphoreCreateFlags -> Int #
type Rep VkSemaphoreCreateFlags Source #
type Rep VkSemaphoreCreateFlags = D1 (MetaData "VkSemaphoreCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkSemaphoreCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkSemaphoreImportFlagsKHR Source #

Constructors

VkSemaphoreImportFlagsKHR VkFlags

Instances

Bounded VkSemaphoreImportFlagsKHR Source #
Methods minBound :: VkSemaphoreImportFlagsKHR # maxBound :: VkSemaphoreImportFlagsKHR #
Enum VkSemaphoreImportFlagsKHR Source #
Methods succ :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # pred :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # toEnum :: Int -> VkSemaphoreImportFlagsKHR # fromEnum :: VkSemaphoreImportFlagsKHR -> Int # enumFrom :: VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR] # enumFromThen :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR] # enumFromTo :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR] # enumFromThenTo :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> [VkSemaphoreImportFlagsKHR] #
Eq VkSemaphoreImportFlagsKHR Source #
Methods (==) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool # (/=) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool #
Integral VkSemaphoreImportFlagsKHR Source #
Methods quot :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # rem :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # div :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # mod :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # quotRem :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> (VkSemaphoreImportFlagsKHR, VkSemaphoreImportFlagsKHR) # divMod :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> (VkSemaphoreImportFlagsKHR, VkSemaphoreImportFlagsKHR) # toInteger :: VkSemaphoreImportFlagsKHR -> Integer #
Data VkSemaphoreImportFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkSemaphoreImportFlagsKHR -> c VkSemaphoreImportFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkSemaphoreImportFlagsKHR # toConstr :: VkSemaphoreImportFlagsKHR -> Constr # dataTypeOf :: VkSemaphoreImportFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkSemaphoreImportFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkSemaphoreImportFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkSemaphoreImportFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkSemaphoreImportFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkSemaphoreImportFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkSemaphoreImportFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkSemaphoreImportFlagsKHR -> m VkSemaphoreImportFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkSemaphoreImportFlagsKHR -> m VkSemaphoreImportFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkSemaphoreImportFlagsKHR -> m VkSemaphoreImportFlagsKHR #
Num VkSemaphoreImportFlagsKHR Source #
Methods (+) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # (-) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # (*) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # negate :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # abs :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # signum :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # fromInteger :: Integer -> VkSemaphoreImportFlagsKHR #
Ord VkSemaphoreImportFlagsKHR Source #
Methods compare :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Ordering # (<) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool # (<=) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool # (>) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool # (>=) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> Bool # max :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # min :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR #
Read VkSemaphoreImportFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkSemaphoreImportFlagsKHR # readList :: ReadS [VkSemaphoreImportFlagsKHR] # readPrec :: ReadPrec VkSemaphoreImportFlagsKHR # readListPrec :: ReadPrec [VkSemaphoreImportFlagsKHR] #
Real VkSemaphoreImportFlagsKHR Source #
Methods toRational :: VkSemaphoreImportFlagsKHR -> Rational #
Show VkSemaphoreImportFlagsKHR Source #
Methods showsPrec :: Int -> VkSemaphoreImportFlagsKHR -> ShowS # show :: VkSemaphoreImportFlagsKHR -> String # showList :: [VkSemaphoreImportFlagsKHR] -> ShowS #
Generic VkSemaphoreImportFlagsKHR Source #
Associated Types type Rep VkSemaphoreImportFlagsKHR :: * -> * # Methods from :: VkSemaphoreImportFlagsKHR -> Rep VkSemaphoreImportFlagsKHR x # to :: Rep VkSemaphoreImportFlagsKHR x -> VkSemaphoreImportFlagsKHR #
Storable VkSemaphoreImportFlagsKHR Source #
Methods sizeOf :: VkSemaphoreImportFlagsKHR -> Int # alignment :: VkSemaphoreImportFlagsKHR -> Int # peekElemOff :: Ptr VkSemaphoreImportFlagsKHR -> Int -> IO VkSemaphoreImportFlagsKHR # pokeElemOff :: Ptr VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSemaphoreImportFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkSemaphoreImportFlagsKHR -> IO () # peek :: Ptr VkSemaphoreImportFlagsKHR -> IO VkSemaphoreImportFlagsKHR # poke :: Ptr VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> IO () #
Bits VkSemaphoreImportFlagsKHR Source #
Methods (.&.) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # (.\|.) :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # xor :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # complement :: VkSemaphoreImportFlagsKHR -> VkSemaphoreImportFlagsKHR # shift :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # rotate :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # zeroBits :: VkSemaphoreImportFlagsKHR # bit :: Int -> VkSemaphoreImportFlagsKHR # setBit :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # clearBit :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # complementBit :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # testBit :: VkSemaphoreImportFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkSemaphoreImportFlagsKHR -> Maybe Int # bitSize :: VkSemaphoreImportFlagsKHR -> Int # isSigned :: VkSemaphoreImportFlagsKHR -> Bool # shiftL :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # unsafeShiftL :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # shiftR :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # unsafeShiftR :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # rotateL :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # rotateR :: VkSemaphoreImportFlagsKHR -> Int -> VkSemaphoreImportFlagsKHR # popCount :: VkSemaphoreImportFlagsKHR -> Int #
FiniteBits VkSemaphoreImportFlagsKHR Source #
Methods finiteBitSize :: VkSemaphoreImportFlagsKHR -> Int # countLeadingZeros :: VkSemaphoreImportFlagsKHR -> Int # countTrailingZeros :: VkSemaphoreImportFlagsKHR -> Int #
type Rep VkSemaphoreImportFlagsKHR Source #
type Rep VkSemaphoreImportFlagsKHR = D1 (MetaData "VkSemaphoreImportFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkSemaphoreImportFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkShaderModuleCreateFlags Source #

Constructors

VkShaderModuleCreateFlags VkFlags

Instances

Bounded VkShaderModuleCreateFlags Source #
Methods minBound :: VkShaderModuleCreateFlags # maxBound :: VkShaderModuleCreateFlags #
Enum VkShaderModuleCreateFlags Source #
Methods succ :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # pred :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # toEnum :: Int -> VkShaderModuleCreateFlags # fromEnum :: VkShaderModuleCreateFlags -> Int # enumFrom :: VkShaderModuleCreateFlags -> [VkShaderModuleCreateFlags] # enumFromThen :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> [VkShaderModuleCreateFlags] # enumFromTo :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> [VkShaderModuleCreateFlags] # enumFromThenTo :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> [VkShaderModuleCreateFlags] #
Eq VkShaderModuleCreateFlags Source #
Methods (==) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> Bool # (/=) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> Bool #
Integral VkShaderModuleCreateFlags Source #
Methods quot :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # rem :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # div :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # mod :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # quotRem :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> (VkShaderModuleCreateFlags, VkShaderModuleCreateFlags) # divMod :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> (VkShaderModuleCreateFlags, VkShaderModuleCreateFlags) # toInteger :: VkShaderModuleCreateFlags -> Integer #
Data VkShaderModuleCreateFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkShaderModuleCreateFlags -> c VkShaderModuleCreateFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkShaderModuleCreateFlags # toConstr :: VkShaderModuleCreateFlags -> Constr # dataTypeOf :: VkShaderModuleCreateFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkShaderModuleCreateFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkShaderModuleCreateFlags) # gmapT :: (forall b. Data b => b -> b) -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkShaderModuleCreateFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkShaderModuleCreateFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkShaderModuleCreateFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkShaderModuleCreateFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkShaderModuleCreateFlags -> m VkShaderModuleCreateFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkShaderModuleCreateFlags -> m VkShaderModuleCreateFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkShaderModuleCreateFlags -> m VkShaderModuleCreateFlags #
Num VkShaderModuleCreateFlags Source #
Methods (+) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # (-) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # (*) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # negate :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # abs :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # signum :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # fromInteger :: Integer -> VkShaderModuleCreateFlags #
Ord VkShaderModuleCreateFlags Source #
Methods compare :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> Ordering # (<) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> Bool # (<=) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> Bool # (>) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> Bool # (>=) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> Bool # max :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # min :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags #
Read VkShaderModuleCreateFlags Source #
Methods readsPrec :: Int -> ReadS VkShaderModuleCreateFlags # readList :: ReadS [VkShaderModuleCreateFlags] # readPrec :: ReadPrec VkShaderModuleCreateFlags # readListPrec :: ReadPrec [VkShaderModuleCreateFlags] #
Real VkShaderModuleCreateFlags Source #
Methods toRational :: VkShaderModuleCreateFlags -> Rational #
Show VkShaderModuleCreateFlags Source #
Methods showsPrec :: Int -> VkShaderModuleCreateFlags -> ShowS # show :: VkShaderModuleCreateFlags -> String # showList :: [VkShaderModuleCreateFlags] -> ShowS #
Generic VkShaderModuleCreateFlags Source #
Associated Types type Rep VkShaderModuleCreateFlags :: * -> * # Methods from :: VkShaderModuleCreateFlags -> Rep VkShaderModuleCreateFlags x # to :: Rep VkShaderModuleCreateFlags x -> VkShaderModuleCreateFlags #
Storable VkShaderModuleCreateFlags Source #
Methods sizeOf :: VkShaderModuleCreateFlags -> Int # alignment :: VkShaderModuleCreateFlags -> Int # peekElemOff :: Ptr VkShaderModuleCreateFlags -> Int -> IO VkShaderModuleCreateFlags # pokeElemOff :: Ptr VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkShaderModuleCreateFlags # pokeByteOff :: Ptr b -> Int -> VkShaderModuleCreateFlags -> IO () # peek :: Ptr VkShaderModuleCreateFlags -> IO VkShaderModuleCreateFlags # poke :: Ptr VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> IO () #
Bits VkShaderModuleCreateFlags Source #
Methods (.&.) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # (.\|.) :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # xor :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # complement :: VkShaderModuleCreateFlags -> VkShaderModuleCreateFlags # shift :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # rotate :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # zeroBits :: VkShaderModuleCreateFlags # bit :: Int -> VkShaderModuleCreateFlags # setBit :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # clearBit :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # complementBit :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # testBit :: VkShaderModuleCreateFlags -> Int -> Bool # bitSizeMaybe :: VkShaderModuleCreateFlags -> Maybe Int # bitSize :: VkShaderModuleCreateFlags -> Int # isSigned :: VkShaderModuleCreateFlags -> Bool # shiftL :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # unsafeShiftL :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # shiftR :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # unsafeShiftR :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # rotateL :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # rotateR :: VkShaderModuleCreateFlags -> Int -> VkShaderModuleCreateFlags # popCount :: VkShaderModuleCreateFlags -> Int #
FiniteBits VkShaderModuleCreateFlags Source #
Methods finiteBitSize :: VkShaderModuleCreateFlags -> Int # countLeadingZeros :: VkShaderModuleCreateFlags -> Int # countTrailingZeros :: VkShaderModuleCreateFlags -> Int #
type Rep VkShaderModuleCreateFlags Source #
type Rep VkShaderModuleCreateFlags = D1 (MetaData "VkShaderModuleCreateFlags" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkShaderModuleCreateFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkValidationCacheCreateFlagsEXT Source #

Constructors

VkValidationCacheCreateFlagsEXT VkFlags

Instances

Bounded VkValidationCacheCreateFlagsEXT Source #
Methods minBound :: VkValidationCacheCreateFlagsEXT # maxBound :: VkValidationCacheCreateFlagsEXT #
Enum VkValidationCacheCreateFlagsEXT Source #
Methods succ :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # pred :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # toEnum :: Int -> VkValidationCacheCreateFlagsEXT # fromEnum :: VkValidationCacheCreateFlagsEXT -> Int # enumFrom :: VkValidationCacheCreateFlagsEXT -> [VkValidationCacheCreateFlagsEXT] # enumFromThen :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> [VkValidationCacheCreateFlagsEXT] # enumFromTo :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> [VkValidationCacheCreateFlagsEXT] # enumFromThenTo :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> [VkValidationCacheCreateFlagsEXT] #
Eq VkValidationCacheCreateFlagsEXT Source #
Methods (==) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Bool # (/=) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Bool #
Integral VkValidationCacheCreateFlagsEXT Source #
Methods quot :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # rem :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # div :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # mod :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # quotRem :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> (VkValidationCacheCreateFlagsEXT, VkValidationCacheCreateFlagsEXT) # divMod :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> (VkValidationCacheCreateFlagsEXT, VkValidationCacheCreateFlagsEXT) # toInteger :: VkValidationCacheCreateFlagsEXT -> Integer #
Data VkValidationCacheCreateFlagsEXT Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkValidationCacheCreateFlagsEXT -> c VkValidationCacheCreateFlagsEXT # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkValidationCacheCreateFlagsEXT # toConstr :: VkValidationCacheCreateFlagsEXT -> Constr # dataTypeOf :: VkValidationCacheCreateFlagsEXT -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkValidationCacheCreateFlagsEXT) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkValidationCacheCreateFlagsEXT) # gmapT :: (forall b. Data b => b -> b) -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkValidationCacheCreateFlagsEXT -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkValidationCacheCreateFlagsEXT -> r # gmapQ :: (forall d. Data d => d -> u) -> VkValidationCacheCreateFlagsEXT -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkValidationCacheCreateFlagsEXT -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkValidationCacheCreateFlagsEXT -> m VkValidationCacheCreateFlagsEXT # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkValidationCacheCreateFlagsEXT -> m VkValidationCacheCreateFlagsEXT # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkValidationCacheCreateFlagsEXT -> m VkValidationCacheCreateFlagsEXT #
Num VkValidationCacheCreateFlagsEXT Source #
Methods (+) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # (-) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # (*) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # negate :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # abs :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # signum :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # fromInteger :: Integer -> VkValidationCacheCreateFlagsEXT #
Ord VkValidationCacheCreateFlagsEXT Source #
Methods compare :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Ordering # (<) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Bool # (<=) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Bool # (>) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Bool # (>=) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> Bool # max :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # min :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT #
Read VkValidationCacheCreateFlagsEXT Source #
Methods readsPrec :: Int -> ReadS VkValidationCacheCreateFlagsEXT # readList :: ReadS [VkValidationCacheCreateFlagsEXT] # readPrec :: ReadPrec VkValidationCacheCreateFlagsEXT # readListPrec :: ReadPrec [VkValidationCacheCreateFlagsEXT] #
Real VkValidationCacheCreateFlagsEXT Source #
Methods toRational :: VkValidationCacheCreateFlagsEXT -> Rational #
Show VkValidationCacheCreateFlagsEXT Source #
Methods showsPrec :: Int -> VkValidationCacheCreateFlagsEXT -> ShowS # show :: VkValidationCacheCreateFlagsEXT -> String # showList :: [VkValidationCacheCreateFlagsEXT] -> ShowS #
Generic VkValidationCacheCreateFlagsEXT Source #
Associated Types type Rep VkValidationCacheCreateFlagsEXT :: * -> * # Methods from :: VkValidationCacheCreateFlagsEXT -> Rep VkValidationCacheCreateFlagsEXT x # to :: Rep VkValidationCacheCreateFlagsEXT x -> VkValidationCacheCreateFlagsEXT #
Storable VkValidationCacheCreateFlagsEXT Source #
Methods sizeOf :: VkValidationCacheCreateFlagsEXT -> Int # alignment :: VkValidationCacheCreateFlagsEXT -> Int # peekElemOff :: Ptr VkValidationCacheCreateFlagsEXT -> Int -> IO VkValidationCacheCreateFlagsEXT # pokeElemOff :: Ptr VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT -> IO () # peekByteOff :: Ptr b -> Int -> IO VkValidationCacheCreateFlagsEXT # pokeByteOff :: Ptr b -> Int -> VkValidationCacheCreateFlagsEXT -> IO () # peek :: Ptr VkValidationCacheCreateFlagsEXT -> IO VkValidationCacheCreateFlagsEXT # poke :: Ptr VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> IO () #
Bits VkValidationCacheCreateFlagsEXT Source #
Methods (.&.) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # (.\|.) :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # xor :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # complement :: VkValidationCacheCreateFlagsEXT -> VkValidationCacheCreateFlagsEXT # shift :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # rotate :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # zeroBits :: VkValidationCacheCreateFlagsEXT # bit :: Int -> VkValidationCacheCreateFlagsEXT # setBit :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # clearBit :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # complementBit :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # testBit :: VkValidationCacheCreateFlagsEXT -> Int -> Bool # bitSizeMaybe :: VkValidationCacheCreateFlagsEXT -> Maybe Int # bitSize :: VkValidationCacheCreateFlagsEXT -> Int # isSigned :: VkValidationCacheCreateFlagsEXT -> Bool # shiftL :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # unsafeShiftL :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # shiftR :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # unsafeShiftR :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # rotateL :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # rotateR :: VkValidationCacheCreateFlagsEXT -> Int -> VkValidationCacheCreateFlagsEXT # popCount :: VkValidationCacheCreateFlagsEXT -> Int #
FiniteBits VkValidationCacheCreateFlagsEXT Source #
Methods finiteBitSize :: VkValidationCacheCreateFlagsEXT -> Int # countLeadingZeros :: VkValidationCacheCreateFlagsEXT -> Int # countTrailingZeros :: VkValidationCacheCreateFlagsEXT -> Int #
type Rep VkValidationCacheCreateFlagsEXT Source #
type Rep VkValidationCacheCreateFlagsEXT = D1 (MetaData "VkValidationCacheCreateFlagsEXT" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkValidationCacheCreateFlagsEXT" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkViSurfaceCreateFlagsNN Source #

Constructors

VkViSurfaceCreateFlagsNN VkFlags

Instances

Bounded VkViSurfaceCreateFlagsNN Source #
Methods minBound :: VkViSurfaceCreateFlagsNN # maxBound :: VkViSurfaceCreateFlagsNN #
Enum VkViSurfaceCreateFlagsNN Source #
Methods succ :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # pred :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # toEnum :: Int -> VkViSurfaceCreateFlagsNN # fromEnum :: VkViSurfaceCreateFlagsNN -> Int # enumFrom :: VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN] # enumFromThen :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN] # enumFromTo :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN] # enumFromThenTo :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> [VkViSurfaceCreateFlagsNN] #
Eq VkViSurfaceCreateFlagsNN Source #
Methods (==) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool # (/=) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool #
Integral VkViSurfaceCreateFlagsNN Source #
Methods quot :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # rem :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # div :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # mod :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # quotRem :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> (VkViSurfaceCreateFlagsNN, VkViSurfaceCreateFlagsNN) # divMod :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> (VkViSurfaceCreateFlagsNN, VkViSurfaceCreateFlagsNN) # toInteger :: VkViSurfaceCreateFlagsNN -> Integer #
Data VkViSurfaceCreateFlagsNN Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkViSurfaceCreateFlagsNN -> c VkViSurfaceCreateFlagsNN # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkViSurfaceCreateFlagsNN # toConstr :: VkViSurfaceCreateFlagsNN -> Constr # dataTypeOf :: VkViSurfaceCreateFlagsNN -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkViSurfaceCreateFlagsNN) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkViSurfaceCreateFlagsNN) # gmapT :: (forall b. Data b => b -> b) -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkViSurfaceCreateFlagsNN -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkViSurfaceCreateFlagsNN -> r # gmapQ :: (forall d. Data d => d -> u) -> VkViSurfaceCreateFlagsNN -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkViSurfaceCreateFlagsNN -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkViSurfaceCreateFlagsNN -> m VkViSurfaceCreateFlagsNN # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkViSurfaceCreateFlagsNN -> m VkViSurfaceCreateFlagsNN # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkViSurfaceCreateFlagsNN -> m VkViSurfaceCreateFlagsNN #
Num VkViSurfaceCreateFlagsNN Source #
Methods (+) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # (-) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # (*) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # negate :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # abs :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # signum :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # fromInteger :: Integer -> VkViSurfaceCreateFlagsNN #
Ord VkViSurfaceCreateFlagsNN Source #
Methods compare :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Ordering # (<) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool # (<=) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool # (>) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool # (>=) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> Bool # max :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # min :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN #
Read VkViSurfaceCreateFlagsNN Source #
Methods readsPrec :: Int -> ReadS VkViSurfaceCreateFlagsNN # readList :: ReadS [VkViSurfaceCreateFlagsNN] # readPrec :: ReadPrec VkViSurfaceCreateFlagsNN # readListPrec :: ReadPrec [VkViSurfaceCreateFlagsNN] #
Real VkViSurfaceCreateFlagsNN Source #
Methods toRational :: VkViSurfaceCreateFlagsNN -> Rational #
Show VkViSurfaceCreateFlagsNN Source #
Methods showsPrec :: Int -> VkViSurfaceCreateFlagsNN -> ShowS # show :: VkViSurfaceCreateFlagsNN -> String # showList :: [VkViSurfaceCreateFlagsNN] -> ShowS #
Generic VkViSurfaceCreateFlagsNN Source #
Associated Types type Rep VkViSurfaceCreateFlagsNN :: * -> * # Methods from :: VkViSurfaceCreateFlagsNN -> Rep VkViSurfaceCreateFlagsNN x # to :: Rep VkViSurfaceCreateFlagsNN x -> VkViSurfaceCreateFlagsNN #
Storable VkViSurfaceCreateFlagsNN Source #
Methods sizeOf :: VkViSurfaceCreateFlagsNN -> Int # alignment :: VkViSurfaceCreateFlagsNN -> Int # peekElemOff :: Ptr VkViSurfaceCreateFlagsNN -> Int -> IO VkViSurfaceCreateFlagsNN # pokeElemOff :: Ptr VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN -> IO () # peekByteOff :: Ptr b -> Int -> IO VkViSurfaceCreateFlagsNN # pokeByteOff :: Ptr b -> Int -> VkViSurfaceCreateFlagsNN -> IO () # peek :: Ptr VkViSurfaceCreateFlagsNN -> IO VkViSurfaceCreateFlagsNN # poke :: Ptr VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> IO () #
Bits VkViSurfaceCreateFlagsNN Source #
Methods (.&.) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # (.\|.) :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # xor :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # complement :: VkViSurfaceCreateFlagsNN -> VkViSurfaceCreateFlagsNN # shift :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # rotate :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # zeroBits :: VkViSurfaceCreateFlagsNN # bit :: Int -> VkViSurfaceCreateFlagsNN # setBit :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # clearBit :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # complementBit :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # testBit :: VkViSurfaceCreateFlagsNN -> Int -> Bool # bitSizeMaybe :: VkViSurfaceCreateFlagsNN -> Maybe Int # bitSize :: VkViSurfaceCreateFlagsNN -> Int # isSigned :: VkViSurfaceCreateFlagsNN -> Bool # shiftL :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # unsafeShiftL :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # shiftR :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # unsafeShiftR :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # rotateL :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # rotateR :: VkViSurfaceCreateFlagsNN -> Int -> VkViSurfaceCreateFlagsNN # popCount :: VkViSurfaceCreateFlagsNN -> Int #
FiniteBits VkViSurfaceCreateFlagsNN Source #
Methods finiteBitSize :: VkViSurfaceCreateFlagsNN -> Int # countLeadingZeros :: VkViSurfaceCreateFlagsNN -> Int # countTrailingZeros :: VkViSurfaceCreateFlagsNN -> Int #
type Rep VkViSurfaceCreateFlagsNN Source #
type Rep VkViSurfaceCreateFlagsNN = D1 (MetaData "VkViSurfaceCreateFlagsNN" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkViSurfaceCreateFlagsNN" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkWaylandSurfaceCreateFlagsKHR Source #

Constructors

VkWaylandSurfaceCreateFlagsKHR VkFlags

Instances

Bounded VkWaylandSurfaceCreateFlagsKHR Source #
Methods minBound :: VkWaylandSurfaceCreateFlagsKHR # maxBound :: VkWaylandSurfaceCreateFlagsKHR #
Enum VkWaylandSurfaceCreateFlagsKHR Source #
Methods succ :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # pred :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # toEnum :: Int -> VkWaylandSurfaceCreateFlagsKHR # fromEnum :: VkWaylandSurfaceCreateFlagsKHR -> Int # enumFrom :: VkWaylandSurfaceCreateFlagsKHR -> [VkWaylandSurfaceCreateFlagsKHR] # enumFromThen :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> [VkWaylandSurfaceCreateFlagsKHR] # enumFromTo :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> [VkWaylandSurfaceCreateFlagsKHR] # enumFromThenTo :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> [VkWaylandSurfaceCreateFlagsKHR] #
Eq VkWaylandSurfaceCreateFlagsKHR Source #
Methods (==) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> Bool # (/=) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> Bool #
Integral VkWaylandSurfaceCreateFlagsKHR Source #
Methods quot :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # rem :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # div :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # mod :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # quotRem :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> (VkWaylandSurfaceCreateFlagsKHR, VkWaylandSurfaceCreateFlagsKHR) # divMod :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> (VkWaylandSurfaceCreateFlagsKHR, VkWaylandSurfaceCreateFlagsKHR) # toInteger :: VkWaylandSurfaceCreateFlagsKHR -> Integer #
Data VkWaylandSurfaceCreateFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkWaylandSurfaceCreateFlagsKHR -> c VkWaylandSurfaceCreateFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkWaylandSurfaceCreateFlagsKHR # toConstr :: VkWaylandSurfaceCreateFlagsKHR -> Constr # dataTypeOf :: VkWaylandSurfaceCreateFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkWaylandSurfaceCreateFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkWaylandSurfaceCreateFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkWaylandSurfaceCreateFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkWaylandSurfaceCreateFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkWaylandSurfaceCreateFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkWaylandSurfaceCreateFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkWaylandSurfaceCreateFlagsKHR -> m VkWaylandSurfaceCreateFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkWaylandSurfaceCreateFlagsKHR -> m VkWaylandSurfaceCreateFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkWaylandSurfaceCreateFlagsKHR -> m VkWaylandSurfaceCreateFlagsKHR #
Num VkWaylandSurfaceCreateFlagsKHR Source #
Methods (+) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # (-) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # (*) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # negate :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # abs :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # signum :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # fromInteger :: Integer -> VkWaylandSurfaceCreateFlagsKHR #
Ord VkWaylandSurfaceCreateFlagsKHR Source #
Methods compare :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> Ordering # (<) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> Bool # (<=) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> Bool # (>) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> Bool # (>=) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> Bool # max :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # min :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR #
Read VkWaylandSurfaceCreateFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkWaylandSurfaceCreateFlagsKHR # readList :: ReadS [VkWaylandSurfaceCreateFlagsKHR] # readPrec :: ReadPrec VkWaylandSurfaceCreateFlagsKHR # readListPrec :: ReadPrec [VkWaylandSurfaceCreateFlagsKHR] #
Real VkWaylandSurfaceCreateFlagsKHR Source #
Methods toRational :: VkWaylandSurfaceCreateFlagsKHR -> Rational #
Show VkWaylandSurfaceCreateFlagsKHR Source #
Methods showsPrec :: Int -> VkWaylandSurfaceCreateFlagsKHR -> ShowS # show :: VkWaylandSurfaceCreateFlagsKHR -> String # showList :: [VkWaylandSurfaceCreateFlagsKHR] -> ShowS #
Generic VkWaylandSurfaceCreateFlagsKHR Source #
Associated Types type Rep VkWaylandSurfaceCreateFlagsKHR :: * -> * # Methods from :: VkWaylandSurfaceCreateFlagsKHR -> Rep VkWaylandSurfaceCreateFlagsKHR x # to :: Rep VkWaylandSurfaceCreateFlagsKHR x -> VkWaylandSurfaceCreateFlagsKHR #
Storable VkWaylandSurfaceCreateFlagsKHR Source #
Methods sizeOf :: VkWaylandSurfaceCreateFlagsKHR -> Int # alignment :: VkWaylandSurfaceCreateFlagsKHR -> Int # peekElemOff :: Ptr VkWaylandSurfaceCreateFlagsKHR -> Int -> IO VkWaylandSurfaceCreateFlagsKHR # pokeElemOff :: Ptr VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkWaylandSurfaceCreateFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkWaylandSurfaceCreateFlagsKHR -> IO () # peek :: Ptr VkWaylandSurfaceCreateFlagsKHR -> IO VkWaylandSurfaceCreateFlagsKHR # poke :: Ptr VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> IO () #
Bits VkWaylandSurfaceCreateFlagsKHR Source #
Methods (.&.) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # (.\|.) :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # xor :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # complement :: VkWaylandSurfaceCreateFlagsKHR -> VkWaylandSurfaceCreateFlagsKHR # shift :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # rotate :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # zeroBits :: VkWaylandSurfaceCreateFlagsKHR # bit :: Int -> VkWaylandSurfaceCreateFlagsKHR # setBit :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # clearBit :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # complementBit :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # testBit :: VkWaylandSurfaceCreateFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkWaylandSurfaceCreateFlagsKHR -> Maybe Int # bitSize :: VkWaylandSurfaceCreateFlagsKHR -> Int # isSigned :: VkWaylandSurfaceCreateFlagsKHR -> Bool # shiftL :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # unsafeShiftL :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # shiftR :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # unsafeShiftR :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # rotateL :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # rotateR :: VkWaylandSurfaceCreateFlagsKHR -> Int -> VkWaylandSurfaceCreateFlagsKHR # popCount :: VkWaylandSurfaceCreateFlagsKHR -> Int #
FiniteBits VkWaylandSurfaceCreateFlagsKHR Source #
Methods finiteBitSize :: VkWaylandSurfaceCreateFlagsKHR -> Int # countLeadingZeros :: VkWaylandSurfaceCreateFlagsKHR -> Int # countTrailingZeros :: VkWaylandSurfaceCreateFlagsKHR -> Int #
type Rep VkWaylandSurfaceCreateFlagsKHR Source #
type Rep VkWaylandSurfaceCreateFlagsKHR = D1 (MetaData "VkWaylandSurfaceCreateFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkWaylandSurfaceCreateFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkWin32SurfaceCreateFlagsKHR Source #

Constructors

VkWin32SurfaceCreateFlagsKHR VkFlags

Instances

Bounded VkWin32SurfaceCreateFlagsKHR Source #
Methods minBound :: VkWin32SurfaceCreateFlagsKHR # maxBound :: VkWin32SurfaceCreateFlagsKHR #
Enum VkWin32SurfaceCreateFlagsKHR Source #
Methods succ :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # pred :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # toEnum :: Int -> VkWin32SurfaceCreateFlagsKHR # fromEnum :: VkWin32SurfaceCreateFlagsKHR -> Int # enumFrom :: VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR] # enumFromThen :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR] # enumFromTo :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR] # enumFromThenTo :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> [VkWin32SurfaceCreateFlagsKHR] #
Eq VkWin32SurfaceCreateFlagsKHR Source #
Methods (==) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> Bool # (/=) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> Bool #
Integral VkWin32SurfaceCreateFlagsKHR Source #
Methods quot :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # rem :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # div :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # mod :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # quotRem :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> (VkWin32SurfaceCreateFlagsKHR, VkWin32SurfaceCreateFlagsKHR) # divMod :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> (VkWin32SurfaceCreateFlagsKHR, VkWin32SurfaceCreateFlagsKHR) # toInteger :: VkWin32SurfaceCreateFlagsKHR -> Integer #
Data VkWin32SurfaceCreateFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkWin32SurfaceCreateFlagsKHR -> c VkWin32SurfaceCreateFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkWin32SurfaceCreateFlagsKHR # toConstr :: VkWin32SurfaceCreateFlagsKHR -> Constr # dataTypeOf :: VkWin32SurfaceCreateFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkWin32SurfaceCreateFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkWin32SurfaceCreateFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkWin32SurfaceCreateFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkWin32SurfaceCreateFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkWin32SurfaceCreateFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkWin32SurfaceCreateFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkWin32SurfaceCreateFlagsKHR -> m VkWin32SurfaceCreateFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkWin32SurfaceCreateFlagsKHR -> m VkWin32SurfaceCreateFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkWin32SurfaceCreateFlagsKHR -> m VkWin32SurfaceCreateFlagsKHR #
Num VkWin32SurfaceCreateFlagsKHR Source #
Methods (+) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # (-) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # (*) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # negate :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # abs :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # signum :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # fromInteger :: Integer -> VkWin32SurfaceCreateFlagsKHR #
Ord VkWin32SurfaceCreateFlagsKHR Source #
Methods compare :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> Ordering # (<) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> Bool # (<=) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> Bool # (>) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> Bool # (>=) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> Bool # max :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # min :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR #
Read VkWin32SurfaceCreateFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkWin32SurfaceCreateFlagsKHR # readList :: ReadS [VkWin32SurfaceCreateFlagsKHR] # readPrec :: ReadPrec VkWin32SurfaceCreateFlagsKHR # readListPrec :: ReadPrec [VkWin32SurfaceCreateFlagsKHR] #
Real VkWin32SurfaceCreateFlagsKHR Source #
Methods toRational :: VkWin32SurfaceCreateFlagsKHR -> Rational #
Show VkWin32SurfaceCreateFlagsKHR Source #
Methods showsPrec :: Int -> VkWin32SurfaceCreateFlagsKHR -> ShowS # show :: VkWin32SurfaceCreateFlagsKHR -> String # showList :: [VkWin32SurfaceCreateFlagsKHR] -> ShowS #
Generic VkWin32SurfaceCreateFlagsKHR Source #
Associated Types type Rep VkWin32SurfaceCreateFlagsKHR :: * -> * # Methods from :: VkWin32SurfaceCreateFlagsKHR -> Rep VkWin32SurfaceCreateFlagsKHR x # to :: Rep VkWin32SurfaceCreateFlagsKHR x -> VkWin32SurfaceCreateFlagsKHR #
Storable VkWin32SurfaceCreateFlagsKHR Source #
Methods sizeOf :: VkWin32SurfaceCreateFlagsKHR -> Int # alignment :: VkWin32SurfaceCreateFlagsKHR -> Int # peekElemOff :: Ptr VkWin32SurfaceCreateFlagsKHR -> Int -> IO VkWin32SurfaceCreateFlagsKHR # pokeElemOff :: Ptr VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkWin32SurfaceCreateFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkWin32SurfaceCreateFlagsKHR -> IO () # peek :: Ptr VkWin32SurfaceCreateFlagsKHR -> IO VkWin32SurfaceCreateFlagsKHR # poke :: Ptr VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> IO () #
Bits VkWin32SurfaceCreateFlagsKHR Source #
Methods (.&.) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # (.\|.) :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # xor :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # complement :: VkWin32SurfaceCreateFlagsKHR -> VkWin32SurfaceCreateFlagsKHR # shift :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # rotate :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # zeroBits :: VkWin32SurfaceCreateFlagsKHR # bit :: Int -> VkWin32SurfaceCreateFlagsKHR # setBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # clearBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # complementBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # testBit :: VkWin32SurfaceCreateFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkWin32SurfaceCreateFlagsKHR -> Maybe Int # bitSize :: VkWin32SurfaceCreateFlagsKHR -> Int # isSigned :: VkWin32SurfaceCreateFlagsKHR -> Bool # shiftL :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # unsafeShiftL :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # shiftR :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # unsafeShiftR :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # rotateL :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # rotateR :: VkWin32SurfaceCreateFlagsKHR -> Int -> VkWin32SurfaceCreateFlagsKHR # popCount :: VkWin32SurfaceCreateFlagsKHR -> Int #
FiniteBits VkWin32SurfaceCreateFlagsKHR Source #
Methods finiteBitSize :: VkWin32SurfaceCreateFlagsKHR -> Int # countLeadingZeros :: VkWin32SurfaceCreateFlagsKHR -> Int # countTrailingZeros :: VkWin32SurfaceCreateFlagsKHR -> Int #
type Rep VkWin32SurfaceCreateFlagsKHR Source #
type Rep VkWin32SurfaceCreateFlagsKHR = D1 (MetaData "VkWin32SurfaceCreateFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkWin32SurfaceCreateFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkXcbSurfaceCreateFlagsKHR Source #

Constructors

VkXcbSurfaceCreateFlagsKHR VkFlags

Instances

Bounded VkXcbSurfaceCreateFlagsKHR Source #
Methods minBound :: VkXcbSurfaceCreateFlagsKHR # maxBound :: VkXcbSurfaceCreateFlagsKHR #
Enum VkXcbSurfaceCreateFlagsKHR Source #
Methods succ :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # pred :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # toEnum :: Int -> VkXcbSurfaceCreateFlagsKHR # fromEnum :: VkXcbSurfaceCreateFlagsKHR -> Int # enumFrom :: VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR] # enumFromThen :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR] # enumFromTo :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR] # enumFromThenTo :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> [VkXcbSurfaceCreateFlagsKHR] #
Eq VkXcbSurfaceCreateFlagsKHR Source #
Methods (==) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool # (/=) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool #
Integral VkXcbSurfaceCreateFlagsKHR Source #
Methods quot :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # rem :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # div :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # mod :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # quotRem :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> (VkXcbSurfaceCreateFlagsKHR, VkXcbSurfaceCreateFlagsKHR) # divMod :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> (VkXcbSurfaceCreateFlagsKHR, VkXcbSurfaceCreateFlagsKHR) # toInteger :: VkXcbSurfaceCreateFlagsKHR -> Integer #
Data VkXcbSurfaceCreateFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkXcbSurfaceCreateFlagsKHR -> c VkXcbSurfaceCreateFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkXcbSurfaceCreateFlagsKHR # toConstr :: VkXcbSurfaceCreateFlagsKHR -> Constr # dataTypeOf :: VkXcbSurfaceCreateFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkXcbSurfaceCreateFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkXcbSurfaceCreateFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkXcbSurfaceCreateFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkXcbSurfaceCreateFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkXcbSurfaceCreateFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkXcbSurfaceCreateFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkXcbSurfaceCreateFlagsKHR -> m VkXcbSurfaceCreateFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkXcbSurfaceCreateFlagsKHR -> m VkXcbSurfaceCreateFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkXcbSurfaceCreateFlagsKHR -> m VkXcbSurfaceCreateFlagsKHR #
Num VkXcbSurfaceCreateFlagsKHR Source #
Methods (+) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # (-) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # (*) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # negate :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # abs :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # signum :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # fromInteger :: Integer -> VkXcbSurfaceCreateFlagsKHR #
Ord VkXcbSurfaceCreateFlagsKHR Source #
Methods compare :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Ordering # (<) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool # (<=) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool # (>) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool # (>=) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> Bool # max :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # min :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR #
Read VkXcbSurfaceCreateFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkXcbSurfaceCreateFlagsKHR # readList :: ReadS [VkXcbSurfaceCreateFlagsKHR] # readPrec :: ReadPrec VkXcbSurfaceCreateFlagsKHR # readListPrec :: ReadPrec [VkXcbSurfaceCreateFlagsKHR] #
Real VkXcbSurfaceCreateFlagsKHR Source #
Methods toRational :: VkXcbSurfaceCreateFlagsKHR -> Rational #
Show VkXcbSurfaceCreateFlagsKHR Source #
Methods showsPrec :: Int -> VkXcbSurfaceCreateFlagsKHR -> ShowS # show :: VkXcbSurfaceCreateFlagsKHR -> String # showList :: [VkXcbSurfaceCreateFlagsKHR] -> ShowS #
Generic VkXcbSurfaceCreateFlagsKHR Source #
Associated Types type Rep VkXcbSurfaceCreateFlagsKHR :: * -> * # Methods from :: VkXcbSurfaceCreateFlagsKHR -> Rep VkXcbSurfaceCreateFlagsKHR x # to :: Rep VkXcbSurfaceCreateFlagsKHR x -> VkXcbSurfaceCreateFlagsKHR #
Storable VkXcbSurfaceCreateFlagsKHR Source #
Methods sizeOf :: VkXcbSurfaceCreateFlagsKHR -> Int # alignment :: VkXcbSurfaceCreateFlagsKHR -> Int # peekElemOff :: Ptr VkXcbSurfaceCreateFlagsKHR -> Int -> IO VkXcbSurfaceCreateFlagsKHR # pokeElemOff :: Ptr VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkXcbSurfaceCreateFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkXcbSurfaceCreateFlagsKHR -> IO () # peek :: Ptr VkXcbSurfaceCreateFlagsKHR -> IO VkXcbSurfaceCreateFlagsKHR # poke :: Ptr VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> IO () #
Bits VkXcbSurfaceCreateFlagsKHR Source #
Methods (.&.) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # (.\|.) :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # xor :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # complement :: VkXcbSurfaceCreateFlagsKHR -> VkXcbSurfaceCreateFlagsKHR # shift :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # rotate :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # zeroBits :: VkXcbSurfaceCreateFlagsKHR # bit :: Int -> VkXcbSurfaceCreateFlagsKHR # setBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # clearBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # complementBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # testBit :: VkXcbSurfaceCreateFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkXcbSurfaceCreateFlagsKHR -> Maybe Int # bitSize :: VkXcbSurfaceCreateFlagsKHR -> Int # isSigned :: VkXcbSurfaceCreateFlagsKHR -> Bool # shiftL :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # unsafeShiftL :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # shiftR :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # unsafeShiftR :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # rotateL :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # rotateR :: VkXcbSurfaceCreateFlagsKHR -> Int -> VkXcbSurfaceCreateFlagsKHR # popCount :: VkXcbSurfaceCreateFlagsKHR -> Int #
FiniteBits VkXcbSurfaceCreateFlagsKHR Source #
Methods finiteBitSize :: VkXcbSurfaceCreateFlagsKHR -> Int # countLeadingZeros :: VkXcbSurfaceCreateFlagsKHR -> Int # countTrailingZeros :: VkXcbSurfaceCreateFlagsKHR -> Int #
type Rep VkXcbSurfaceCreateFlagsKHR Source #
type Rep VkXcbSurfaceCreateFlagsKHR = D1 (MetaData "VkXcbSurfaceCreateFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkXcbSurfaceCreateFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

newtype VkXlibSurfaceCreateFlagsKHR Source #

Constructors

VkXlibSurfaceCreateFlagsKHR VkFlags

Instances

Bounded VkXlibSurfaceCreateFlagsKHR Source #
Methods minBound :: VkXlibSurfaceCreateFlagsKHR # maxBound :: VkXlibSurfaceCreateFlagsKHR #
Enum VkXlibSurfaceCreateFlagsKHR Source #
Methods succ :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # pred :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # toEnum :: Int -> VkXlibSurfaceCreateFlagsKHR # fromEnum :: VkXlibSurfaceCreateFlagsKHR -> Int # enumFrom :: VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR] # enumFromThen :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR] # enumFromTo :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR] # enumFromThenTo :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> [VkXlibSurfaceCreateFlagsKHR] #
Eq VkXlibSurfaceCreateFlagsKHR Source #
Methods (==) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool # (/=) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool #
Integral VkXlibSurfaceCreateFlagsKHR Source #
Methods quot :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # rem :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # div :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # mod :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # quotRem :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> (VkXlibSurfaceCreateFlagsKHR, VkXlibSurfaceCreateFlagsKHR) # divMod :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> (VkXlibSurfaceCreateFlagsKHR, VkXlibSurfaceCreateFlagsKHR) # toInteger :: VkXlibSurfaceCreateFlagsKHR -> Integer #
Data VkXlibSurfaceCreateFlagsKHR Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkXlibSurfaceCreateFlagsKHR -> c VkXlibSurfaceCreateFlagsKHR # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkXlibSurfaceCreateFlagsKHR # toConstr :: VkXlibSurfaceCreateFlagsKHR -> Constr # dataTypeOf :: VkXlibSurfaceCreateFlagsKHR -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkXlibSurfaceCreateFlagsKHR) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkXlibSurfaceCreateFlagsKHR) # gmapT :: (forall b. Data b => b -> b) -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkXlibSurfaceCreateFlagsKHR -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkXlibSurfaceCreateFlagsKHR -> r # gmapQ :: (forall d. Data d => d -> u) -> VkXlibSurfaceCreateFlagsKHR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkXlibSurfaceCreateFlagsKHR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkXlibSurfaceCreateFlagsKHR -> m VkXlibSurfaceCreateFlagsKHR # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkXlibSurfaceCreateFlagsKHR -> m VkXlibSurfaceCreateFlagsKHR # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkXlibSurfaceCreateFlagsKHR -> m VkXlibSurfaceCreateFlagsKHR #
Num VkXlibSurfaceCreateFlagsKHR Source #
Methods (+) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # (-) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # (*) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # negate :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # abs :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # signum :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # fromInteger :: Integer -> VkXlibSurfaceCreateFlagsKHR #
Ord VkXlibSurfaceCreateFlagsKHR Source #
Methods compare :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Ordering # (<) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool # (<=) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool # (>) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool # (>=) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> Bool # max :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # min :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR #
Read VkXlibSurfaceCreateFlagsKHR Source #
Methods readsPrec :: Int -> ReadS VkXlibSurfaceCreateFlagsKHR # readList :: ReadS [VkXlibSurfaceCreateFlagsKHR] # readPrec :: ReadPrec VkXlibSurfaceCreateFlagsKHR # readListPrec :: ReadPrec [VkXlibSurfaceCreateFlagsKHR] #
Real VkXlibSurfaceCreateFlagsKHR Source #
Methods toRational :: VkXlibSurfaceCreateFlagsKHR -> Rational #
Show VkXlibSurfaceCreateFlagsKHR Source #
Methods showsPrec :: Int -> VkXlibSurfaceCreateFlagsKHR -> ShowS # show :: VkXlibSurfaceCreateFlagsKHR -> String # showList :: [VkXlibSurfaceCreateFlagsKHR] -> ShowS #
Generic VkXlibSurfaceCreateFlagsKHR Source #
Associated Types type Rep VkXlibSurfaceCreateFlagsKHR :: * -> * # Methods from :: VkXlibSurfaceCreateFlagsKHR -> Rep VkXlibSurfaceCreateFlagsKHR x # to :: Rep VkXlibSurfaceCreateFlagsKHR x -> VkXlibSurfaceCreateFlagsKHR #
Storable VkXlibSurfaceCreateFlagsKHR Source #
Methods sizeOf :: VkXlibSurfaceCreateFlagsKHR -> Int # alignment :: VkXlibSurfaceCreateFlagsKHR -> Int # peekElemOff :: Ptr VkXlibSurfaceCreateFlagsKHR -> Int -> IO VkXlibSurfaceCreateFlagsKHR # pokeElemOff :: Ptr VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR -> IO () # peekByteOff :: Ptr b -> Int -> IO VkXlibSurfaceCreateFlagsKHR # pokeByteOff :: Ptr b -> Int -> VkXlibSurfaceCreateFlagsKHR -> IO () # peek :: Ptr VkXlibSurfaceCreateFlagsKHR -> IO VkXlibSurfaceCreateFlagsKHR # poke :: Ptr VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> IO () #
Bits VkXlibSurfaceCreateFlagsKHR Source #
Methods (.&.) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # (.\|.) :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # xor :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # complement :: VkXlibSurfaceCreateFlagsKHR -> VkXlibSurfaceCreateFlagsKHR # shift :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # rotate :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # zeroBits :: VkXlibSurfaceCreateFlagsKHR # bit :: Int -> VkXlibSurfaceCreateFlagsKHR # setBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # clearBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # complementBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # testBit :: VkXlibSurfaceCreateFlagsKHR -> Int -> Bool # bitSizeMaybe :: VkXlibSurfaceCreateFlagsKHR -> Maybe Int # bitSize :: VkXlibSurfaceCreateFlagsKHR -> Int # isSigned :: VkXlibSurfaceCreateFlagsKHR -> Bool # shiftL :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # unsafeShiftL :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # shiftR :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # unsafeShiftR :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # rotateL :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # rotateR :: VkXlibSurfaceCreateFlagsKHR -> Int -> VkXlibSurfaceCreateFlagsKHR # popCount :: VkXlibSurfaceCreateFlagsKHR -> Int #
FiniteBits VkXlibSurfaceCreateFlagsKHR Source #
Methods finiteBitSize :: VkXlibSurfaceCreateFlagsKHR -> Int # countLeadingZeros :: VkXlibSurfaceCreateFlagsKHR -> Int # countTrailingZeros :: VkXlibSurfaceCreateFlagsKHR -> Int #
type Rep VkXlibSurfaceCreateFlagsKHR Source #
type Rep VkXlibSurfaceCreateFlagsKHR = D1 (MetaData "VkXlibSurfaceCreateFlagsKHR" "Graphics.Vulkan.Types.Bitmasks" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkXlibSurfaceCreateFlagsKHR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

type VkTrimCommandPoolKHR = "vkTrimCommandPoolKHR" Source #

pattern VkTrimCommandPoolKHR :: CString Source #

type HS_vkTrimCommandPoolKHR Source #

Arguments

= VkDevice	device
-> VkCommandPool	commandPool
-> VkCommandPoolTrimFlags	flags
-> IO ()

This is an alias for vkTrimCommandPool.

void vkTrimCommandPoolKHR
    ( VkDevice device
    , VkCommandPool commandPool
    , VkCommandPoolTrimFlags flags
    )

vkTrimCommandPoolKHR registry at www.khronos.org

type PFN_vkTrimCommandPoolKHR = FunPtr HS_vkTrimCommandPoolKHR Source #

module Graphics.Vulkan.Marshal

newtype VkBool32 Source #

Constructors

VkBool32 Word32

Instances

Bounded VkBool32 Source #
Methods minBound :: VkBool32 # maxBound :: VkBool32 #
Enum VkBool32 Source #
Methods succ :: VkBool32 -> VkBool32 # pred :: VkBool32 -> VkBool32 # toEnum :: Int -> VkBool32 # fromEnum :: VkBool32 -> Int # enumFrom :: VkBool32 -> [VkBool32] # enumFromThen :: VkBool32 -> VkBool32 -> [VkBool32] # enumFromTo :: VkBool32 -> VkBool32 -> [VkBool32] # enumFromThenTo :: VkBool32 -> VkBool32 -> VkBool32 -> [VkBool32] #
Eq VkBool32 Source #
Methods (==) :: VkBool32 -> VkBool32 -> Bool # (/=) :: VkBool32 -> VkBool32 -> Bool #
Integral VkBool32 Source #
Methods quot :: VkBool32 -> VkBool32 -> VkBool32 # rem :: VkBool32 -> VkBool32 -> VkBool32 # div :: VkBool32 -> VkBool32 -> VkBool32 # mod :: VkBool32 -> VkBool32 -> VkBool32 # quotRem :: VkBool32 -> VkBool32 -> (VkBool32, VkBool32) # divMod :: VkBool32 -> VkBool32 -> (VkBool32, VkBool32) # toInteger :: VkBool32 -> Integer #
Data VkBool32 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkBool32 -> c VkBool32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkBool32 # toConstr :: VkBool32 -> Constr # dataTypeOf :: VkBool32 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkBool32) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkBool32) # gmapT :: (forall b. Data b => b -> b) -> VkBool32 -> VkBool32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkBool32 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkBool32 -> r # gmapQ :: (forall d. Data d => d -> u) -> VkBool32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkBool32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkBool32 -> m VkBool32 #
Num VkBool32 Source #
Methods (+) :: VkBool32 -> VkBool32 -> VkBool32 # (-) :: VkBool32 -> VkBool32 -> VkBool32 # (*) :: VkBool32 -> VkBool32 -> VkBool32 # negate :: VkBool32 -> VkBool32 # abs :: VkBool32 -> VkBool32 # signum :: VkBool32 -> VkBool32 # fromInteger :: Integer -> VkBool32 #
Ord VkBool32 Source #
Methods compare :: VkBool32 -> VkBool32 -> Ordering # (<) :: VkBool32 -> VkBool32 -> Bool # (<=) :: VkBool32 -> VkBool32 -> Bool # (>) :: VkBool32 -> VkBool32 -> Bool # (>=) :: VkBool32 -> VkBool32 -> Bool # max :: VkBool32 -> VkBool32 -> VkBool32 # min :: VkBool32 -> VkBool32 -> VkBool32 #
Read VkBool32 Source #
Methods readsPrec :: Int -> ReadS VkBool32 # readList :: ReadS [VkBool32] # readPrec :: ReadPrec VkBool32 # readListPrec :: ReadPrec [VkBool32] #
Real VkBool32 Source #
Methods toRational :: VkBool32 -> Rational #
Show VkBool32 Source #
Methods showsPrec :: Int -> VkBool32 -> ShowS # show :: VkBool32 -> String # showList :: [VkBool32] -> ShowS #
Generic VkBool32 Source #
Associated Types type Rep VkBool32 :: * -> * # Methods from :: VkBool32 -> Rep VkBool32 x # to :: Rep VkBool32 x -> VkBool32 #
Storable VkBool32 Source #
Methods sizeOf :: VkBool32 -> Int # alignment :: VkBool32 -> Int # peekElemOff :: Ptr VkBool32 -> Int -> IO VkBool32 # pokeElemOff :: Ptr VkBool32 -> Int -> VkBool32 -> IO () # peekByteOff :: Ptr b -> Int -> IO VkBool32 # pokeByteOff :: Ptr b -> Int -> VkBool32 -> IO () # peek :: Ptr VkBool32 -> IO VkBool32 # poke :: Ptr VkBool32 -> VkBool32 -> IO () #
Bits VkBool32 Source #
Methods (.&.) :: VkBool32 -> VkBool32 -> VkBool32 # (.\|.) :: VkBool32 -> VkBool32 -> VkBool32 # xor :: VkBool32 -> VkBool32 -> VkBool32 # complement :: VkBool32 -> VkBool32 # shift :: VkBool32 -> Int -> VkBool32 # rotate :: VkBool32 -> Int -> VkBool32 # zeroBits :: VkBool32 # bit :: Int -> VkBool32 # setBit :: VkBool32 -> Int -> VkBool32 # clearBit :: VkBool32 -> Int -> VkBool32 # complementBit :: VkBool32 -> Int -> VkBool32 # testBit :: VkBool32 -> Int -> Bool # bitSizeMaybe :: VkBool32 -> Maybe Int # bitSize :: VkBool32 -> Int # isSigned :: VkBool32 -> Bool # shiftL :: VkBool32 -> Int -> VkBool32 # unsafeShiftL :: VkBool32 -> Int -> VkBool32 # shiftR :: VkBool32 -> Int -> VkBool32 # unsafeShiftR :: VkBool32 -> Int -> VkBool32 # rotateL :: VkBool32 -> Int -> VkBool32 # rotateR :: VkBool32 -> Int -> VkBool32 # popCount :: VkBool32 -> Int #
FiniteBits VkBool32 Source #
Methods finiteBitSize :: VkBool32 -> Int # countLeadingZeros :: VkBool32 -> Int # countTrailingZeros :: VkBool32 -> Int #
type Rep VkBool32 Source #
type Rep VkBool32 = D1 (MetaData "VkBool32" "Graphics.Vulkan.Types.BaseTypes" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkBool32" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word32)))

newtype VkDeviceSize Source #

Constructors

VkDeviceSize Word64

Instances

Bounded VkDeviceSize Source #
Methods minBound :: VkDeviceSize # maxBound :: VkDeviceSize #
Enum VkDeviceSize Source #
Methods succ :: VkDeviceSize -> VkDeviceSize # pred :: VkDeviceSize -> VkDeviceSize # toEnum :: Int -> VkDeviceSize # fromEnum :: VkDeviceSize -> Int # enumFrom :: VkDeviceSize -> [VkDeviceSize] # enumFromThen :: VkDeviceSize -> VkDeviceSize -> [VkDeviceSize] # enumFromTo :: VkDeviceSize -> VkDeviceSize -> [VkDeviceSize] # enumFromThenTo :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize -> [VkDeviceSize] #
Eq VkDeviceSize Source #
Methods (==) :: VkDeviceSize -> VkDeviceSize -> Bool # (/=) :: VkDeviceSize -> VkDeviceSize -> Bool #
Integral VkDeviceSize Source #
Methods quot :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # rem :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # div :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # mod :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # quotRem :: VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize) # divMod :: VkDeviceSize -> VkDeviceSize -> (VkDeviceSize, VkDeviceSize) # toInteger :: VkDeviceSize -> Integer #
Data VkDeviceSize Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkDeviceSize -> c VkDeviceSize # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkDeviceSize # toConstr :: VkDeviceSize -> Constr # dataTypeOf :: VkDeviceSize -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkDeviceSize) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkDeviceSize) # gmapT :: (forall b. Data b => b -> b) -> VkDeviceSize -> VkDeviceSize # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkDeviceSize -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkDeviceSize -> r # gmapQ :: (forall d. Data d => d -> u) -> VkDeviceSize -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkDeviceSize -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkDeviceSize -> m VkDeviceSize #
Num VkDeviceSize Source #
Methods (+) :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # (-) :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # (*) :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # negate :: VkDeviceSize -> VkDeviceSize # abs :: VkDeviceSize -> VkDeviceSize # signum :: VkDeviceSize -> VkDeviceSize # fromInteger :: Integer -> VkDeviceSize #
Ord VkDeviceSize Source #
Methods compare :: VkDeviceSize -> VkDeviceSize -> Ordering # (<) :: VkDeviceSize -> VkDeviceSize -> Bool # (<=) :: VkDeviceSize -> VkDeviceSize -> Bool # (>) :: VkDeviceSize -> VkDeviceSize -> Bool # (>=) :: VkDeviceSize -> VkDeviceSize -> Bool # max :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # min :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize #
Read VkDeviceSize Source #
Methods readsPrec :: Int -> ReadS VkDeviceSize # readList :: ReadS [VkDeviceSize] # readPrec :: ReadPrec VkDeviceSize # readListPrec :: ReadPrec [VkDeviceSize] #
Real VkDeviceSize Source #
Methods toRational :: VkDeviceSize -> Rational #
Show VkDeviceSize Source #
Methods showsPrec :: Int -> VkDeviceSize -> ShowS # show :: VkDeviceSize -> String # showList :: [VkDeviceSize] -> ShowS #
Generic VkDeviceSize Source #
Associated Types type Rep VkDeviceSize :: * -> * # Methods from :: VkDeviceSize -> Rep VkDeviceSize x # to :: Rep VkDeviceSize x -> VkDeviceSize #
Storable VkDeviceSize Source #
Methods sizeOf :: VkDeviceSize -> Int # alignment :: VkDeviceSize -> Int # peekElemOff :: Ptr VkDeviceSize -> Int -> IO VkDeviceSize # pokeElemOff :: Ptr VkDeviceSize -> Int -> VkDeviceSize -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDeviceSize # pokeByteOff :: Ptr b -> Int -> VkDeviceSize -> IO () # peek :: Ptr VkDeviceSize -> IO VkDeviceSize # poke :: Ptr VkDeviceSize -> VkDeviceSize -> IO () #
Bits VkDeviceSize Source #
Methods (.&.) :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # (.\|.) :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # xor :: VkDeviceSize -> VkDeviceSize -> VkDeviceSize # complement :: VkDeviceSize -> VkDeviceSize # shift :: VkDeviceSize -> Int -> VkDeviceSize # rotate :: VkDeviceSize -> Int -> VkDeviceSize # zeroBits :: VkDeviceSize # bit :: Int -> VkDeviceSize # setBit :: VkDeviceSize -> Int -> VkDeviceSize # clearBit :: VkDeviceSize -> Int -> VkDeviceSize # complementBit :: VkDeviceSize -> Int -> VkDeviceSize # testBit :: VkDeviceSize -> Int -> Bool # bitSizeMaybe :: VkDeviceSize -> Maybe Int # bitSize :: VkDeviceSize -> Int # isSigned :: VkDeviceSize -> Bool # shiftL :: VkDeviceSize -> Int -> VkDeviceSize # unsafeShiftL :: VkDeviceSize -> Int -> VkDeviceSize # shiftR :: VkDeviceSize -> Int -> VkDeviceSize # unsafeShiftR :: VkDeviceSize -> Int -> VkDeviceSize # rotateL :: VkDeviceSize -> Int -> VkDeviceSize # rotateR :: VkDeviceSize -> Int -> VkDeviceSize # popCount :: VkDeviceSize -> Int #
FiniteBits VkDeviceSize Source #
Methods finiteBitSize :: VkDeviceSize -> Int # countLeadingZeros :: VkDeviceSize -> Int # countTrailingZeros :: VkDeviceSize -> Int #
type Rep VkDeviceSize Source #
type Rep VkDeviceSize = D1 (MetaData "VkDeviceSize" "Graphics.Vulkan.Types.BaseTypes" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkDeviceSize" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word64)))

newtype VkFlags Source #

Constructors

VkFlags Word32

Instances

Bounded VkFlags Source #
Methods minBound :: VkFlags # maxBound :: VkFlags #
Enum VkFlags Source #
Methods succ :: VkFlags -> VkFlags # pred :: VkFlags -> VkFlags # toEnum :: Int -> VkFlags # fromEnum :: VkFlags -> Int # enumFrom :: VkFlags -> [VkFlags] # enumFromThen :: VkFlags -> VkFlags -> [VkFlags] # enumFromTo :: VkFlags -> VkFlags -> [VkFlags] # enumFromThenTo :: VkFlags -> VkFlags -> VkFlags -> [VkFlags] #
Eq VkFlags Source #
Methods (==) :: VkFlags -> VkFlags -> Bool # (/=) :: VkFlags -> VkFlags -> Bool #
Integral VkFlags Source #
Methods quot :: VkFlags -> VkFlags -> VkFlags # rem :: VkFlags -> VkFlags -> VkFlags # div :: VkFlags -> VkFlags -> VkFlags # mod :: VkFlags -> VkFlags -> VkFlags # quotRem :: VkFlags -> VkFlags -> (VkFlags, VkFlags) # divMod :: VkFlags -> VkFlags -> (VkFlags, VkFlags) # toInteger :: VkFlags -> Integer #
Data VkFlags Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkFlags -> c VkFlags # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkFlags # toConstr :: VkFlags -> Constr # dataTypeOf :: VkFlags -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkFlags) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkFlags) # gmapT :: (forall b. Data b => b -> b) -> VkFlags -> VkFlags # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkFlags -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkFlags -> r # gmapQ :: (forall d. Data d => d -> u) -> VkFlags -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkFlags -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkFlags -> m VkFlags # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkFlags -> m VkFlags # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkFlags -> m VkFlags #
Num VkFlags Source #
Methods (+) :: VkFlags -> VkFlags -> VkFlags # (-) :: VkFlags -> VkFlags -> VkFlags # (*) :: VkFlags -> VkFlags -> VkFlags # negate :: VkFlags -> VkFlags # abs :: VkFlags -> VkFlags # signum :: VkFlags -> VkFlags # fromInteger :: Integer -> VkFlags #
Ord VkFlags Source #
Methods compare :: VkFlags -> VkFlags -> Ordering # (<) :: VkFlags -> VkFlags -> Bool # (<=) :: VkFlags -> VkFlags -> Bool # (>) :: VkFlags -> VkFlags -> Bool # (>=) :: VkFlags -> VkFlags -> Bool # max :: VkFlags -> VkFlags -> VkFlags # min :: VkFlags -> VkFlags -> VkFlags #
Read VkFlags Source #
Methods readsPrec :: Int -> ReadS VkFlags # readList :: ReadS [VkFlags] # readPrec :: ReadPrec VkFlags # readListPrec :: ReadPrec [VkFlags] #
Real VkFlags Source #
Methods toRational :: VkFlags -> Rational #
Show VkFlags Source #
Methods showsPrec :: Int -> VkFlags -> ShowS # show :: VkFlags -> String # showList :: [VkFlags] -> ShowS #
Generic VkFlags Source #
Associated Types type Rep VkFlags :: * -> * # Methods from :: VkFlags -> Rep VkFlags x # to :: Rep VkFlags x -> VkFlags #
Storable VkFlags Source #
Methods sizeOf :: VkFlags -> Int # alignment :: VkFlags -> Int # peekElemOff :: Ptr VkFlags -> Int -> IO VkFlags # pokeElemOff :: Ptr VkFlags -> Int -> VkFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkFlags # pokeByteOff :: Ptr b -> Int -> VkFlags -> IO () # peek :: Ptr VkFlags -> IO VkFlags # poke :: Ptr VkFlags -> VkFlags -> IO () #
Bits VkFlags Source #
Methods (.&.) :: VkFlags -> VkFlags -> VkFlags # (.\|.) :: VkFlags -> VkFlags -> VkFlags # xor :: VkFlags -> VkFlags -> VkFlags # complement :: VkFlags -> VkFlags # shift :: VkFlags -> Int -> VkFlags # rotate :: VkFlags -> Int -> VkFlags # zeroBits :: VkFlags # bit :: Int -> VkFlags # setBit :: VkFlags -> Int -> VkFlags # clearBit :: VkFlags -> Int -> VkFlags # complementBit :: VkFlags -> Int -> VkFlags # testBit :: VkFlags -> Int -> Bool # bitSizeMaybe :: VkFlags -> Maybe Int # bitSize :: VkFlags -> Int # isSigned :: VkFlags -> Bool # shiftL :: VkFlags -> Int -> VkFlags # unsafeShiftL :: VkFlags -> Int -> VkFlags # shiftR :: VkFlags -> Int -> VkFlags # unsafeShiftR :: VkFlags -> Int -> VkFlags # rotateL :: VkFlags -> Int -> VkFlags # rotateR :: VkFlags -> Int -> VkFlags # popCount :: VkFlags -> Int #
FiniteBits VkFlags Source #
Methods finiteBitSize :: VkFlags -> Int # countLeadingZeros :: VkFlags -> Int # countTrailingZeros :: VkFlags -> Int #
type Rep VkFlags Source #
type Rep VkFlags = D1 (MetaData "VkFlags" "Graphics.Vulkan.Types.BaseTypes" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkFlags" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word32)))

newtype VkSampleMask Source #

Constructors

VkSampleMask Word32

Instances

Bounded VkSampleMask Source #
Methods minBound :: VkSampleMask # maxBound :: VkSampleMask #
Enum VkSampleMask Source #
Methods succ :: VkSampleMask -> VkSampleMask # pred :: VkSampleMask -> VkSampleMask # toEnum :: Int -> VkSampleMask # fromEnum :: VkSampleMask -> Int # enumFrom :: VkSampleMask -> [VkSampleMask] # enumFromThen :: VkSampleMask -> VkSampleMask -> [VkSampleMask] # enumFromTo :: VkSampleMask -> VkSampleMask -> [VkSampleMask] # enumFromThenTo :: VkSampleMask -> VkSampleMask -> VkSampleMask -> [VkSampleMask] #
Eq VkSampleMask Source #
Methods (==) :: VkSampleMask -> VkSampleMask -> Bool # (/=) :: VkSampleMask -> VkSampleMask -> Bool #
Integral VkSampleMask Source #
Methods quot :: VkSampleMask -> VkSampleMask -> VkSampleMask # rem :: VkSampleMask -> VkSampleMask -> VkSampleMask # div :: VkSampleMask -> VkSampleMask -> VkSampleMask # mod :: VkSampleMask -> VkSampleMask -> VkSampleMask # quotRem :: VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask) # divMod :: VkSampleMask -> VkSampleMask -> (VkSampleMask, VkSampleMask) # toInteger :: VkSampleMask -> Integer #
Data VkSampleMask Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkSampleMask -> c VkSampleMask # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkSampleMask # toConstr :: VkSampleMask -> Constr # dataTypeOf :: VkSampleMask -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c VkSampleMask) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkSampleMask) # gmapT :: (forall b. Data b => b -> b) -> VkSampleMask -> VkSampleMask # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkSampleMask -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkSampleMask -> r # gmapQ :: (forall d. Data d => d -> u) -> VkSampleMask -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VkSampleMask -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkSampleMask -> m VkSampleMask #
Num VkSampleMask Source #
Methods (+) :: VkSampleMask -> VkSampleMask -> VkSampleMask # (-) :: VkSampleMask -> VkSampleMask -> VkSampleMask # (*) :: VkSampleMask -> VkSampleMask -> VkSampleMask # negate :: VkSampleMask -> VkSampleMask # abs :: VkSampleMask -> VkSampleMask # signum :: VkSampleMask -> VkSampleMask # fromInteger :: Integer -> VkSampleMask #
Ord VkSampleMask Source #
Methods compare :: VkSampleMask -> VkSampleMask -> Ordering # (<) :: VkSampleMask -> VkSampleMask -> Bool # (<=) :: VkSampleMask -> VkSampleMask -> Bool # (>) :: VkSampleMask -> VkSampleMask -> Bool # (>=) :: VkSampleMask -> VkSampleMask -> Bool # max :: VkSampleMask -> VkSampleMask -> VkSampleMask # min :: VkSampleMask -> VkSampleMask -> VkSampleMask #
Read VkSampleMask Source #
Methods readsPrec :: Int -> ReadS VkSampleMask # readList :: ReadS [VkSampleMask] # readPrec :: ReadPrec VkSampleMask # readListPrec :: ReadPrec [VkSampleMask] #
Real VkSampleMask Source #
Methods toRational :: VkSampleMask -> Rational #
Show VkSampleMask Source #
Methods showsPrec :: Int -> VkSampleMask -> ShowS # show :: VkSampleMask -> String # showList :: [VkSampleMask] -> ShowS #
Generic VkSampleMask Source #
Associated Types type Rep VkSampleMask :: * -> * # Methods from :: VkSampleMask -> Rep VkSampleMask x # to :: Rep VkSampleMask x -> VkSampleMask #
Storable VkSampleMask Source #
Methods sizeOf :: VkSampleMask -> Int # alignment :: VkSampleMask -> Int # peekElemOff :: Ptr VkSampleMask -> Int -> IO VkSampleMask # pokeElemOff :: Ptr VkSampleMask -> Int -> VkSampleMask -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSampleMask # pokeByteOff :: Ptr b -> Int -> VkSampleMask -> IO () # peek :: Ptr VkSampleMask -> IO VkSampleMask # poke :: Ptr VkSampleMask -> VkSampleMask -> IO () #
Bits VkSampleMask Source #
Methods (.&.) :: VkSampleMask -> VkSampleMask -> VkSampleMask # (.\|.) :: VkSampleMask -> VkSampleMask -> VkSampleMask # xor :: VkSampleMask -> VkSampleMask -> VkSampleMask # complement :: VkSampleMask -> VkSampleMask # shift :: VkSampleMask -> Int -> VkSampleMask # rotate :: VkSampleMask -> Int -> VkSampleMask # zeroBits :: VkSampleMask # bit :: Int -> VkSampleMask # setBit :: VkSampleMask -> Int -> VkSampleMask # clearBit :: VkSampleMask -> Int -> VkSampleMask # complementBit :: VkSampleMask -> Int -> VkSampleMask # testBit :: VkSampleMask -> Int -> Bool # bitSizeMaybe :: VkSampleMask -> Maybe Int # bitSize :: VkSampleMask -> Int # isSigned :: VkSampleMask -> Bool # shiftL :: VkSampleMask -> Int -> VkSampleMask # unsafeShiftL :: VkSampleMask -> Int -> VkSampleMask # shiftR :: VkSampleMask -> Int -> VkSampleMask # unsafeShiftR :: VkSampleMask -> Int -> VkSampleMask # rotateL :: VkSampleMask -> Int -> VkSampleMask # rotateR :: VkSampleMask -> Int -> VkSampleMask # popCount :: VkSampleMask -> Int #
FiniteBits VkSampleMask Source #
Methods finiteBitSize :: VkSampleMask -> Int # countLeadingZeros :: VkSampleMask -> Int # countTrailingZeros :: VkSampleMask -> Int #
type Rep VkSampleMask Source #
type Rep VkSampleMask = D1 (MetaData "VkSampleMask" "Graphics.Vulkan.Types.BaseTypes" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkSampleMask" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word32)))

type VkBuffer = VkPtr VkBuffer_T Source #

data VkBuffer_T Source #

Opaque data type referenced by VkBuffer

type VkBufferView = VkPtr VkBufferView_T Source #

data VkBufferView_T Source #

Opaque data type referenced by VkBufferView

type VkCommandBuffer = Ptr VkCommandBuffer_T Source #

data VkCommandBuffer_T Source #

Opaque data type referenced by VkCommandBuffer

type VkCommandPool = VkPtr VkCommandPool_T Source #

data VkCommandPool_T Source #

Opaque data type referenced by VkCommandPool

type VkDebugReportCallbackEXT = VkPtr VkDebugReportCallbackEXT_T Source #

data VkDebugReportCallbackEXT_T Source #

Opaque data type referenced by VkDebugReportCallbackEXT

type VkDebugUtilsMessengerEXT = VkPtr VkDebugUtilsMessengerEXT_T Source #

data VkDebugUtilsMessengerEXT_T Source #

Opaque data type referenced by VkDebugUtilsMessengerEXT

type VkDescriptorPool = VkPtr VkDescriptorPool_T Source #

data VkDescriptorPool_T Source #

Opaque data type referenced by VkDescriptorPool

type VkDescriptorSet = VkPtr VkDescriptorSet_T Source #

data VkDescriptorSet_T Source #

Opaque data type referenced by VkDescriptorSet

type VkDescriptorSetLayout = VkPtr VkDescriptorSetLayout_T Source #

data VkDescriptorSetLayout_T Source #

Opaque data type referenced by VkDescriptorSetLayout

type VkDescriptorUpdateTemplate = VkPtr VkDescriptorUpdateTemplate_T Source #

data VkDescriptorUpdateTemplate_T Source #

Opaque data type referenced by VkDescriptorUpdateTemplate

type VkDescriptorUpdateTemplateKHR = VkPtr VkDescriptorUpdateTemplateKHR_T Source #

data VkDescriptorUpdateTemplateKHR_T Source #

Opaque data type referenced by VkDescriptorUpdateTemplateKHR

type VkDevice = Ptr VkDevice_T Source #

data VkDevice_T Source #

Opaque data type referenced by VkDevice

type VkDeviceMemory = VkPtr VkDeviceMemory_T Source #

data VkDeviceMemory_T Source #

Opaque data type referenced by VkDeviceMemory

type VkDisplayKHR = VkPtr VkDisplayKHR_T Source #

data VkDisplayKHR_T Source #

Opaque data type referenced by VkDisplayKHR

type VkDisplayModeKHR = VkPtr VkDisplayModeKHR_T Source #

data VkDisplayModeKHR_T Source #

Opaque data type referenced by VkDisplayModeKHR

type VkEvent = VkPtr VkEvent_T Source #

data VkEvent_T Source #

Opaque data type referenced by VkEvent

type VkFence = VkPtr VkFence_T Source #

data VkFence_T Source #

Opaque data type referenced by VkFence

type VkFramebuffer = VkPtr VkFramebuffer_T Source #

data VkFramebuffer_T Source #

Opaque data type referenced by VkFramebuffer

type VkImage = VkPtr VkImage_T Source #

data VkImage_T Source #

Opaque data type referenced by VkImage

type VkImageView = VkPtr VkImageView_T Source #

data VkImageView_T Source #

Opaque data type referenced by VkImageView

type VkIndirectCommandsLayoutNVX = VkPtr VkIndirectCommandsLayoutNVX_T Source #

data VkIndirectCommandsLayoutNVX_T Source #

Opaque data type referenced by VkIndirectCommandsLayoutNVX

type VkInstance = Ptr VkInstance_T Source #

data VkInstance_T Source #

Opaque data type referenced by VkInstance

type VkObjectTableNVX = VkPtr VkObjectTableNVX_T Source #

data VkObjectTableNVX_T Source #

Opaque data type referenced by VkObjectTableNVX

type VkPhysicalDevice = Ptr VkPhysicalDevice_T Source #

data VkPhysicalDevice_T Source #

Opaque data type referenced by VkPhysicalDevice

type VkPipeline = VkPtr VkPipeline_T Source #

data VkPipeline_T Source #

Opaque data type referenced by VkPipeline

type VkPipelineCache = VkPtr VkPipelineCache_T Source #

data VkPipelineCache_T Source #

Opaque data type referenced by VkPipelineCache

type VkPipelineLayout = VkPtr VkPipelineLayout_T Source #

data VkPipelineLayout_T Source #

Opaque data type referenced by VkPipelineLayout

type VkQueryPool = VkPtr VkQueryPool_T Source #

data VkQueryPool_T Source #

Opaque data type referenced by VkQueryPool

type VkQueue = Ptr VkQueue_T Source #

data VkQueue_T Source #

Opaque data type referenced by VkQueue

type VkRenderPass = VkPtr VkRenderPass_T Source #

data VkRenderPass_T Source #

Opaque data type referenced by VkRenderPass

type VkSampler = VkPtr VkSampler_T Source #

data VkSampler_T Source #

Opaque data type referenced by VkSampler

type VkSamplerYcbcrConversion = VkPtr VkSamplerYcbcrConversion_T Source #

data VkSamplerYcbcrConversion_T Source #

Opaque data type referenced by VkSamplerYcbcrConversion

type VkSamplerYcbcrConversionKHR = VkPtr VkSamplerYcbcrConversionKHR_T Source #

data VkSamplerYcbcrConversionKHR_T Source #

Opaque data type referenced by VkSamplerYcbcrConversionKHR

type VkSemaphore = VkPtr VkSemaphore_T Source #

data VkSemaphore_T Source #

Opaque data type referenced by VkSemaphore

type VkShaderModule = VkPtr VkShaderModule_T Source #

data VkShaderModule_T Source #

Opaque data type referenced by VkShaderModule

type VkSurfaceKHR = VkPtr VkSurfaceKHR_T Source #

data VkSurfaceKHR_T Source #

Opaque data type referenced by VkSurfaceKHR

type VkSwapchainKHR = VkPtr VkSwapchainKHR_T Source #

data VkSwapchainKHR_T Source #

Opaque data type referenced by VkSwapchainKHR

type VkValidationCacheEXT = VkPtr VkValidationCacheEXT_T Source #

data VkValidationCacheEXT_T Source #

Opaque data type referenced by VkValidationCacheEXT

type VK_KHR_MAINTENANCE1_SPEC_VERSION = 2 Source #

pattern VK_KHR_MAINTENANCE1_SPEC_VERSION :: forall a. (Num a, Eq a) => a Source #

type VK_KHR_MAINTENANCE1_EXTENSION_NAME = "VK_KHR_maintenance1" Source #

pattern VK_KHR_MAINTENANCE1_EXTENSION_NAME :: CString Source #

pattern VK_ERROR_OUT_OF_POOL_MEMORY_KHR :: VkResult Source #

pattern VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR :: VkFormatFeatureFlagBits Source #

pattern VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR :: VkFormatFeatureFlagBits Source #

pattern VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR :: VkImageCreateFlagBits Source #

Orphan instances

VulkanProc "vkTrimCommandPoolKHR" Source #
Associated Types type VkProcType ("vkTrimCommandPoolKHR" :: Symbol) :: * Source # Methods vkProcSymbol :: CString Source # unwrapVkProcPtrUnsafe :: FunPtr (VkProcType "vkTrimCommandPoolKHR") -> VkProcType "vkTrimCommandPoolKHR" Source # unwrapVkProcPtrSafe :: FunPtr (VkProcType "vkTrimCommandPoolKHR") -> VkProcType "vkTrimCommandPoolKHR" Source #

Vulkan extension: VK_KHR_maintenance1

Orphan instances

Vulkan extension: `VK_KHR_maintenance1`