vulkan-api-1.1.3.0: Low-level low-overhead vulkan api bindings

Safe HaskellNone
LanguageHaskell2010

Graphics.Vulkan.Ext.VK_NV_fragment_coverage_to_color

Contents

Synopsis

Vulkan extension: VK_NV_fragment_coverage_to_color

supported: vulkan

contact: Jeff Bolz jeffbolznv@

author: NV

type: device

Extension number: 150

newtype VkBool32 Source #

Constructors

VkBool32 Word32 

Instances

Bounded VkBool32 Source # 
Enum VkBool32 Source # 
Eq VkBool32 Source # 
Integral VkBool32 Source # 
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 # 
Ord VkBool32 Source # 
Read VkBool32 Source # 
Real VkBool32 Source # 
Show VkBool32 Source # 
Generic VkBool32 Source # 

Associated Types

type Rep VkBool32 :: * -> * #

Methods

from :: VkBool32 -> Rep VkBool32 x #

to :: Rep VkBool32 x -> VkBool32 #

Storable VkBool32 Source # 
Bits VkBool32 Source # 
FiniteBits VkBool32 Source # 
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 # 
Enum VkDeviceSize Source # 
Eq VkDeviceSize Source # 
Integral VkDeviceSize Source # 
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 # 
Ord VkDeviceSize Source # 
Read VkDeviceSize Source # 
Real VkDeviceSize Source # 
Show VkDeviceSize Source # 
Generic VkDeviceSize Source # 

Associated Types

type Rep VkDeviceSize :: * -> * #

Storable VkDeviceSize Source # 
Bits VkDeviceSize Source # 
FiniteBits VkDeviceSize Source # 
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 # 
Enum VkFlags Source # 
Eq VkFlags Source # 

Methods

(==) :: VkFlags -> VkFlags -> Bool #

(/=) :: VkFlags -> VkFlags -> Bool #

Integral VkFlags Source # 
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 # 
Ord VkFlags Source # 
Read VkFlags Source # 
Real VkFlags Source # 
Show VkFlags Source # 
Generic VkFlags Source # 

Associated Types

type Rep VkFlags :: * -> * #

Methods

from :: VkFlags -> Rep VkFlags x #

to :: Rep VkFlags x -> VkFlags #

Storable VkFlags Source # 
Bits VkFlags Source # 
FiniteBits VkFlags Source # 
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 # 
Enum VkSampleMask Source # 
Eq VkSampleMask Source # 
Integral VkSampleMask Source # 
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 # 
Ord VkSampleMask Source # 
Read VkSampleMask Source # 
Real VkSampleMask Source # 
Show VkSampleMask Source # 
Generic VkSampleMask Source # 

Associated Types

type Rep VkSampleMask :: * -> * #

Storable VkSampleMask Source # 
Bits VkSampleMask Source # 
FiniteBits VkSampleMask Source # 
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)))

newtype VkAndroidSurfaceCreateFlagsKHR Source #

Instances

Bounded VkAndroidSurfaceCreateFlagsKHR Source # 
Enum VkAndroidSurfaceCreateFlagsKHR Source # 
Eq VkAndroidSurfaceCreateFlagsKHR Source # 
Integral VkAndroidSurfaceCreateFlagsKHR Source # 
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 # 
Ord VkAndroidSurfaceCreateFlagsKHR Source # 
Read VkAndroidSurfaceCreateFlagsKHR Source # 
Real VkAndroidSurfaceCreateFlagsKHR Source # 
Show VkAndroidSurfaceCreateFlagsKHR Source # 
Generic VkAndroidSurfaceCreateFlagsKHR Source # 
Storable VkAndroidSurfaceCreateFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkBufferViewCreateFlags Source # 
Enum VkBufferViewCreateFlags Source # 
Eq VkBufferViewCreateFlags Source # 
Integral VkBufferViewCreateFlags Source # 
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 # 
Ord VkBufferViewCreateFlags Source # 
Read VkBufferViewCreateFlags Source # 
Real VkBufferViewCreateFlags Source # 
Show VkBufferViewCreateFlags Source # 
Generic VkBufferViewCreateFlags Source # 
Storable VkBufferViewCreateFlags Source # 
Bits VkBufferViewCreateFlags Source # 
FiniteBits VkBufferViewCreateFlags Source # 
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 #

Instances

Bounded VkCommandPoolTrimFlags Source # 
Enum VkCommandPoolTrimFlags Source # 
Eq VkCommandPoolTrimFlags Source # 
Integral VkCommandPoolTrimFlags Source # 
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 # 
Ord VkCommandPoolTrimFlags Source # 
Read VkCommandPoolTrimFlags Source # 
Real VkCommandPoolTrimFlags Source # 
Show VkCommandPoolTrimFlags Source # 
Generic VkCommandPoolTrimFlags Source # 
Storable VkCommandPoolTrimFlags Source # 
Bits VkCommandPoolTrimFlags Source # 
FiniteBits VkCommandPoolTrimFlags Source # 
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 #

Instances

Bounded VkCommandPoolTrimFlagsKHR Source # 
Enum VkCommandPoolTrimFlagsKHR Source # 
Eq VkCommandPoolTrimFlagsKHR Source # 
Integral VkCommandPoolTrimFlagsKHR Source # 
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 # 
Ord VkCommandPoolTrimFlagsKHR Source # 
Read VkCommandPoolTrimFlagsKHR Source # 
Real VkCommandPoolTrimFlagsKHR Source # 
Show VkCommandPoolTrimFlagsKHR Source # 
Generic VkCommandPoolTrimFlagsKHR Source # 
Storable VkCommandPoolTrimFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkDebugUtilsMessengerCallbackDataFlagsEXT Source # 
Enum VkDebugUtilsMessengerCallbackDataFlagsEXT Source # 
Eq VkDebugUtilsMessengerCallbackDataFlagsEXT Source # 
Integral VkDebugUtilsMessengerCallbackDataFlagsEXT Source # 
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 # 
Ord VkDebugUtilsMessengerCallbackDataFlagsEXT Source # 
Read VkDebugUtilsMessengerCallbackDataFlagsEXT Source # 
Real VkDebugUtilsMessengerCallbackDataFlagsEXT Source # 
Show VkDebugUtilsMessengerCallbackDataFlagsEXT Source # 
Generic VkDebugUtilsMessengerCallbackDataFlagsEXT Source # 
Storable VkDebugUtilsMessengerCallbackDataFlagsEXT Source # 
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 # 
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 #

Instances

Bounded VkDebugUtilsMessengerCreateFlagsEXT Source # 
Enum VkDebugUtilsMessengerCreateFlagsEXT Source # 
Eq VkDebugUtilsMessengerCreateFlagsEXT Source # 
Integral VkDebugUtilsMessengerCreateFlagsEXT Source # 
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 # 
Ord VkDebugUtilsMessengerCreateFlagsEXT Source # 
Read VkDebugUtilsMessengerCreateFlagsEXT Source # 
Real VkDebugUtilsMessengerCreateFlagsEXT Source # 
Show VkDebugUtilsMessengerCreateFlagsEXT Source # 
Generic VkDebugUtilsMessengerCreateFlagsEXT Source # 
Storable VkDebugUtilsMessengerCreateFlagsEXT Source # 
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 # 
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 #

Instances

Bounded VkDescriptorPoolResetFlags Source # 
Enum VkDescriptorPoolResetFlags Source # 
Eq VkDescriptorPoolResetFlags Source # 
Integral VkDescriptorPoolResetFlags Source # 
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 # 
Ord VkDescriptorPoolResetFlags Source # 
Read VkDescriptorPoolResetFlags Source # 
Real VkDescriptorPoolResetFlags Source # 
Show VkDescriptorPoolResetFlags Source # 
Generic VkDescriptorPoolResetFlags Source # 
Storable VkDescriptorPoolResetFlags Source # 
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 # 
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 #

Instances

Bounded VkDescriptorUpdateTemplateCreateFlags Source # 
Enum VkDescriptorUpdateTemplateCreateFlags Source # 
Eq VkDescriptorUpdateTemplateCreateFlags Source # 
Integral VkDescriptorUpdateTemplateCreateFlags Source # 
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 # 
Ord VkDescriptorUpdateTemplateCreateFlags Source # 
Read VkDescriptorUpdateTemplateCreateFlags Source # 
Real VkDescriptorUpdateTemplateCreateFlags Source # 
Show VkDescriptorUpdateTemplateCreateFlags Source # 
Generic VkDescriptorUpdateTemplateCreateFlags Source # 
Storable VkDescriptorUpdateTemplateCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkDescriptorUpdateTemplateCreateFlagsKHR Source # 
Enum VkDescriptorUpdateTemplateCreateFlagsKHR Source # 
Eq VkDescriptorUpdateTemplateCreateFlagsKHR Source # 
Integral VkDescriptorUpdateTemplateCreateFlagsKHR Source # 
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 # 
Ord VkDescriptorUpdateTemplateCreateFlagsKHR Source # 
Read VkDescriptorUpdateTemplateCreateFlagsKHR Source # 
Real VkDescriptorUpdateTemplateCreateFlagsKHR Source # 
Show VkDescriptorUpdateTemplateCreateFlagsKHR Source # 
Generic VkDescriptorUpdateTemplateCreateFlagsKHR Source # 
Storable VkDescriptorUpdateTemplateCreateFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkDeviceCreateFlags Source # 
Enum VkDeviceCreateFlags Source # 
Eq VkDeviceCreateFlags Source # 
Integral VkDeviceCreateFlags Source # 
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 # 
Ord VkDeviceCreateFlags Source # 
Read VkDeviceCreateFlags Source # 
Real VkDeviceCreateFlags Source # 
Show VkDeviceCreateFlags Source # 
Generic VkDeviceCreateFlags Source # 
Storable VkDeviceCreateFlags Source # 
Bits VkDeviceCreateFlags Source # 
FiniteBits VkDeviceCreateFlags Source # 
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 #

Instances

Bounded VkDisplayModeCreateFlagsKHR Source # 
Enum VkDisplayModeCreateFlagsKHR Source # 
Eq VkDisplayModeCreateFlagsKHR Source # 
Integral VkDisplayModeCreateFlagsKHR Source # 
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 # 
Ord VkDisplayModeCreateFlagsKHR Source # 
Read VkDisplayModeCreateFlagsKHR Source # 
Real VkDisplayModeCreateFlagsKHR Source # 
Show VkDisplayModeCreateFlagsKHR Source # 
Generic VkDisplayModeCreateFlagsKHR Source # 
Storable VkDisplayModeCreateFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkDisplaySurfaceCreateFlagsKHR Source # 
Enum VkDisplaySurfaceCreateFlagsKHR Source # 
Eq VkDisplaySurfaceCreateFlagsKHR Source # 
Integral VkDisplaySurfaceCreateFlagsKHR Source # 
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 # 
Ord VkDisplaySurfaceCreateFlagsKHR Source # 
Read VkDisplaySurfaceCreateFlagsKHR Source # 
Real VkDisplaySurfaceCreateFlagsKHR Source # 
Show VkDisplaySurfaceCreateFlagsKHR Source # 
Generic VkDisplaySurfaceCreateFlagsKHR Source # 
Storable VkDisplaySurfaceCreateFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkEventCreateFlags Source # 
Enum VkEventCreateFlags Source # 
Eq VkEventCreateFlags Source # 
Integral VkEventCreateFlags Source # 
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 # 
Ord VkEventCreateFlags Source # 
Read VkEventCreateFlags Source # 
Real VkEventCreateFlags Source # 
Show VkEventCreateFlags Source # 
Generic VkEventCreateFlags Source # 
Storable VkEventCreateFlags Source # 
Bits VkEventCreateFlags Source # 
FiniteBits VkEventCreateFlags Source # 
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 #

Instances

Bounded VkExternalFenceFeatureFlagsKHR Source # 
Enum VkExternalFenceFeatureFlagsKHR Source # 
Eq VkExternalFenceFeatureFlagsKHR Source # 
Integral VkExternalFenceFeatureFlagsKHR Source # 
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 # 
Ord VkExternalFenceFeatureFlagsKHR Source # 
Read VkExternalFenceFeatureFlagsKHR Source # 
Real VkExternalFenceFeatureFlagsKHR Source # 
Show VkExternalFenceFeatureFlagsKHR Source # 
Generic VkExternalFenceFeatureFlagsKHR Source # 
Storable VkExternalFenceFeatureFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkExternalFenceHandleTypeFlagsKHR Source # 
Enum VkExternalFenceHandleTypeFlagsKHR Source # 
Eq VkExternalFenceHandleTypeFlagsKHR Source # 
Integral VkExternalFenceHandleTypeFlagsKHR Source # 
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 # 
Ord VkExternalFenceHandleTypeFlagsKHR Source # 
Read VkExternalFenceHandleTypeFlagsKHR Source # 
Real VkExternalFenceHandleTypeFlagsKHR Source # 
Show VkExternalFenceHandleTypeFlagsKHR Source # 
Generic VkExternalFenceHandleTypeFlagsKHR Source # 
Storable VkExternalFenceHandleTypeFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkExternalMemoryFeatureFlagsKHR Source # 
Enum VkExternalMemoryFeatureFlagsKHR Source # 
Eq VkExternalMemoryFeatureFlagsKHR Source # 
Integral VkExternalMemoryFeatureFlagsKHR Source # 
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 # 
Ord VkExternalMemoryFeatureFlagsKHR Source # 
Read VkExternalMemoryFeatureFlagsKHR Source # 
Real VkExternalMemoryFeatureFlagsKHR Source # 
Show VkExternalMemoryFeatureFlagsKHR Source # 
Generic VkExternalMemoryFeatureFlagsKHR Source # 
Storable VkExternalMemoryFeatureFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkExternalMemoryHandleTypeFlagsKHR Source # 
Enum VkExternalMemoryHandleTypeFlagsKHR Source # 
Eq VkExternalMemoryHandleTypeFlagsKHR Source # 
Integral VkExternalMemoryHandleTypeFlagsKHR Source # 
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 # 
Ord VkExternalMemoryHandleTypeFlagsKHR Source # 
Read VkExternalMemoryHandleTypeFlagsKHR Source # 
Real VkExternalMemoryHandleTypeFlagsKHR Source # 
Show VkExternalMemoryHandleTypeFlagsKHR Source # 
Generic VkExternalMemoryHandleTypeFlagsKHR Source # 
Storable VkExternalMemoryHandleTypeFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkExternalSemaphoreFeatureFlagsKHR Source # 
Enum VkExternalSemaphoreFeatureFlagsKHR Source # 
Eq VkExternalSemaphoreFeatureFlagsKHR Source # 
Integral VkExternalSemaphoreFeatureFlagsKHR Source # 
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 # 
Ord VkExternalSemaphoreFeatureFlagsKHR Source # 
Read VkExternalSemaphoreFeatureFlagsKHR Source # 
Real VkExternalSemaphoreFeatureFlagsKHR Source # 
Show VkExternalSemaphoreFeatureFlagsKHR Source # 
Generic VkExternalSemaphoreFeatureFlagsKHR Source # 
Storable VkExternalSemaphoreFeatureFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkExternalSemaphoreHandleTypeFlagsKHR Source # 
Enum VkExternalSemaphoreHandleTypeFlagsKHR Source # 
Eq VkExternalSemaphoreHandleTypeFlagsKHR Source # 
Integral VkExternalSemaphoreHandleTypeFlagsKHR Source # 
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 # 
Ord VkExternalSemaphoreHandleTypeFlagsKHR Source # 
Read VkExternalSemaphoreHandleTypeFlagsKHR Source # 
Real VkExternalSemaphoreHandleTypeFlagsKHR Source # 
Show VkExternalSemaphoreHandleTypeFlagsKHR Source # 
Generic VkExternalSemaphoreHandleTypeFlagsKHR Source # 
Storable VkExternalSemaphoreHandleTypeFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkFenceImportFlagsKHR Source # 
Enum VkFenceImportFlagsKHR Source # 
Eq VkFenceImportFlagsKHR Source # 
Integral VkFenceImportFlagsKHR Source # 
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 # 
Ord VkFenceImportFlagsKHR Source # 
Read VkFenceImportFlagsKHR Source # 
Real VkFenceImportFlagsKHR Source # 
Show VkFenceImportFlagsKHR Source # 
Generic VkFenceImportFlagsKHR Source # 
Storable VkFenceImportFlagsKHR Source # 
Bits VkFenceImportFlagsKHR Source # 
FiniteBits VkFenceImportFlagsKHR Source # 
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 #

Instances

Bounded VkFramebufferCreateFlags Source # 
Enum VkFramebufferCreateFlags Source # 
Eq VkFramebufferCreateFlags Source # 
Integral VkFramebufferCreateFlags Source # 
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 # 
Ord VkFramebufferCreateFlags Source # 
Read VkFramebufferCreateFlags Source # 
Real VkFramebufferCreateFlags Source # 
Show VkFramebufferCreateFlags Source # 
Generic VkFramebufferCreateFlags Source # 
Storable VkFramebufferCreateFlags Source # 
Bits VkFramebufferCreateFlags Source # 
FiniteBits VkFramebufferCreateFlags Source # 
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 #

Instances

Bounded VkIOSSurfaceCreateFlagsMVK Source # 
Enum VkIOSSurfaceCreateFlagsMVK Source # 
Eq VkIOSSurfaceCreateFlagsMVK Source # 
Integral VkIOSSurfaceCreateFlagsMVK Source # 
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 # 
Ord VkIOSSurfaceCreateFlagsMVK Source # 
Read VkIOSSurfaceCreateFlagsMVK Source # 
Real VkIOSSurfaceCreateFlagsMVK Source # 
Show VkIOSSurfaceCreateFlagsMVK Source # 
Generic VkIOSSurfaceCreateFlagsMVK Source # 
Storable VkIOSSurfaceCreateFlagsMVK Source # 
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 # 
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 #

Instances

Bounded VkImageViewCreateFlags Source # 
Enum VkImageViewCreateFlags Source # 
Eq VkImageViewCreateFlags Source # 
Integral VkImageViewCreateFlags Source # 
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 # 
Ord VkImageViewCreateFlags Source # 
Read VkImageViewCreateFlags Source # 
Real VkImageViewCreateFlags Source # 
Show VkImageViewCreateFlags Source # 
Generic VkImageViewCreateFlags Source # 
Storable VkImageViewCreateFlags Source # 
Bits VkImageViewCreateFlags Source # 
FiniteBits VkImageViewCreateFlags Source # 
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 #

Instances

Bounded VkInstanceCreateFlags Source # 
Enum VkInstanceCreateFlags Source # 
Eq VkInstanceCreateFlags Source # 
Integral VkInstanceCreateFlags Source # 
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 # 
Ord VkInstanceCreateFlags Source # 
Read VkInstanceCreateFlags Source # 
Real VkInstanceCreateFlags Source # 
Show VkInstanceCreateFlags Source # 
Generic VkInstanceCreateFlags Source # 
Storable VkInstanceCreateFlags Source # 
Bits VkInstanceCreateFlags Source # 
FiniteBits VkInstanceCreateFlags Source # 
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 #

Instances

Bounded VkMacOSSurfaceCreateFlagsMVK Source # 
Enum VkMacOSSurfaceCreateFlagsMVK Source # 
Eq VkMacOSSurfaceCreateFlagsMVK Source # 
Integral VkMacOSSurfaceCreateFlagsMVK Source # 
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 # 
Ord VkMacOSSurfaceCreateFlagsMVK Source # 
Read VkMacOSSurfaceCreateFlagsMVK Source # 
Real VkMacOSSurfaceCreateFlagsMVK Source # 
Show VkMacOSSurfaceCreateFlagsMVK Source # 
Generic VkMacOSSurfaceCreateFlagsMVK Source # 
Storable VkMacOSSurfaceCreateFlagsMVK Source # 
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 # 
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 #

Instances

Bounded VkMemoryAllocateFlagsKHR Source # 
Enum VkMemoryAllocateFlagsKHR Source # 
Eq VkMemoryAllocateFlagsKHR Source # 
Integral VkMemoryAllocateFlagsKHR Source # 
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 # 
Ord VkMemoryAllocateFlagsKHR Source # 
Read VkMemoryAllocateFlagsKHR Source # 
Real VkMemoryAllocateFlagsKHR Source # 
Show VkMemoryAllocateFlagsKHR Source # 
Generic VkMemoryAllocateFlagsKHR Source # 
Storable VkMemoryAllocateFlagsKHR Source # 
Bits VkMemoryAllocateFlagsKHR Source # 
FiniteBits VkMemoryAllocateFlagsKHR Source # 
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 #

Instances

Bounded VkMemoryMapFlags Source # 
Enum VkMemoryMapFlags Source # 
Eq VkMemoryMapFlags Source # 
Integral VkMemoryMapFlags Source # 
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 # 
Ord VkMemoryMapFlags Source # 
Read VkMemoryMapFlags Source # 
Real VkMemoryMapFlags Source # 
Show VkMemoryMapFlags Source # 
Generic VkMemoryMapFlags Source # 
Storable VkMemoryMapFlags Source # 
Bits VkMemoryMapFlags Source # 
FiniteBits VkMemoryMapFlags Source # 
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 #

Instances

Bounded VkMirSurfaceCreateFlagsKHR Source # 
Enum VkMirSurfaceCreateFlagsKHR Source # 
Eq VkMirSurfaceCreateFlagsKHR Source # 
Integral VkMirSurfaceCreateFlagsKHR Source # 
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 # 
Ord VkMirSurfaceCreateFlagsKHR Source # 
Read VkMirSurfaceCreateFlagsKHR Source # 
Real VkMirSurfaceCreateFlagsKHR Source # 
Show VkMirSurfaceCreateFlagsKHR Source # 
Generic VkMirSurfaceCreateFlagsKHR Source # 
Storable VkMirSurfaceCreateFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkPeerMemoryFeatureFlagsKHR Source # 
Enum VkPeerMemoryFeatureFlagsKHR Source # 
Eq VkPeerMemoryFeatureFlagsKHR Source # 
Integral VkPeerMemoryFeatureFlagsKHR Source # 
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 # 
Ord VkPeerMemoryFeatureFlagsKHR Source # 
Read VkPeerMemoryFeatureFlagsKHR Source # 
Real VkPeerMemoryFeatureFlagsKHR Source # 
Show VkPeerMemoryFeatureFlagsKHR Source # 
Generic VkPeerMemoryFeatureFlagsKHR Source # 
Storable VkPeerMemoryFeatureFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkPipelineCacheCreateFlags Source # 
Enum VkPipelineCacheCreateFlags Source # 
Eq VkPipelineCacheCreateFlags Source # 
Integral VkPipelineCacheCreateFlags Source # 
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 # 
Ord VkPipelineCacheCreateFlags Source # 
Read VkPipelineCacheCreateFlags Source # 
Real VkPipelineCacheCreateFlags Source # 
Show VkPipelineCacheCreateFlags Source # 
Generic VkPipelineCacheCreateFlags Source # 
Storable VkPipelineCacheCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineColorBlendStateCreateFlags Source # 
Enum VkPipelineColorBlendStateCreateFlags Source # 
Eq VkPipelineColorBlendStateCreateFlags Source # 
Integral VkPipelineColorBlendStateCreateFlags Source # 
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 # 
Ord VkPipelineColorBlendStateCreateFlags Source # 
Read VkPipelineColorBlendStateCreateFlags Source # 
Real VkPipelineColorBlendStateCreateFlags Source # 
Show VkPipelineColorBlendStateCreateFlags Source # 
Generic VkPipelineColorBlendStateCreateFlags Source # 
Storable VkPipelineColorBlendStateCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineCoverageModulationStateCreateFlagsNV Source # 
Enum VkPipelineCoverageModulationStateCreateFlagsNV Source # 
Eq VkPipelineCoverageModulationStateCreateFlagsNV Source # 
Integral VkPipelineCoverageModulationStateCreateFlagsNV Source # 
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 # 
Ord VkPipelineCoverageModulationStateCreateFlagsNV Source # 
Read VkPipelineCoverageModulationStateCreateFlagsNV Source # 
Real VkPipelineCoverageModulationStateCreateFlagsNV Source # 
Show VkPipelineCoverageModulationStateCreateFlagsNV Source # 
Generic VkPipelineCoverageModulationStateCreateFlagsNV Source # 
Storable VkPipelineCoverageModulationStateCreateFlagsNV Source # 
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 # 
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 #

Instances

Bounded VkPipelineCoverageToColorStateCreateFlagsNV Source # 
Enum VkPipelineCoverageToColorStateCreateFlagsNV Source # 
Eq VkPipelineCoverageToColorStateCreateFlagsNV Source # 
Integral VkPipelineCoverageToColorStateCreateFlagsNV Source # 
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 # 
Ord VkPipelineCoverageToColorStateCreateFlagsNV Source # 
Read VkPipelineCoverageToColorStateCreateFlagsNV Source # 
Real VkPipelineCoverageToColorStateCreateFlagsNV Source # 
Show VkPipelineCoverageToColorStateCreateFlagsNV Source # 
Generic VkPipelineCoverageToColorStateCreateFlagsNV Source # 
Storable VkPipelineCoverageToColorStateCreateFlagsNV Source # 
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 # 
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 #

Instances

Bounded VkPipelineDepthStencilStateCreateFlags Source # 
Enum VkPipelineDepthStencilStateCreateFlags Source # 
Eq VkPipelineDepthStencilStateCreateFlags Source # 
Integral VkPipelineDepthStencilStateCreateFlags Source # 
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 # 
Ord VkPipelineDepthStencilStateCreateFlags Source # 
Read VkPipelineDepthStencilStateCreateFlags Source # 
Real VkPipelineDepthStencilStateCreateFlags Source # 
Show VkPipelineDepthStencilStateCreateFlags Source # 
Generic VkPipelineDepthStencilStateCreateFlags Source # 
Storable VkPipelineDepthStencilStateCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineDiscardRectangleStateCreateFlagsEXT Source # 
Enum VkPipelineDiscardRectangleStateCreateFlagsEXT Source # 
Eq VkPipelineDiscardRectangleStateCreateFlagsEXT Source # 
Integral VkPipelineDiscardRectangleStateCreateFlagsEXT Source # 
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 # 
Ord VkPipelineDiscardRectangleStateCreateFlagsEXT Source # 
Read VkPipelineDiscardRectangleStateCreateFlagsEXT Source # 
Real VkPipelineDiscardRectangleStateCreateFlagsEXT Source # 
Show VkPipelineDiscardRectangleStateCreateFlagsEXT Source # 
Generic VkPipelineDiscardRectangleStateCreateFlagsEXT Source # 
Storable VkPipelineDiscardRectangleStateCreateFlagsEXT Source # 
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 # 
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 #

Instances

Bounded VkPipelineDynamicStateCreateFlags Source # 
Enum VkPipelineDynamicStateCreateFlags Source # 
Eq VkPipelineDynamicStateCreateFlags Source # 
Integral VkPipelineDynamicStateCreateFlags Source # 
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 # 
Ord VkPipelineDynamicStateCreateFlags Source # 
Read VkPipelineDynamicStateCreateFlags Source # 
Real VkPipelineDynamicStateCreateFlags Source # 
Show VkPipelineDynamicStateCreateFlags Source # 
Generic VkPipelineDynamicStateCreateFlags Source # 
Storable VkPipelineDynamicStateCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineInputAssemblyStateCreateFlags Source # 
Enum VkPipelineInputAssemblyStateCreateFlags Source # 
Eq VkPipelineInputAssemblyStateCreateFlags Source # 
Integral VkPipelineInputAssemblyStateCreateFlags Source # 
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 # 
Ord VkPipelineInputAssemblyStateCreateFlags Source # 
Read VkPipelineInputAssemblyStateCreateFlags Source # 
Real VkPipelineInputAssemblyStateCreateFlags Source # 
Show VkPipelineInputAssemblyStateCreateFlags Source # 
Generic VkPipelineInputAssemblyStateCreateFlags Source # 
Storable VkPipelineInputAssemblyStateCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineLayoutCreateFlags Source # 
Enum VkPipelineLayoutCreateFlags Source # 
Eq VkPipelineLayoutCreateFlags Source # 
Integral VkPipelineLayoutCreateFlags Source # 
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 # 
Ord VkPipelineLayoutCreateFlags Source # 
Read VkPipelineLayoutCreateFlags Source # 
Real VkPipelineLayoutCreateFlags Source # 
Show VkPipelineLayoutCreateFlags Source # 
Generic VkPipelineLayoutCreateFlags Source # 
Storable VkPipelineLayoutCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineMultisampleStateCreateFlags Source # 
Enum VkPipelineMultisampleStateCreateFlags Source # 
Eq VkPipelineMultisampleStateCreateFlags Source # 
Integral VkPipelineMultisampleStateCreateFlags Source # 
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 # 
Ord VkPipelineMultisampleStateCreateFlags Source # 
Read VkPipelineMultisampleStateCreateFlags Source # 
Real VkPipelineMultisampleStateCreateFlags Source # 
Show VkPipelineMultisampleStateCreateFlags Source # 
Generic VkPipelineMultisampleStateCreateFlags Source # 
Storable VkPipelineMultisampleStateCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineRasterizationConservativeStateCreateFlagsEXT Source # 
Enum VkPipelineRasterizationConservativeStateCreateFlagsEXT Source # 
Eq VkPipelineRasterizationConservativeStateCreateFlagsEXT Source # 
Integral VkPipelineRasterizationConservativeStateCreateFlagsEXT Source # 
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 # 
Ord VkPipelineRasterizationConservativeStateCreateFlagsEXT Source # 
Read VkPipelineRasterizationConservativeStateCreateFlagsEXT Source # 
Real VkPipelineRasterizationConservativeStateCreateFlagsEXT Source # 
Show VkPipelineRasterizationConservativeStateCreateFlagsEXT Source # 
Generic VkPipelineRasterizationConservativeStateCreateFlagsEXT Source # 
Storable VkPipelineRasterizationConservativeStateCreateFlagsEXT Source # 
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 # 
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 #

Instances

Bounded VkPipelineRasterizationStateCreateFlags Source # 
Enum VkPipelineRasterizationStateCreateFlags Source # 
Eq VkPipelineRasterizationStateCreateFlags Source # 
Integral VkPipelineRasterizationStateCreateFlags Source # 
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 # 
Ord VkPipelineRasterizationStateCreateFlags Source # 
Read VkPipelineRasterizationStateCreateFlags Source # 
Real VkPipelineRasterizationStateCreateFlags Source # 
Show VkPipelineRasterizationStateCreateFlags Source # 
Generic VkPipelineRasterizationStateCreateFlags Source # 
Storable VkPipelineRasterizationStateCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineShaderStageCreateFlags Source # 
Enum VkPipelineShaderStageCreateFlags Source # 
Eq VkPipelineShaderStageCreateFlags Source # 
Integral VkPipelineShaderStageCreateFlags Source # 
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 # 
Ord VkPipelineShaderStageCreateFlags Source # 
Read VkPipelineShaderStageCreateFlags Source # 
Real VkPipelineShaderStageCreateFlags Source # 
Show VkPipelineShaderStageCreateFlags Source # 
Generic VkPipelineShaderStageCreateFlags Source # 
Storable VkPipelineShaderStageCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineTessellationStateCreateFlags Source # 
Enum VkPipelineTessellationStateCreateFlags Source # 
Eq VkPipelineTessellationStateCreateFlags Source # 
Integral VkPipelineTessellationStateCreateFlags Source # 
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 # 
Ord VkPipelineTessellationStateCreateFlags Source # 
Read VkPipelineTessellationStateCreateFlags Source # 
Real VkPipelineTessellationStateCreateFlags Source # 
Show VkPipelineTessellationStateCreateFlags Source # 
Generic VkPipelineTessellationStateCreateFlags Source # 
Storable VkPipelineTessellationStateCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineVertexInputStateCreateFlags Source # 
Enum VkPipelineVertexInputStateCreateFlags Source # 
Eq VkPipelineVertexInputStateCreateFlags Source # 
Integral VkPipelineVertexInputStateCreateFlags Source # 
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 # 
Ord VkPipelineVertexInputStateCreateFlags Source # 
Read VkPipelineVertexInputStateCreateFlags Source # 
Real VkPipelineVertexInputStateCreateFlags Source # 
Show VkPipelineVertexInputStateCreateFlags Source # 
Generic VkPipelineVertexInputStateCreateFlags Source # 
Storable VkPipelineVertexInputStateCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineViewportStateCreateFlags Source # 
Enum VkPipelineViewportStateCreateFlags Source # 
Eq VkPipelineViewportStateCreateFlags Source # 
Integral VkPipelineViewportStateCreateFlags Source # 
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 # 
Ord VkPipelineViewportStateCreateFlags Source # 
Read VkPipelineViewportStateCreateFlags Source # 
Real VkPipelineViewportStateCreateFlags Source # 
Show VkPipelineViewportStateCreateFlags Source # 
Generic VkPipelineViewportStateCreateFlags Source # 
Storable VkPipelineViewportStateCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkPipelineViewportSwizzleStateCreateFlagsNV Source # 
Enum VkPipelineViewportSwizzleStateCreateFlagsNV Source # 
Eq VkPipelineViewportSwizzleStateCreateFlagsNV Source # 
Integral VkPipelineViewportSwizzleStateCreateFlagsNV Source # 
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 # 
Ord VkPipelineViewportSwizzleStateCreateFlagsNV Source # 
Read VkPipelineViewportSwizzleStateCreateFlagsNV Source # 
Real VkPipelineViewportSwizzleStateCreateFlagsNV Source # 
Show VkPipelineViewportSwizzleStateCreateFlagsNV Source # 
Generic VkPipelineViewportSwizzleStateCreateFlagsNV Source # 
Storable VkPipelineViewportSwizzleStateCreateFlagsNV Source # 
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 # 
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 #

Instances

Bounded VkQueryPoolCreateFlags Source # 
Enum VkQueryPoolCreateFlags Source # 
Eq VkQueryPoolCreateFlags Source # 
Integral VkQueryPoolCreateFlags Source # 
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 # 
Ord VkQueryPoolCreateFlags Source # 
Read VkQueryPoolCreateFlags Source # 
Real VkQueryPoolCreateFlags Source # 
Show VkQueryPoolCreateFlags Source # 
Generic VkQueryPoolCreateFlags Source # 
Storable VkQueryPoolCreateFlags Source # 
Bits VkQueryPoolCreateFlags Source # 
FiniteBits VkQueryPoolCreateFlags Source # 
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 #

Instances

Bounded VkRenderPassCreateFlags Source # 
Enum VkRenderPassCreateFlags Source # 
Eq VkRenderPassCreateFlags Source # 
Integral VkRenderPassCreateFlags Source # 
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 # 
Ord VkRenderPassCreateFlags Source # 
Read VkRenderPassCreateFlags Source # 
Real VkRenderPassCreateFlags Source # 
Show VkRenderPassCreateFlags Source # 
Generic VkRenderPassCreateFlags Source # 
Storable VkRenderPassCreateFlags Source # 
Bits VkRenderPassCreateFlags Source # 
FiniteBits VkRenderPassCreateFlags Source # 
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 #

Instances

Bounded VkSamplerCreateFlags Source # 
Enum VkSamplerCreateFlags Source # 
Eq VkSamplerCreateFlags Source # 
Integral VkSamplerCreateFlags Source # 
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 # 
Ord VkSamplerCreateFlags Source # 
Read VkSamplerCreateFlags Source # 
Real VkSamplerCreateFlags Source # 
Show VkSamplerCreateFlags Source # 
Generic VkSamplerCreateFlags Source # 
Storable VkSamplerCreateFlags Source # 
Bits VkSamplerCreateFlags Source # 
FiniteBits VkSamplerCreateFlags Source # 
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 #

Instances

Bounded VkSemaphoreCreateFlags Source # 
Enum VkSemaphoreCreateFlags Source # 
Eq VkSemaphoreCreateFlags Source # 
Integral VkSemaphoreCreateFlags Source # 
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 # 
Ord VkSemaphoreCreateFlags Source # 
Read VkSemaphoreCreateFlags Source # 
Real VkSemaphoreCreateFlags Source # 
Show VkSemaphoreCreateFlags Source # 
Generic VkSemaphoreCreateFlags Source # 
Storable VkSemaphoreCreateFlags Source # 
Bits VkSemaphoreCreateFlags Source # 
FiniteBits VkSemaphoreCreateFlags Source # 
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 #

Instances

Bounded VkSemaphoreImportFlagsKHR Source # 
Enum VkSemaphoreImportFlagsKHR Source # 
Eq VkSemaphoreImportFlagsKHR Source # 
Integral VkSemaphoreImportFlagsKHR Source # 
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 # 
Ord VkSemaphoreImportFlagsKHR Source # 
Read VkSemaphoreImportFlagsKHR Source # 
Real VkSemaphoreImportFlagsKHR Source # 
Show VkSemaphoreImportFlagsKHR Source # 
Generic VkSemaphoreImportFlagsKHR Source # 
Storable VkSemaphoreImportFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkShaderModuleCreateFlags Source # 
Enum VkShaderModuleCreateFlags Source # 
Eq VkShaderModuleCreateFlags Source # 
Integral VkShaderModuleCreateFlags Source # 
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 # 
Ord VkShaderModuleCreateFlags Source # 
Read VkShaderModuleCreateFlags Source # 
Real VkShaderModuleCreateFlags Source # 
Show VkShaderModuleCreateFlags Source # 
Generic VkShaderModuleCreateFlags Source # 
Storable VkShaderModuleCreateFlags Source # 
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 # 
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 #

Instances

Bounded VkValidationCacheCreateFlagsEXT Source # 
Enum VkValidationCacheCreateFlagsEXT Source # 
Eq VkValidationCacheCreateFlagsEXT Source # 
Integral VkValidationCacheCreateFlagsEXT Source # 
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 # 
Ord VkValidationCacheCreateFlagsEXT Source # 
Read VkValidationCacheCreateFlagsEXT Source # 
Real VkValidationCacheCreateFlagsEXT Source # 
Show VkValidationCacheCreateFlagsEXT Source # 
Generic VkValidationCacheCreateFlagsEXT Source # 
Storable VkValidationCacheCreateFlagsEXT Source # 
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 # 
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 #

Instances

Bounded VkViSurfaceCreateFlagsNN Source # 
Enum VkViSurfaceCreateFlagsNN Source # 
Eq VkViSurfaceCreateFlagsNN Source # 
Integral VkViSurfaceCreateFlagsNN Source # 
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 # 
Ord VkViSurfaceCreateFlagsNN Source # 
Read VkViSurfaceCreateFlagsNN Source # 
Real VkViSurfaceCreateFlagsNN Source # 
Show VkViSurfaceCreateFlagsNN Source # 
Generic VkViSurfaceCreateFlagsNN Source # 
Storable VkViSurfaceCreateFlagsNN Source # 
Bits VkViSurfaceCreateFlagsNN Source # 
FiniteBits VkViSurfaceCreateFlagsNN Source # 
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 #

Instances

Bounded VkWaylandSurfaceCreateFlagsKHR Source # 
Enum VkWaylandSurfaceCreateFlagsKHR Source # 
Eq VkWaylandSurfaceCreateFlagsKHR Source # 
Integral VkWaylandSurfaceCreateFlagsKHR Source # 
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 # 
Ord VkWaylandSurfaceCreateFlagsKHR Source # 
Read VkWaylandSurfaceCreateFlagsKHR Source # 
Real VkWaylandSurfaceCreateFlagsKHR Source # 
Show VkWaylandSurfaceCreateFlagsKHR Source # 
Generic VkWaylandSurfaceCreateFlagsKHR Source # 
Storable VkWaylandSurfaceCreateFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkWin32SurfaceCreateFlagsKHR Source # 
Enum VkWin32SurfaceCreateFlagsKHR Source # 
Eq VkWin32SurfaceCreateFlagsKHR Source # 
Integral VkWin32SurfaceCreateFlagsKHR Source # 
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 # 
Ord VkWin32SurfaceCreateFlagsKHR Source # 
Read VkWin32SurfaceCreateFlagsKHR Source # 
Real VkWin32SurfaceCreateFlagsKHR Source # 
Show VkWin32SurfaceCreateFlagsKHR Source # 
Generic VkWin32SurfaceCreateFlagsKHR Source # 
Storable VkWin32SurfaceCreateFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkXcbSurfaceCreateFlagsKHR Source # 
Enum VkXcbSurfaceCreateFlagsKHR Source # 
Eq VkXcbSurfaceCreateFlagsKHR Source # 
Integral VkXcbSurfaceCreateFlagsKHR Source # 
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 # 
Ord VkXcbSurfaceCreateFlagsKHR Source # 
Read VkXcbSurfaceCreateFlagsKHR Source # 
Real VkXcbSurfaceCreateFlagsKHR Source # 
Show VkXcbSurfaceCreateFlagsKHR Source # 
Generic VkXcbSurfaceCreateFlagsKHR Source # 
Storable VkXcbSurfaceCreateFlagsKHR Source # 
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 # 
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 #

Instances

Bounded VkXlibSurfaceCreateFlagsKHR Source # 
Enum VkXlibSurfaceCreateFlagsKHR Source # 
Eq VkXlibSurfaceCreateFlagsKHR Source # 
Integral VkXlibSurfaceCreateFlagsKHR Source # 
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 # 
Ord VkXlibSurfaceCreateFlagsKHR Source # 
Read VkXlibSurfaceCreateFlagsKHR Source # 
Real VkXlibSurfaceCreateFlagsKHR Source # 
Show VkXlibSurfaceCreateFlagsKHR Source # 
Generic VkXlibSurfaceCreateFlagsKHR Source # 
Storable VkXlibSurfaceCreateFlagsKHR Source # 
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 # 
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)))

data VkGraphicsPipelineCreateInfo Source #

typedef struct VkGraphicsPipelineCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineCreateFlags  flags;
    uint32_t               stageCount;
    const VkPipelineShaderStageCreateInfo* pStages;
    const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
    const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
    const VkPipelineTessellationStateCreateInfo* pTessellationState;
    const VkPipelineViewportStateCreateInfo* pViewportState;
    const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
    const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
    const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
    const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
    const VkPipelineDynamicStateCreateInfo* pDynamicState;
    VkPipelineLayout       layout;
    VkRenderPass           renderPass;
    uint32_t               subpass;
    VkPipeline      basePipelineHandle;
    int32_t                basePipelineIndex;
} VkGraphicsPipelineCreateInfo;

VkGraphicsPipelineCreateInfo registry at www.khronos.org

Instances

Eq VkGraphicsPipelineCreateInfo Source # 
Ord VkGraphicsPipelineCreateInfo Source # 
Show VkGraphicsPipelineCreateInfo Source # 
Storable VkGraphicsPipelineCreateInfo Source # 
VulkanMarshalPrim VkGraphicsPipelineCreateInfo Source # 
VulkanMarshal VkGraphicsPipelineCreateInfo Source # 
CanWriteField "basePipelineHandle" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "basePipelineIndex" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "flags" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "layout" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pColorBlendState" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pDepthStencilState" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pDynamicState" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pInputAssemblyState" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pMultisampleState" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pNext" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pRasterizationState" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pStages" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pTessellationState" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pVertexInputState" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "pViewportState" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "renderPass" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "sType" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "stageCount" VkGraphicsPipelineCreateInfo Source # 
CanWriteField "subpass" VkGraphicsPipelineCreateInfo Source # 
CanReadField "basePipelineHandle" VkGraphicsPipelineCreateInfo Source # 
CanReadField "basePipelineIndex" VkGraphicsPipelineCreateInfo Source # 
CanReadField "flags" VkGraphicsPipelineCreateInfo Source # 
CanReadField "layout" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pColorBlendState" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pDepthStencilState" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pDynamicState" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pInputAssemblyState" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pMultisampleState" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pNext" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pRasterizationState" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pStages" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pTessellationState" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pVertexInputState" VkGraphicsPipelineCreateInfo Source # 
CanReadField "pViewportState" VkGraphicsPipelineCreateInfo Source # 
CanReadField "renderPass" VkGraphicsPipelineCreateInfo Source # 
CanReadField "sType" VkGraphicsPipelineCreateInfo Source # 
CanReadField "stageCount" VkGraphicsPipelineCreateInfo Source # 
CanReadField "subpass" VkGraphicsPipelineCreateInfo Source # 
HasField "basePipelineHandle" VkGraphicsPipelineCreateInfo Source # 

Associated Types

type FieldType ("basePipelineHandle" :: Symbol) VkGraphicsPipelineCreateInfo :: Type Source #

type FieldOptional ("basePipelineHandle" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

type FieldOffset ("basePipelineHandle" :: Symbol) VkGraphicsPipelineCreateInfo :: Nat Source #

type FieldIsArray ("basePipelineHandle" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

HasField "basePipelineIndex" VkGraphicsPipelineCreateInfo Source # 

Associated Types

type FieldType ("basePipelineIndex" :: Symbol) VkGraphicsPipelineCreateInfo :: Type Source #

type FieldOptional ("basePipelineIndex" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

type FieldOffset ("basePipelineIndex" :: Symbol) VkGraphicsPipelineCreateInfo :: Nat Source #

type FieldIsArray ("basePipelineIndex" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

HasField "flags" VkGraphicsPipelineCreateInfo Source # 
HasField "layout" VkGraphicsPipelineCreateInfo Source # 
HasField "pColorBlendState" VkGraphicsPipelineCreateInfo Source # 

Associated Types

type FieldType ("pColorBlendState" :: Symbol) VkGraphicsPipelineCreateInfo :: Type Source #

type FieldOptional ("pColorBlendState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

type FieldOffset ("pColorBlendState" :: Symbol) VkGraphicsPipelineCreateInfo :: Nat Source #

type FieldIsArray ("pColorBlendState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

HasField "pDepthStencilState" VkGraphicsPipelineCreateInfo Source # 

Associated Types

type FieldType ("pDepthStencilState" :: Symbol) VkGraphicsPipelineCreateInfo :: Type Source #

type FieldOptional ("pDepthStencilState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

type FieldOffset ("pDepthStencilState" :: Symbol) VkGraphicsPipelineCreateInfo :: Nat Source #

type FieldIsArray ("pDepthStencilState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

HasField "pDynamicState" VkGraphicsPipelineCreateInfo Source # 
HasField "pInputAssemblyState" VkGraphicsPipelineCreateInfo Source # 

Associated Types

type FieldType ("pInputAssemblyState" :: Symbol) VkGraphicsPipelineCreateInfo :: Type Source #

type FieldOptional ("pInputAssemblyState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

type FieldOffset ("pInputAssemblyState" :: Symbol) VkGraphicsPipelineCreateInfo :: Nat Source #

type FieldIsArray ("pInputAssemblyState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

HasField "pMultisampleState" VkGraphicsPipelineCreateInfo Source # 

Associated Types

type FieldType ("pMultisampleState" :: Symbol) VkGraphicsPipelineCreateInfo :: Type Source #

type FieldOptional ("pMultisampleState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

type FieldOffset ("pMultisampleState" :: Symbol) VkGraphicsPipelineCreateInfo :: Nat Source #

type FieldIsArray ("pMultisampleState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

HasField "pNext" VkGraphicsPipelineCreateInfo Source # 
HasField "pRasterizationState" VkGraphicsPipelineCreateInfo Source # 

Associated Types

type FieldType ("pRasterizationState" :: Symbol) VkGraphicsPipelineCreateInfo :: Type Source #

type FieldOptional ("pRasterizationState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

type FieldOffset ("pRasterizationState" :: Symbol) VkGraphicsPipelineCreateInfo :: Nat Source #

type FieldIsArray ("pRasterizationState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

HasField "pStages" VkGraphicsPipelineCreateInfo Source # 
HasField "pTessellationState" VkGraphicsPipelineCreateInfo Source # 

Associated Types

type FieldType ("pTessellationState" :: Symbol) VkGraphicsPipelineCreateInfo :: Type Source #

type FieldOptional ("pTessellationState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

type FieldOffset ("pTessellationState" :: Symbol) VkGraphicsPipelineCreateInfo :: Nat Source #

type FieldIsArray ("pTessellationState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

HasField "pVertexInputState" VkGraphicsPipelineCreateInfo Source # 

Associated Types

type FieldType ("pVertexInputState" :: Symbol) VkGraphicsPipelineCreateInfo :: Type Source #

type FieldOptional ("pVertexInputState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

type FieldOffset ("pVertexInputState" :: Symbol) VkGraphicsPipelineCreateInfo :: Nat Source #

type FieldIsArray ("pVertexInputState" :: Symbol) VkGraphicsPipelineCreateInfo :: Bool Source #

HasField "pViewportState" VkGraphicsPipelineCreateInfo Source # 
HasField "renderPass" VkGraphicsPipelineCreateInfo Source # 
HasField "sType" VkGraphicsPipelineCreateInfo Source # 
HasField "stageCount" VkGraphicsPipelineCreateInfo Source # 
HasField "subpass" VkGraphicsPipelineCreateInfo Source # 
type StructFields VkGraphicsPipelineCreateInfo Source # 
type StructFields VkGraphicsPipelineCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "stageCount" ((:) Symbol "pStages" ((:) Symbol "pVertexInputState" ((:) Symbol "pInputAssemblyState" ((:) Symbol "pTessellationState" ((:) Symbol "pViewportState" ((:) Symbol "pRasterizationState" ((:) Symbol "pMultisampleState" ((:) Symbol "pDepthStencilState" ((:) Symbol "pColorBlendState" ((:) Symbol "pDynamicState" ((:) Symbol "layout" ((:) Symbol "renderPass" ((:) Symbol "subpass" ((:) Symbol "basePipelineHandle" ((:) Symbol "basePipelineIndex" ([] Symbol)))))))))))))))))))
type CUnionType VkGraphicsPipelineCreateInfo Source # 
type ReturnedOnly VkGraphicsPipelineCreateInfo Source # 
type StructExtends VkGraphicsPipelineCreateInfo Source # 
type FieldType "basePipelineHandle" VkGraphicsPipelineCreateInfo Source # 
type FieldType "basePipelineIndex" VkGraphicsPipelineCreateInfo Source # 
type FieldType "basePipelineIndex" VkGraphicsPipelineCreateInfo = Int32
type FieldType "flags" VkGraphicsPipelineCreateInfo Source # 
type FieldType "layout" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pColorBlendState" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pDepthStencilState" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pDynamicState" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pInputAssemblyState" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pMultisampleState" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pNext" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pRasterizationState" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pStages" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pTessellationState" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pVertexInputState" VkGraphicsPipelineCreateInfo Source # 
type FieldType "pViewportState" VkGraphicsPipelineCreateInfo Source # 
type FieldType "renderPass" VkGraphicsPipelineCreateInfo Source # 
type FieldType "sType" VkGraphicsPipelineCreateInfo Source # 
type FieldType "stageCount" VkGraphicsPipelineCreateInfo Source # 
type FieldType "subpass" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "basePipelineHandle" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "basePipelineHandle" VkGraphicsPipelineCreateInfo = True
type FieldOptional "basePipelineIndex" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "flags" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "layout" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pColorBlendState" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pDepthStencilState" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pDepthStencilState" VkGraphicsPipelineCreateInfo = True
type FieldOptional "pDynamicState" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pInputAssemblyState" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pInputAssemblyState" VkGraphicsPipelineCreateInfo = False
type FieldOptional "pMultisampleState" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pNext" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pRasterizationState" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pRasterizationState" VkGraphicsPipelineCreateInfo = False
type FieldOptional "pStages" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pTessellationState" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pTessellationState" VkGraphicsPipelineCreateInfo = True
type FieldOptional "pVertexInputState" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "pViewportState" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "renderPass" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "sType" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "stageCount" VkGraphicsPipelineCreateInfo Source # 
type FieldOptional "subpass" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "basePipelineHandle" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "basePipelineHandle" VkGraphicsPipelineCreateInfo = 128
type FieldOffset "basePipelineIndex" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "basePipelineIndex" VkGraphicsPipelineCreateInfo = 136
type FieldOffset "flags" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "layout" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pColorBlendState" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pColorBlendState" VkGraphicsPipelineCreateInfo = 88
type FieldOffset "pDepthStencilState" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pDepthStencilState" VkGraphicsPipelineCreateInfo = 80
type FieldOffset "pDynamicState" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pDynamicState" VkGraphicsPipelineCreateInfo = 96
type FieldOffset "pInputAssemblyState" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pInputAssemblyState" VkGraphicsPipelineCreateInfo = 40
type FieldOffset "pMultisampleState" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pMultisampleState" VkGraphicsPipelineCreateInfo = 72
type FieldOffset "pNext" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pRasterizationState" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pRasterizationState" VkGraphicsPipelineCreateInfo = 64
type FieldOffset "pStages" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pTessellationState" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pTessellationState" VkGraphicsPipelineCreateInfo = 48
type FieldOffset "pVertexInputState" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pVertexInputState" VkGraphicsPipelineCreateInfo = 32
type FieldOffset "pViewportState" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "pViewportState" VkGraphicsPipelineCreateInfo = 56
type FieldOffset "renderPass" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "sType" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "stageCount" VkGraphicsPipelineCreateInfo Source # 
type FieldOffset "subpass" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "basePipelineHandle" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "basePipelineHandle" VkGraphicsPipelineCreateInfo = False
type FieldIsArray "basePipelineIndex" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "flags" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "layout" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pColorBlendState" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pDepthStencilState" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pDepthStencilState" VkGraphicsPipelineCreateInfo = False
type FieldIsArray "pDynamicState" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pInputAssemblyState" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pInputAssemblyState" VkGraphicsPipelineCreateInfo = False
type FieldIsArray "pMultisampleState" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pNext" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pRasterizationState" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pRasterizationState" VkGraphicsPipelineCreateInfo = False
type FieldIsArray "pStages" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pTessellationState" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pTessellationState" VkGraphicsPipelineCreateInfo = False
type FieldIsArray "pVertexInputState" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "pViewportState" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "renderPass" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "sType" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "stageCount" VkGraphicsPipelineCreateInfo Source # 
type FieldIsArray "subpass" VkGraphicsPipelineCreateInfo Source # 

data VkPipelineCacheCreateInfo Source #

typedef struct VkPipelineCacheCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineCacheCreateFlags    flags;
    size_t                 initialDataSize;
    const void*            pInitialData;
} VkPipelineCacheCreateInfo;

VkPipelineCacheCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineCacheCreateInfo Source # 
Ord VkPipelineCacheCreateInfo Source # 
Show VkPipelineCacheCreateInfo Source # 
Storable VkPipelineCacheCreateInfo Source # 
VulkanMarshalPrim VkPipelineCacheCreateInfo Source # 
VulkanMarshal VkPipelineCacheCreateInfo Source # 
CanWriteField "flags" VkPipelineCacheCreateInfo Source # 
CanWriteField "initialDataSize" VkPipelineCacheCreateInfo Source # 
CanWriteField "pInitialData" VkPipelineCacheCreateInfo Source # 
CanWriteField "pNext" VkPipelineCacheCreateInfo Source # 
CanWriteField "sType" VkPipelineCacheCreateInfo Source # 
CanReadField "flags" VkPipelineCacheCreateInfo Source # 
CanReadField "initialDataSize" VkPipelineCacheCreateInfo Source # 
CanReadField "pInitialData" VkPipelineCacheCreateInfo Source # 
CanReadField "pNext" VkPipelineCacheCreateInfo Source # 
CanReadField "sType" VkPipelineCacheCreateInfo Source # 
HasField "flags" VkPipelineCacheCreateInfo Source # 
HasField "initialDataSize" VkPipelineCacheCreateInfo Source # 

Associated Types

type FieldType ("initialDataSize" :: Symbol) VkPipelineCacheCreateInfo :: Type Source #

type FieldOptional ("initialDataSize" :: Symbol) VkPipelineCacheCreateInfo :: Bool Source #

type FieldOffset ("initialDataSize" :: Symbol) VkPipelineCacheCreateInfo :: Nat Source #

type FieldIsArray ("initialDataSize" :: Symbol) VkPipelineCacheCreateInfo :: Bool Source #

HasField "pInitialData" VkPipelineCacheCreateInfo Source # 
HasField "pNext" VkPipelineCacheCreateInfo Source # 
HasField "sType" VkPipelineCacheCreateInfo Source # 
type StructFields VkPipelineCacheCreateInfo Source # 
type StructFields VkPipelineCacheCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "initialDataSize" ((:) Symbol "pInitialData" ([] Symbol)))))
type CUnionType VkPipelineCacheCreateInfo Source # 
type ReturnedOnly VkPipelineCacheCreateInfo Source # 
type StructExtends VkPipelineCacheCreateInfo Source # 
type FieldType "flags" VkPipelineCacheCreateInfo Source # 
type FieldType "initialDataSize" VkPipelineCacheCreateInfo Source # 
type FieldType "initialDataSize" VkPipelineCacheCreateInfo = CSize
type FieldType "pInitialData" VkPipelineCacheCreateInfo Source # 
type FieldType "pNext" VkPipelineCacheCreateInfo Source # 
type FieldType "sType" VkPipelineCacheCreateInfo Source # 
type FieldOptional "flags" VkPipelineCacheCreateInfo Source # 
type FieldOptional "initialDataSize" VkPipelineCacheCreateInfo Source # 
type FieldOptional "pInitialData" VkPipelineCacheCreateInfo Source # 
type FieldOptional "pNext" VkPipelineCacheCreateInfo Source # 
type FieldOptional "sType" VkPipelineCacheCreateInfo Source # 
type FieldOffset "flags" VkPipelineCacheCreateInfo Source # 
type FieldOffset "initialDataSize" VkPipelineCacheCreateInfo Source # 
type FieldOffset "initialDataSize" VkPipelineCacheCreateInfo = 24
type FieldOffset "pInitialData" VkPipelineCacheCreateInfo Source # 
type FieldOffset "pInitialData" VkPipelineCacheCreateInfo = 32
type FieldOffset "pNext" VkPipelineCacheCreateInfo Source # 
type FieldOffset "sType" VkPipelineCacheCreateInfo Source # 
type FieldIsArray "flags" VkPipelineCacheCreateInfo Source # 
type FieldIsArray "initialDataSize" VkPipelineCacheCreateInfo Source # 
type FieldIsArray "pInitialData" VkPipelineCacheCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineCacheCreateInfo Source # 
type FieldIsArray "sType" VkPipelineCacheCreateInfo Source # 

data VkPipelineColorBlendAdvancedStateCreateInfoEXT Source #

typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
    VkStructureType sType;
    const void*            pNext;
    VkBool32               srcPremultiplied;
    VkBool32               dstPremultiplied;
    VkBlendOverlapEXT      blendOverlap;
} VkPipelineColorBlendAdvancedStateCreateInfoEXT;

VkPipelineColorBlendAdvancedStateCreateInfoEXT registry at www.khronos.org

Instances

Eq VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
Ord VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
Show VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
Storable VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
VulkanMarshalPrim VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
VulkanMarshal VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
CanWriteField "blendOverlap" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
CanWriteField "dstPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
CanWriteField "pNext" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
CanWriteField "sType" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
CanWriteField "srcPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
CanReadField "blendOverlap" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
CanReadField "dstPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
CanReadField "pNext" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
CanReadField "sType" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
CanReadField "srcPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
HasField "blendOverlap" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
HasField "dstPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
HasField "pNext" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
HasField "sType" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
HasField "srcPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type StructFields VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type StructFields VkPipelineColorBlendAdvancedStateCreateInfoEXT = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "srcPremultiplied" ((:) Symbol "dstPremultiplied" ((:) Symbol "blendOverlap" ([] Symbol)))))
type CUnionType VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type ReturnedOnly VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type StructExtends VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldType "blendOverlap" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldType "dstPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldType "pNext" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldType "sType" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldType "srcPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldOptional "blendOverlap" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldOptional "dstPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldOptional "pNext" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldOptional "sType" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldOptional "srcPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldOffset "blendOverlap" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldOffset "dstPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldOffset "pNext" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldOffset "sType" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldOffset "srcPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldIsArray "blendOverlap" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldIsArray "dstPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldIsArray "pNext" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldIsArray "sType" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 
type FieldIsArray "srcPremultiplied" VkPipelineColorBlendAdvancedStateCreateInfoEXT Source # 

data VkPipelineColorBlendAttachmentState Source #

typedef struct VkPipelineColorBlendAttachmentState {
    VkBool32               blendEnable;
    VkBlendFactor          srcColorBlendFactor;
    VkBlendFactor          dstColorBlendFactor;
    VkBlendOp              colorBlendOp;
    VkBlendFactor          srcAlphaBlendFactor;
    VkBlendFactor          dstAlphaBlendFactor;
    VkBlendOp              alphaBlendOp;
    VkColorComponentFlags  colorWriteMask;
} VkPipelineColorBlendAttachmentState;

VkPipelineColorBlendAttachmentState registry at www.khronos.org

Instances

Eq VkPipelineColorBlendAttachmentState Source # 
Ord VkPipelineColorBlendAttachmentState Source # 
Show VkPipelineColorBlendAttachmentState Source # 
Storable VkPipelineColorBlendAttachmentState Source # 
VulkanMarshalPrim VkPipelineColorBlendAttachmentState Source # 
VulkanMarshal VkPipelineColorBlendAttachmentState Source # 
CanWriteField "alphaBlendOp" VkPipelineColorBlendAttachmentState Source # 
CanWriteField "blendEnable" VkPipelineColorBlendAttachmentState Source # 
CanWriteField "colorBlendOp" VkPipelineColorBlendAttachmentState Source # 
CanWriteField "colorWriteMask" VkPipelineColorBlendAttachmentState Source # 
CanWriteField "dstAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
CanWriteField "dstColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
CanWriteField "srcAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
CanWriteField "srcColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
CanReadField "alphaBlendOp" VkPipelineColorBlendAttachmentState Source # 
CanReadField "blendEnable" VkPipelineColorBlendAttachmentState Source # 
CanReadField "colorBlendOp" VkPipelineColorBlendAttachmentState Source # 
CanReadField "colorWriteMask" VkPipelineColorBlendAttachmentState Source # 
CanReadField "dstAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
CanReadField "dstColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
CanReadField "srcAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
CanReadField "srcColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
HasField "alphaBlendOp" VkPipelineColorBlendAttachmentState Source # 
HasField "blendEnable" VkPipelineColorBlendAttachmentState Source # 
HasField "colorBlendOp" VkPipelineColorBlendAttachmentState Source # 
HasField "colorWriteMask" VkPipelineColorBlendAttachmentState Source # 
HasField "dstAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
HasField "dstColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
HasField "srcAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
HasField "srcColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type StructFields VkPipelineColorBlendAttachmentState Source # 
type StructFields VkPipelineColorBlendAttachmentState = (:) Symbol "blendEnable" ((:) Symbol "srcColorBlendFactor" ((:) Symbol "dstColorBlendFactor" ((:) Symbol "colorBlendOp" ((:) Symbol "srcAlphaBlendFactor" ((:) Symbol "dstAlphaBlendFactor" ((:) Symbol "alphaBlendOp" ((:) Symbol "colorWriteMask" ([] Symbol))))))))
type CUnionType VkPipelineColorBlendAttachmentState Source # 
type ReturnedOnly VkPipelineColorBlendAttachmentState Source # 
type StructExtends VkPipelineColorBlendAttachmentState Source # 
type FieldType "alphaBlendOp" VkPipelineColorBlendAttachmentState Source # 
type FieldType "blendEnable" VkPipelineColorBlendAttachmentState Source # 
type FieldType "colorBlendOp" VkPipelineColorBlendAttachmentState Source # 
type FieldType "colorWriteMask" VkPipelineColorBlendAttachmentState Source # 
type FieldType "dstAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldType "dstColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldType "srcAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldType "srcColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldOptional "alphaBlendOp" VkPipelineColorBlendAttachmentState Source # 
type FieldOptional "blendEnable" VkPipelineColorBlendAttachmentState Source # 
type FieldOptional "colorBlendOp" VkPipelineColorBlendAttachmentState Source # 
type FieldOptional "colorWriteMask" VkPipelineColorBlendAttachmentState Source # 
type FieldOptional "dstAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldOptional "dstColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldOptional "srcAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldOptional "srcColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldOffset "alphaBlendOp" VkPipelineColorBlendAttachmentState Source # 
type FieldOffset "blendEnable" VkPipelineColorBlendAttachmentState Source # 
type FieldOffset "colorBlendOp" VkPipelineColorBlendAttachmentState Source # 
type FieldOffset "colorWriteMask" VkPipelineColorBlendAttachmentState Source # 
type FieldOffset "dstAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldOffset "dstAlphaBlendFactor" VkPipelineColorBlendAttachmentState = 20
type FieldOffset "dstColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldOffset "dstColorBlendFactor" VkPipelineColorBlendAttachmentState = 8
type FieldOffset "srcAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldOffset "srcAlphaBlendFactor" VkPipelineColorBlendAttachmentState = 16
type FieldOffset "srcColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldOffset "srcColorBlendFactor" VkPipelineColorBlendAttachmentState = 4
type FieldIsArray "alphaBlendOp" VkPipelineColorBlendAttachmentState Source # 
type FieldIsArray "blendEnable" VkPipelineColorBlendAttachmentState Source # 
type FieldIsArray "colorBlendOp" VkPipelineColorBlendAttachmentState Source # 
type FieldIsArray "colorWriteMask" VkPipelineColorBlendAttachmentState Source # 
type FieldIsArray "dstAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldIsArray "dstColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldIsArray "srcAlphaBlendFactor" VkPipelineColorBlendAttachmentState Source # 
type FieldIsArray "srcColorBlendFactor" VkPipelineColorBlendAttachmentState Source # 

data VkPipelineColorBlendStateCreateInfo Source #

typedef struct VkPipelineColorBlendStateCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineColorBlendStateCreateFlags    flags;
    VkBool32               logicOpEnable;
    VkLogicOp              logicOp;
    uint32_t               attachmentCount;
    const VkPipelineColorBlendAttachmentState* pAttachments;
    float                  blendConstants[4];
} VkPipelineColorBlendStateCreateInfo;

VkPipelineColorBlendStateCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineColorBlendStateCreateInfo Source # 
Ord VkPipelineColorBlendStateCreateInfo Source # 
Show VkPipelineColorBlendStateCreateInfo Source # 
Storable VkPipelineColorBlendStateCreateInfo Source # 
VulkanMarshalPrim VkPipelineColorBlendStateCreateInfo Source # 
VulkanMarshal VkPipelineColorBlendStateCreateInfo Source # 
CanWriteField "attachmentCount" VkPipelineColorBlendStateCreateInfo Source # 
CanWriteField "flags" VkPipelineColorBlendStateCreateInfo Source # 
CanWriteField "logicOp" VkPipelineColorBlendStateCreateInfo Source # 
CanWriteField "logicOpEnable" VkPipelineColorBlendStateCreateInfo Source # 
CanWriteField "pAttachments" VkPipelineColorBlendStateCreateInfo Source # 
CanWriteField "pNext" VkPipelineColorBlendStateCreateInfo Source # 
CanWriteField "sType" VkPipelineColorBlendStateCreateInfo Source # 
CanReadField "attachmentCount" VkPipelineColorBlendStateCreateInfo Source # 
CanReadField "flags" VkPipelineColorBlendStateCreateInfo Source # 
CanReadField "logicOp" VkPipelineColorBlendStateCreateInfo Source # 
CanReadField "logicOpEnable" VkPipelineColorBlendStateCreateInfo Source # 
CanReadField "pAttachments" VkPipelineColorBlendStateCreateInfo Source # 
CanReadField "pNext" VkPipelineColorBlendStateCreateInfo Source # 
CanReadField "sType" VkPipelineColorBlendStateCreateInfo Source # 
HasField "attachmentCount" VkPipelineColorBlendStateCreateInfo Source # 
HasField "blendConstants" VkPipelineColorBlendStateCreateInfo Source # 
HasField "flags" VkPipelineColorBlendStateCreateInfo Source # 
HasField "logicOp" VkPipelineColorBlendStateCreateInfo Source # 
HasField "logicOpEnable" VkPipelineColorBlendStateCreateInfo Source # 
HasField "pAttachments" VkPipelineColorBlendStateCreateInfo Source # 
HasField "pNext" VkPipelineColorBlendStateCreateInfo Source # 
HasField "sType" VkPipelineColorBlendStateCreateInfo Source # 
(KnownNat idx, IndexInBounds "blendConstants" idx VkPipelineColorBlendStateCreateInfo) => CanWriteFieldArray "blendConstants" idx VkPipelineColorBlendStateCreateInfo Source # 
(KnownNat idx, IndexInBounds "blendConstants" idx VkPipelineColorBlendStateCreateInfo) => CanReadFieldArray "blendConstants" idx VkPipelineColorBlendStateCreateInfo Source # 
type StructFields VkPipelineColorBlendStateCreateInfo Source # 
type StructFields VkPipelineColorBlendStateCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "logicOpEnable" ((:) Symbol "logicOp" ((:) Symbol "attachmentCount" ((:) Symbol "pAttachments" ((:) Symbol "blendConstants" ([] Symbol))))))))
type CUnionType VkPipelineColorBlendStateCreateInfo Source # 
type ReturnedOnly VkPipelineColorBlendStateCreateInfo Source # 
type StructExtends VkPipelineColorBlendStateCreateInfo Source # 
type FieldArrayLength "blendConstants" VkPipelineColorBlendStateCreateInfo Source # 
type FieldType "attachmentCount" VkPipelineColorBlendStateCreateInfo Source # 
type FieldType "blendConstants" VkPipelineColorBlendStateCreateInfo Source # 
type FieldType "flags" VkPipelineColorBlendStateCreateInfo Source # 
type FieldType "logicOp" VkPipelineColorBlendStateCreateInfo Source # 
type FieldType "logicOpEnable" VkPipelineColorBlendStateCreateInfo Source # 
type FieldType "pAttachments" VkPipelineColorBlendStateCreateInfo Source # 
type FieldType "pNext" VkPipelineColorBlendStateCreateInfo Source # 
type FieldType "sType" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOptional "attachmentCount" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOptional "blendConstants" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOptional "flags" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOptional "logicOp" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOptional "logicOpEnable" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOptional "pAttachments" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOptional "pNext" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOptional "sType" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOffset "attachmentCount" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOffset "blendConstants" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOffset "flags" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOffset "logicOp" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOffset "logicOpEnable" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOffset "pAttachments" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOffset "pNext" VkPipelineColorBlendStateCreateInfo Source # 
type FieldOffset "sType" VkPipelineColorBlendStateCreateInfo Source # 
type FieldIsArray "attachmentCount" VkPipelineColorBlendStateCreateInfo Source # 
type FieldIsArray "blendConstants" VkPipelineColorBlendStateCreateInfo Source # 
type FieldIsArray "flags" VkPipelineColorBlendStateCreateInfo Source # 
type FieldIsArray "logicOp" VkPipelineColorBlendStateCreateInfo Source # 
type FieldIsArray "logicOpEnable" VkPipelineColorBlendStateCreateInfo Source # 
type FieldIsArray "pAttachments" VkPipelineColorBlendStateCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineColorBlendStateCreateInfo Source # 
type FieldIsArray "sType" VkPipelineColorBlendStateCreateInfo Source # 

data VkPipelineCoverageModulationStateCreateInfoNV Source #

typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
    VkStructureType sType;
    const void*                                                                      pNext;
    VkPipelineCoverageModulationStateCreateFlagsNV                   flags;
    VkCoverageModulationModeNV                                                       coverageModulationMode;
    VkBool32                                                                         coverageModulationTableEnable;
    uint32_t                                                                         coverageModulationTableCount;
    const float* pCoverageModulationTable;
} VkPipelineCoverageModulationStateCreateInfoNV;

VkPipelineCoverageModulationStateCreateInfoNV registry at www.khronos.org

Instances

Eq VkPipelineCoverageModulationStateCreateInfoNV Source # 
Ord VkPipelineCoverageModulationStateCreateInfoNV Source # 
Show VkPipelineCoverageModulationStateCreateInfoNV Source # 
Storable VkPipelineCoverageModulationStateCreateInfoNV Source # 
VulkanMarshalPrim VkPipelineCoverageModulationStateCreateInfoNV Source # 
VulkanMarshal VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanWriteField "coverageModulationMode" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanWriteField "coverageModulationTableCount" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanWriteField "coverageModulationTableEnable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanWriteField "flags" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanWriteField "pCoverageModulationTable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanWriteField "pNext" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanWriteField "sType" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanReadField "coverageModulationMode" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanReadField "coverageModulationTableCount" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanReadField "coverageModulationTableEnable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanReadField "flags" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanReadField "pCoverageModulationTable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanReadField "pNext" VkPipelineCoverageModulationStateCreateInfoNV Source # 
CanReadField "sType" VkPipelineCoverageModulationStateCreateInfoNV Source # 
HasField "coverageModulationMode" VkPipelineCoverageModulationStateCreateInfoNV Source # 
HasField "coverageModulationTableCount" VkPipelineCoverageModulationStateCreateInfoNV Source # 

Associated Types

type FieldType ("coverageModulationTableCount" :: Symbol) VkPipelineCoverageModulationStateCreateInfoNV :: Type Source #

type FieldOptional ("coverageModulationTableCount" :: Symbol) VkPipelineCoverageModulationStateCreateInfoNV :: Bool Source #

type FieldOffset ("coverageModulationTableCount" :: Symbol) VkPipelineCoverageModulationStateCreateInfoNV :: Nat Source #

type FieldIsArray ("coverageModulationTableCount" :: Symbol) VkPipelineCoverageModulationStateCreateInfoNV :: Bool Source #

HasField "coverageModulationTableEnable" VkPipelineCoverageModulationStateCreateInfoNV Source # 

Associated Types

type FieldType ("coverageModulationTableEnable" :: Symbol) VkPipelineCoverageModulationStateCreateInfoNV :: Type Source #

type FieldOptional ("coverageModulationTableEnable" :: Symbol) VkPipelineCoverageModulationStateCreateInfoNV :: Bool Source #

type FieldOffset ("coverageModulationTableEnable" :: Symbol) VkPipelineCoverageModulationStateCreateInfoNV :: Nat Source #

type FieldIsArray ("coverageModulationTableEnable" :: Symbol) VkPipelineCoverageModulationStateCreateInfoNV :: Bool Source #

HasField "flags" VkPipelineCoverageModulationStateCreateInfoNV Source # 
HasField "pCoverageModulationTable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
HasField "pNext" VkPipelineCoverageModulationStateCreateInfoNV Source # 
HasField "sType" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type StructFields VkPipelineCoverageModulationStateCreateInfoNV Source # 
type StructFields VkPipelineCoverageModulationStateCreateInfoNV = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "coverageModulationMode" ((:) Symbol "coverageModulationTableEnable" ((:) Symbol "coverageModulationTableCount" ((:) Symbol "pCoverageModulationTable" ([] Symbol)))))))
type CUnionType VkPipelineCoverageModulationStateCreateInfoNV Source # 
type ReturnedOnly VkPipelineCoverageModulationStateCreateInfoNV Source # 
type StructExtends VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldType "coverageModulationMode" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldType "coverageModulationTableCount" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldType "coverageModulationTableCount" VkPipelineCoverageModulationStateCreateInfoNV = Word32
type FieldType "coverageModulationTableEnable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldType "flags" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldType "pCoverageModulationTable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldType "pNext" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldType "sType" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOptional "coverageModulationMode" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOptional "coverageModulationTableCount" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOptional "coverageModulationTableEnable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOptional "flags" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOptional "pCoverageModulationTable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOptional "pNext" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOptional "sType" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOffset "coverageModulationMode" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOffset "coverageModulationTableCount" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOffset "coverageModulationTableCount" VkPipelineCoverageModulationStateCreateInfoNV = 28
type FieldOffset "coverageModulationTableEnable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOffset "coverageModulationTableEnable" VkPipelineCoverageModulationStateCreateInfoNV = 24
type FieldOffset "flags" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOffset "pCoverageModulationTable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOffset "pCoverageModulationTable" VkPipelineCoverageModulationStateCreateInfoNV = 32
type FieldOffset "pNext" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldOffset "sType" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldIsArray "coverageModulationMode" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldIsArray "coverageModulationTableCount" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldIsArray "coverageModulationTableEnable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldIsArray "flags" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldIsArray "pCoverageModulationTable" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldIsArray "pNext" VkPipelineCoverageModulationStateCreateInfoNV Source # 
type FieldIsArray "sType" VkPipelineCoverageModulationStateCreateInfoNV Source # 

data VkPipelineCoverageToColorStateCreateInfoNV Source #

typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
    VkStructureType sType;
    const void*                                                                      pNext;
    VkPipelineCoverageToColorStateCreateFlagsNV                    flags;
    VkBool32                         coverageToColorEnable;
    uint32_t         coverageToColorLocation;
} VkPipelineCoverageToColorStateCreateInfoNV;

VkPipelineCoverageToColorStateCreateInfoNV registry at www.khronos.org

Instances

Eq VkPipelineCoverageToColorStateCreateInfoNV Source # 
Ord VkPipelineCoverageToColorStateCreateInfoNV Source # 
Show VkPipelineCoverageToColorStateCreateInfoNV Source # 
Storable VkPipelineCoverageToColorStateCreateInfoNV Source # 
VulkanMarshalPrim VkPipelineCoverageToColorStateCreateInfoNV Source # 
VulkanMarshal VkPipelineCoverageToColorStateCreateInfoNV Source # 
CanWriteField "coverageToColorEnable" VkPipelineCoverageToColorStateCreateInfoNV Source # 
CanWriteField "coverageToColorLocation" VkPipelineCoverageToColorStateCreateInfoNV Source # 
CanWriteField "flags" VkPipelineCoverageToColorStateCreateInfoNV Source # 
CanWriteField "pNext" VkPipelineCoverageToColorStateCreateInfoNV Source # 
CanWriteField "sType" VkPipelineCoverageToColorStateCreateInfoNV Source # 
CanReadField "coverageToColorEnable" VkPipelineCoverageToColorStateCreateInfoNV Source # 
CanReadField "coverageToColorLocation" VkPipelineCoverageToColorStateCreateInfoNV Source # 
CanReadField "flags" VkPipelineCoverageToColorStateCreateInfoNV Source # 
CanReadField "pNext" VkPipelineCoverageToColorStateCreateInfoNV Source # 
CanReadField "sType" VkPipelineCoverageToColorStateCreateInfoNV Source # 
HasField "coverageToColorEnable" VkPipelineCoverageToColorStateCreateInfoNV Source # 
HasField "coverageToColorLocation" VkPipelineCoverageToColorStateCreateInfoNV Source # 
HasField "flags" VkPipelineCoverageToColorStateCreateInfoNV Source # 
HasField "pNext" VkPipelineCoverageToColorStateCreateInfoNV Source # 
HasField "sType" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type StructFields VkPipelineCoverageToColorStateCreateInfoNV Source # 
type StructFields VkPipelineCoverageToColorStateCreateInfoNV = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "coverageToColorEnable" ((:) Symbol "coverageToColorLocation" ([] Symbol)))))
type CUnionType VkPipelineCoverageToColorStateCreateInfoNV Source # 
type ReturnedOnly VkPipelineCoverageToColorStateCreateInfoNV Source # 
type StructExtends VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldType "coverageToColorEnable" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldType "coverageToColorLocation" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldType "flags" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldType "pNext" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldType "sType" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldOptional "coverageToColorEnable" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldOptional "coverageToColorLocation" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldOptional "flags" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldOptional "pNext" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldOptional "sType" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldOffset "coverageToColorEnable" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldOffset "coverageToColorLocation" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldOffset "coverageToColorLocation" VkPipelineCoverageToColorStateCreateInfoNV = 24
type FieldOffset "flags" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldOffset "pNext" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldOffset "sType" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldIsArray "coverageToColorEnable" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldIsArray "coverageToColorLocation" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldIsArray "flags" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldIsArray "pNext" VkPipelineCoverageToColorStateCreateInfoNV Source # 
type FieldIsArray "sType" VkPipelineCoverageToColorStateCreateInfoNV Source # 

data VkPipelineDepthStencilStateCreateInfo Source #

typedef struct VkPipelineDepthStencilStateCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineDepthStencilStateCreateFlags    flags;
    VkBool32               depthTestEnable;
    VkBool32               depthWriteEnable;
    VkCompareOp            depthCompareOp;
    VkBool32               depthBoundsTestEnable;
    VkBool32               stencilTestEnable;
    VkStencilOpState       front;
    VkStencilOpState       back;
    float                  minDepthBounds;
    float                  maxDepthBounds;
} VkPipelineDepthStencilStateCreateInfo;

VkPipelineDepthStencilStateCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineDepthStencilStateCreateInfo Source # 
Ord VkPipelineDepthStencilStateCreateInfo Source # 
Show VkPipelineDepthStencilStateCreateInfo Source # 
Storable VkPipelineDepthStencilStateCreateInfo Source # 
VulkanMarshalPrim VkPipelineDepthStencilStateCreateInfo Source # 
VulkanMarshal VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "back" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "depthBoundsTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "depthCompareOp" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "depthTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "depthWriteEnable" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "flags" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "front" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "maxDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "minDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "pNext" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "sType" VkPipelineDepthStencilStateCreateInfo Source # 
CanWriteField "stencilTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "back" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "depthBoundsTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "depthCompareOp" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "depthTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "depthWriteEnable" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "flags" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "front" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "maxDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "minDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "pNext" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "sType" VkPipelineDepthStencilStateCreateInfo Source # 
CanReadField "stencilTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "back" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "depthBoundsTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 

Associated Types

type FieldType ("depthBoundsTestEnable" :: Symbol) VkPipelineDepthStencilStateCreateInfo :: Type Source #

type FieldOptional ("depthBoundsTestEnable" :: Symbol) VkPipelineDepthStencilStateCreateInfo :: Bool Source #

type FieldOffset ("depthBoundsTestEnable" :: Symbol) VkPipelineDepthStencilStateCreateInfo :: Nat Source #

type FieldIsArray ("depthBoundsTestEnable" :: Symbol) VkPipelineDepthStencilStateCreateInfo :: Bool Source #

HasField "depthCompareOp" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "depthTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "depthWriteEnable" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "flags" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "front" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "maxDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "minDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "pNext" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "sType" VkPipelineDepthStencilStateCreateInfo Source # 
HasField "stencilTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type StructFields VkPipelineDepthStencilStateCreateInfo Source # 
type StructFields VkPipelineDepthStencilStateCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "depthTestEnable" ((:) Symbol "depthWriteEnable" ((:) Symbol "depthCompareOp" ((:) Symbol "depthBoundsTestEnable" ((:) Symbol "stencilTestEnable" ((:) Symbol "front" ((:) Symbol "back" ((:) Symbol "minDepthBounds" ((:) Symbol "maxDepthBounds" ([] Symbol))))))))))))
type CUnionType VkPipelineDepthStencilStateCreateInfo Source # 
type ReturnedOnly VkPipelineDepthStencilStateCreateInfo Source # 
type StructExtends VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "back" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "depthBoundsTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "depthCompareOp" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "depthTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "depthWriteEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "flags" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "front" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "maxDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "minDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "pNext" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "sType" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldType "stencilTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "back" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "depthBoundsTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "depthCompareOp" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "depthTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "depthWriteEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "flags" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "front" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "maxDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "minDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "pNext" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "sType" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOptional "stencilTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "back" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "depthBoundsTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "depthBoundsTestEnable" VkPipelineDepthStencilStateCreateInfo = 32
type FieldOffset "depthCompareOp" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "depthTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "depthWriteEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "flags" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "front" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "maxDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "minDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "pNext" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "sType" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldOffset "stencilTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "back" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "depthBoundsTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "depthCompareOp" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "depthTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "depthWriteEnable" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "flags" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "front" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "maxDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "minDepthBounds" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "sType" VkPipelineDepthStencilStateCreateInfo Source # 
type FieldIsArray "stencilTestEnable" VkPipelineDepthStencilStateCreateInfo Source # 

data VkPipelineDiscardRectangleStateCreateInfoEXT Source #

typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
    VkStructureType sType;
    const void*                                                                      pNext;
    VkPipelineDiscardRectangleStateCreateFlagsEXT                    flags;
    VkDiscardRectangleModeEXT                                                        discardRectangleMode;
    uint32_t                                                         discardRectangleCount;
    const VkRect2D* pDiscardRectangles;
} VkPipelineDiscardRectangleStateCreateInfoEXT;

VkPipelineDiscardRectangleStateCreateInfoEXT registry at www.khronos.org

Instances

Eq VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
Ord VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
Show VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
Storable VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
VulkanMarshalPrim VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
VulkanMarshal VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanWriteField "discardRectangleCount" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanWriteField "discardRectangleMode" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanWriteField "flags" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanWriteField "pDiscardRectangles" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanWriteField "pNext" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanWriteField "sType" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanReadField "discardRectangleCount" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanReadField "discardRectangleMode" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanReadField "flags" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanReadField "pDiscardRectangles" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanReadField "pNext" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
CanReadField "sType" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
HasField "discardRectangleCount" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
HasField "discardRectangleMode" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
HasField "flags" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
HasField "pDiscardRectangles" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
HasField "pNext" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
HasField "sType" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type StructFields VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type StructFields VkPipelineDiscardRectangleStateCreateInfoEXT = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "discardRectangleMode" ((:) Symbol "discardRectangleCount" ((:) Symbol "pDiscardRectangles" ([] Symbol))))))
type CUnionType VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type ReturnedOnly VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type StructExtends VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldType "discardRectangleCount" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldType "discardRectangleMode" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldType "flags" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldType "pDiscardRectangles" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldType "pNext" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldType "sType" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOptional "discardRectangleCount" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOptional "discardRectangleMode" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOptional "flags" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOptional "pDiscardRectangles" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOptional "pNext" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOptional "sType" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOffset "discardRectangleCount" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOffset "discardRectangleMode" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOffset "flags" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOffset "pDiscardRectangles" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOffset "pNext" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldOffset "sType" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldIsArray "discardRectangleCount" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldIsArray "discardRectangleMode" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldIsArray "flags" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldIsArray "pDiscardRectangles" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldIsArray "pNext" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 
type FieldIsArray "sType" VkPipelineDiscardRectangleStateCreateInfoEXT Source # 

data VkPipelineDynamicStateCreateInfo Source #

typedef struct VkPipelineDynamicStateCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineDynamicStateCreateFlags    flags;
    uint32_t               dynamicStateCount;
    const VkDynamicState*  pDynamicStates;
} VkPipelineDynamicStateCreateInfo;

VkPipelineDynamicStateCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineDynamicStateCreateInfo Source # 
Ord VkPipelineDynamicStateCreateInfo Source # 
Show VkPipelineDynamicStateCreateInfo Source # 
Storable VkPipelineDynamicStateCreateInfo Source # 
VulkanMarshalPrim VkPipelineDynamicStateCreateInfo Source # 
VulkanMarshal VkPipelineDynamicStateCreateInfo Source # 
CanWriteField "dynamicStateCount" VkPipelineDynamicStateCreateInfo Source # 
CanWriteField "flags" VkPipelineDynamicStateCreateInfo Source # 
CanWriteField "pDynamicStates" VkPipelineDynamicStateCreateInfo Source # 
CanWriteField "pNext" VkPipelineDynamicStateCreateInfo Source # 
CanWriteField "sType" VkPipelineDynamicStateCreateInfo Source # 
CanReadField "dynamicStateCount" VkPipelineDynamicStateCreateInfo Source # 
CanReadField "flags" VkPipelineDynamicStateCreateInfo Source # 
CanReadField "pDynamicStates" VkPipelineDynamicStateCreateInfo Source # 
CanReadField "pNext" VkPipelineDynamicStateCreateInfo Source # 
CanReadField "sType" VkPipelineDynamicStateCreateInfo Source # 
HasField "dynamicStateCount" VkPipelineDynamicStateCreateInfo Source # 
HasField "flags" VkPipelineDynamicStateCreateInfo Source # 
HasField "pDynamicStates" VkPipelineDynamicStateCreateInfo Source # 
HasField "pNext" VkPipelineDynamicStateCreateInfo Source # 
HasField "sType" VkPipelineDynamicStateCreateInfo Source # 
type StructFields VkPipelineDynamicStateCreateInfo Source # 
type StructFields VkPipelineDynamicStateCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "dynamicStateCount" ((:) Symbol "pDynamicStates" ([] Symbol)))))
type CUnionType VkPipelineDynamicStateCreateInfo Source # 
type ReturnedOnly VkPipelineDynamicStateCreateInfo Source # 
type StructExtends VkPipelineDynamicStateCreateInfo Source # 
type FieldType "dynamicStateCount" VkPipelineDynamicStateCreateInfo Source # 
type FieldType "flags" VkPipelineDynamicStateCreateInfo Source # 
type FieldType "pDynamicStates" VkPipelineDynamicStateCreateInfo Source # 
type FieldType "pNext" VkPipelineDynamicStateCreateInfo Source # 
type FieldType "sType" VkPipelineDynamicStateCreateInfo Source # 
type FieldOptional "dynamicStateCount" VkPipelineDynamicStateCreateInfo Source # 
type FieldOptional "flags" VkPipelineDynamicStateCreateInfo Source # 
type FieldOptional "pDynamicStates" VkPipelineDynamicStateCreateInfo Source # 
type FieldOptional "pNext" VkPipelineDynamicStateCreateInfo Source # 
type FieldOptional "sType" VkPipelineDynamicStateCreateInfo Source # 
type FieldOffset "dynamicStateCount" VkPipelineDynamicStateCreateInfo Source # 
type FieldOffset "dynamicStateCount" VkPipelineDynamicStateCreateInfo = 20
type FieldOffset "flags" VkPipelineDynamicStateCreateInfo Source # 
type FieldOffset "pDynamicStates" VkPipelineDynamicStateCreateInfo Source # 
type FieldOffset "pNext" VkPipelineDynamicStateCreateInfo Source # 
type FieldOffset "sType" VkPipelineDynamicStateCreateInfo Source # 
type FieldIsArray "dynamicStateCount" VkPipelineDynamicStateCreateInfo Source # 
type FieldIsArray "flags" VkPipelineDynamicStateCreateInfo Source # 
type FieldIsArray "pDynamicStates" VkPipelineDynamicStateCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineDynamicStateCreateInfo Source # 
type FieldIsArray "sType" VkPipelineDynamicStateCreateInfo Source # 

data VkPipelineInputAssemblyStateCreateInfo Source #

typedef struct VkPipelineInputAssemblyStateCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineInputAssemblyStateCreateFlags    flags;
    VkPrimitiveTopology    topology;
    VkBool32               primitiveRestartEnable;
} VkPipelineInputAssemblyStateCreateInfo;

VkPipelineInputAssemblyStateCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineInputAssemblyStateCreateInfo Source # 
Ord VkPipelineInputAssemblyStateCreateInfo Source # 
Show VkPipelineInputAssemblyStateCreateInfo Source # 
Storable VkPipelineInputAssemblyStateCreateInfo Source # 
VulkanMarshalPrim VkPipelineInputAssemblyStateCreateInfo Source # 
VulkanMarshal VkPipelineInputAssemblyStateCreateInfo Source # 
CanWriteField "flags" VkPipelineInputAssemblyStateCreateInfo Source # 
CanWriteField "pNext" VkPipelineInputAssemblyStateCreateInfo Source # 
CanWriteField "primitiveRestartEnable" VkPipelineInputAssemblyStateCreateInfo Source # 
CanWriteField "sType" VkPipelineInputAssemblyStateCreateInfo Source # 
CanWriteField "topology" VkPipelineInputAssemblyStateCreateInfo Source # 
CanReadField "flags" VkPipelineInputAssemblyStateCreateInfo Source # 
CanReadField "pNext" VkPipelineInputAssemblyStateCreateInfo Source # 
CanReadField "primitiveRestartEnable" VkPipelineInputAssemblyStateCreateInfo Source # 
CanReadField "sType" VkPipelineInputAssemblyStateCreateInfo Source # 
CanReadField "topology" VkPipelineInputAssemblyStateCreateInfo Source # 
HasField "flags" VkPipelineInputAssemblyStateCreateInfo Source # 
HasField "pNext" VkPipelineInputAssemblyStateCreateInfo Source # 
HasField "primitiveRestartEnable" VkPipelineInputAssemblyStateCreateInfo Source # 

Associated Types

type FieldType ("primitiveRestartEnable" :: Symbol) VkPipelineInputAssemblyStateCreateInfo :: Type Source #

type FieldOptional ("primitiveRestartEnable" :: Symbol) VkPipelineInputAssemblyStateCreateInfo :: Bool Source #

type FieldOffset ("primitiveRestartEnable" :: Symbol) VkPipelineInputAssemblyStateCreateInfo :: Nat Source #

type FieldIsArray ("primitiveRestartEnable" :: Symbol) VkPipelineInputAssemblyStateCreateInfo :: Bool Source #

HasField "sType" VkPipelineInputAssemblyStateCreateInfo Source # 
HasField "topology" VkPipelineInputAssemblyStateCreateInfo Source # 
type StructFields VkPipelineInputAssemblyStateCreateInfo Source # 
type StructFields VkPipelineInputAssemblyStateCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "topology" ((:) Symbol "primitiveRestartEnable" ([] Symbol)))))
type CUnionType VkPipelineInputAssemblyStateCreateInfo Source # 
type ReturnedOnly VkPipelineInputAssemblyStateCreateInfo Source # 
type StructExtends VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldType "flags" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldType "pNext" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldType "primitiveRestartEnable" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldType "sType" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldType "topology" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldOptional "flags" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldOptional "pNext" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldOptional "primitiveRestartEnable" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldOptional "sType" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldOptional "topology" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldOffset "flags" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldOffset "pNext" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldOffset "primitiveRestartEnable" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldOffset "primitiveRestartEnable" VkPipelineInputAssemblyStateCreateInfo = 24
type FieldOffset "sType" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldOffset "topology" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldIsArray "flags" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldIsArray "primitiveRestartEnable" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldIsArray "sType" VkPipelineInputAssemblyStateCreateInfo Source # 
type FieldIsArray "topology" VkPipelineInputAssemblyStateCreateInfo Source # 

data VkPipelineLayoutCreateInfo Source #

typedef struct VkPipelineLayoutCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineLayoutCreateFlags    flags;
    uint32_t               setLayoutCount;
    const VkDescriptorSetLayout* pSetLayouts;
    uint32_t               pushConstantRangeCount;
    const VkPushConstantRange* pPushConstantRanges;
} VkPipelineLayoutCreateInfo;

VkPipelineLayoutCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineLayoutCreateInfo Source # 
Ord VkPipelineLayoutCreateInfo Source # 
Show VkPipelineLayoutCreateInfo Source # 
Storable VkPipelineLayoutCreateInfo Source # 
VulkanMarshalPrim VkPipelineLayoutCreateInfo Source # 
VulkanMarshal VkPipelineLayoutCreateInfo Source # 
CanWriteField "flags" VkPipelineLayoutCreateInfo Source # 
CanWriteField "pNext" VkPipelineLayoutCreateInfo Source # 
CanWriteField "pPushConstantRanges" VkPipelineLayoutCreateInfo Source # 
CanWriteField "pSetLayouts" VkPipelineLayoutCreateInfo Source # 
CanWriteField "pushConstantRangeCount" VkPipelineLayoutCreateInfo Source # 
CanWriteField "sType" VkPipelineLayoutCreateInfo Source # 
CanWriteField "setLayoutCount" VkPipelineLayoutCreateInfo Source # 
CanReadField "flags" VkPipelineLayoutCreateInfo Source # 
CanReadField "pNext" VkPipelineLayoutCreateInfo Source # 
CanReadField "pPushConstantRanges" VkPipelineLayoutCreateInfo Source # 
CanReadField "pSetLayouts" VkPipelineLayoutCreateInfo Source # 
CanReadField "pushConstantRangeCount" VkPipelineLayoutCreateInfo Source # 
CanReadField "sType" VkPipelineLayoutCreateInfo Source # 
CanReadField "setLayoutCount" VkPipelineLayoutCreateInfo Source # 
HasField "flags" VkPipelineLayoutCreateInfo Source # 
HasField "pNext" VkPipelineLayoutCreateInfo Source # 
HasField "pPushConstantRanges" VkPipelineLayoutCreateInfo Source # 

Associated Types

type FieldType ("pPushConstantRanges" :: Symbol) VkPipelineLayoutCreateInfo :: Type Source #

type FieldOptional ("pPushConstantRanges" :: Symbol) VkPipelineLayoutCreateInfo :: Bool Source #

type FieldOffset ("pPushConstantRanges" :: Symbol) VkPipelineLayoutCreateInfo :: Nat Source #

type FieldIsArray ("pPushConstantRanges" :: Symbol) VkPipelineLayoutCreateInfo :: Bool Source #

HasField "pSetLayouts" VkPipelineLayoutCreateInfo Source # 
HasField "pushConstantRangeCount" VkPipelineLayoutCreateInfo Source # 

Associated Types

type FieldType ("pushConstantRangeCount" :: Symbol) VkPipelineLayoutCreateInfo :: Type Source #

type FieldOptional ("pushConstantRangeCount" :: Symbol) VkPipelineLayoutCreateInfo :: Bool Source #

type FieldOffset ("pushConstantRangeCount" :: Symbol) VkPipelineLayoutCreateInfo :: Nat Source #

type FieldIsArray ("pushConstantRangeCount" :: Symbol) VkPipelineLayoutCreateInfo :: Bool Source #

HasField "sType" VkPipelineLayoutCreateInfo Source # 
HasField "setLayoutCount" VkPipelineLayoutCreateInfo Source # 

Associated Types

type FieldType ("setLayoutCount" :: Symbol) VkPipelineLayoutCreateInfo :: Type Source #

type FieldOptional ("setLayoutCount" :: Symbol) VkPipelineLayoutCreateInfo :: Bool Source #

type FieldOffset ("setLayoutCount" :: Symbol) VkPipelineLayoutCreateInfo :: Nat Source #

type FieldIsArray ("setLayoutCount" :: Symbol) VkPipelineLayoutCreateInfo :: Bool Source #

type StructFields VkPipelineLayoutCreateInfo Source # 
type StructFields VkPipelineLayoutCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "setLayoutCount" ((:) Symbol "pSetLayouts" ((:) Symbol "pushConstantRangeCount" ((:) Symbol "pPushConstantRanges" ([] Symbol)))))))
type CUnionType VkPipelineLayoutCreateInfo Source # 
type ReturnedOnly VkPipelineLayoutCreateInfo Source # 
type StructExtends VkPipelineLayoutCreateInfo Source # 
type FieldType "flags" VkPipelineLayoutCreateInfo Source # 
type FieldType "pNext" VkPipelineLayoutCreateInfo Source # 
type FieldType "pPushConstantRanges" VkPipelineLayoutCreateInfo Source # 
type FieldType "pSetLayouts" VkPipelineLayoutCreateInfo Source # 
type FieldType "pushConstantRangeCount" VkPipelineLayoutCreateInfo Source # 
type FieldType "pushConstantRangeCount" VkPipelineLayoutCreateInfo = Word32
type FieldType "sType" VkPipelineLayoutCreateInfo Source # 
type FieldType "setLayoutCount" VkPipelineLayoutCreateInfo Source # 
type FieldOptional "flags" VkPipelineLayoutCreateInfo Source # 
type FieldOptional "pNext" VkPipelineLayoutCreateInfo Source # 
type FieldOptional "pPushConstantRanges" VkPipelineLayoutCreateInfo Source # 
type FieldOptional "pPushConstantRanges" VkPipelineLayoutCreateInfo = False
type FieldOptional "pSetLayouts" VkPipelineLayoutCreateInfo Source # 
type FieldOptional "pushConstantRangeCount" VkPipelineLayoutCreateInfo Source # 
type FieldOptional "pushConstantRangeCount" VkPipelineLayoutCreateInfo = True
type FieldOptional "sType" VkPipelineLayoutCreateInfo Source # 
type FieldOptional "setLayoutCount" VkPipelineLayoutCreateInfo Source # 
type FieldOffset "flags" VkPipelineLayoutCreateInfo Source # 
type FieldOffset "pNext" VkPipelineLayoutCreateInfo Source # 
type FieldOffset "pPushConstantRanges" VkPipelineLayoutCreateInfo Source # 
type FieldOffset "pPushConstantRanges" VkPipelineLayoutCreateInfo = 40
type FieldOffset "pSetLayouts" VkPipelineLayoutCreateInfo Source # 
type FieldOffset "pSetLayouts" VkPipelineLayoutCreateInfo = 24
type FieldOffset "pushConstantRangeCount" VkPipelineLayoutCreateInfo Source # 
type FieldOffset "pushConstantRangeCount" VkPipelineLayoutCreateInfo = 32
type FieldOffset "sType" VkPipelineLayoutCreateInfo Source # 
type FieldOffset "setLayoutCount" VkPipelineLayoutCreateInfo Source # 
type FieldOffset "setLayoutCount" VkPipelineLayoutCreateInfo = 20
type FieldIsArray "flags" VkPipelineLayoutCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineLayoutCreateInfo Source # 
type FieldIsArray "pPushConstantRanges" VkPipelineLayoutCreateInfo Source # 
type FieldIsArray "pPushConstantRanges" VkPipelineLayoutCreateInfo = False
type FieldIsArray "pSetLayouts" VkPipelineLayoutCreateInfo Source # 
type FieldIsArray "pushConstantRangeCount" VkPipelineLayoutCreateInfo Source # 
type FieldIsArray "pushConstantRangeCount" VkPipelineLayoutCreateInfo = False
type FieldIsArray "sType" VkPipelineLayoutCreateInfo Source # 
type FieldIsArray "setLayoutCount" VkPipelineLayoutCreateInfo Source # 

data VkPipelineMultisampleStateCreateInfo Source #

typedef struct VkPipelineMultisampleStateCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineMultisampleStateCreateFlags    flags;
    VkSampleCountFlagBits  rasterizationSamples;
    VkBool32               sampleShadingEnable;
    float                  minSampleShading;
    const VkSampleMask*    pSampleMask;
    VkBool32               alphaToCoverageEnable;
    VkBool32               alphaToOneEnable;
} VkPipelineMultisampleStateCreateInfo;

VkPipelineMultisampleStateCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineMultisampleStateCreateInfo Source # 
Ord VkPipelineMultisampleStateCreateInfo Source # 
Show VkPipelineMultisampleStateCreateInfo Source # 
Storable VkPipelineMultisampleStateCreateInfo Source # 
VulkanMarshalPrim VkPipelineMultisampleStateCreateInfo Source # 
VulkanMarshal VkPipelineMultisampleStateCreateInfo Source # 
CanWriteField "alphaToCoverageEnable" VkPipelineMultisampleStateCreateInfo Source # 
CanWriteField "alphaToOneEnable" VkPipelineMultisampleStateCreateInfo Source # 
CanWriteField "flags" VkPipelineMultisampleStateCreateInfo Source # 
CanWriteField "minSampleShading" VkPipelineMultisampleStateCreateInfo Source # 
CanWriteField "pNext" VkPipelineMultisampleStateCreateInfo Source # 
CanWriteField "pSampleMask" VkPipelineMultisampleStateCreateInfo Source # 
CanWriteField "rasterizationSamples" VkPipelineMultisampleStateCreateInfo Source # 
CanWriteField "sType" VkPipelineMultisampleStateCreateInfo Source # 
CanWriteField "sampleShadingEnable" VkPipelineMultisampleStateCreateInfo Source # 
CanReadField "alphaToCoverageEnable" VkPipelineMultisampleStateCreateInfo Source # 
CanReadField "alphaToOneEnable" VkPipelineMultisampleStateCreateInfo Source # 
CanReadField "flags" VkPipelineMultisampleStateCreateInfo Source # 
CanReadField "minSampleShading" VkPipelineMultisampleStateCreateInfo Source # 
CanReadField "pNext" VkPipelineMultisampleStateCreateInfo Source # 
CanReadField "pSampleMask" VkPipelineMultisampleStateCreateInfo Source # 
CanReadField "rasterizationSamples" VkPipelineMultisampleStateCreateInfo Source # 
CanReadField "sType" VkPipelineMultisampleStateCreateInfo Source # 
CanReadField "sampleShadingEnable" VkPipelineMultisampleStateCreateInfo Source # 
HasField "alphaToCoverageEnable" VkPipelineMultisampleStateCreateInfo Source # 

Associated Types

type FieldType ("alphaToCoverageEnable" :: Symbol) VkPipelineMultisampleStateCreateInfo :: Type Source #

type FieldOptional ("alphaToCoverageEnable" :: Symbol) VkPipelineMultisampleStateCreateInfo :: Bool Source #

type FieldOffset ("alphaToCoverageEnable" :: Symbol) VkPipelineMultisampleStateCreateInfo :: Nat Source #

type FieldIsArray ("alphaToCoverageEnable" :: Symbol) VkPipelineMultisampleStateCreateInfo :: Bool Source #

HasField "alphaToOneEnable" VkPipelineMultisampleStateCreateInfo Source # 
HasField "flags" VkPipelineMultisampleStateCreateInfo Source # 
HasField "minSampleShading" VkPipelineMultisampleStateCreateInfo Source # 
HasField "pNext" VkPipelineMultisampleStateCreateInfo Source # 
HasField "pSampleMask" VkPipelineMultisampleStateCreateInfo Source # 
HasField "rasterizationSamples" VkPipelineMultisampleStateCreateInfo Source # 
HasField "sType" VkPipelineMultisampleStateCreateInfo Source # 
HasField "sampleShadingEnable" VkPipelineMultisampleStateCreateInfo Source # 
type StructFields VkPipelineMultisampleStateCreateInfo Source # 
type StructFields VkPipelineMultisampleStateCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "rasterizationSamples" ((:) Symbol "sampleShadingEnable" ((:) Symbol "minSampleShading" ((:) Symbol "pSampleMask" ((:) Symbol "alphaToCoverageEnable" ((:) Symbol "alphaToOneEnable" ([] Symbol)))))))))
type CUnionType VkPipelineMultisampleStateCreateInfo Source # 
type ReturnedOnly VkPipelineMultisampleStateCreateInfo Source # 
type StructExtends VkPipelineMultisampleStateCreateInfo Source # 
type FieldType "alphaToCoverageEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldType "alphaToOneEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldType "flags" VkPipelineMultisampleStateCreateInfo Source # 
type FieldType "minSampleShading" VkPipelineMultisampleStateCreateInfo Source # 
type FieldType "pNext" VkPipelineMultisampleStateCreateInfo Source # 
type FieldType "pSampleMask" VkPipelineMultisampleStateCreateInfo Source # 
type FieldType "rasterizationSamples" VkPipelineMultisampleStateCreateInfo Source # 
type FieldType "sType" VkPipelineMultisampleStateCreateInfo Source # 
type FieldType "sampleShadingEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOptional "alphaToCoverageEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOptional "alphaToOneEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOptional "flags" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOptional "minSampleShading" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOptional "pNext" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOptional "pSampleMask" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOptional "rasterizationSamples" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOptional "sType" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOptional "sampleShadingEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOffset "alphaToCoverageEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOffset "alphaToCoverageEnable" VkPipelineMultisampleStateCreateInfo = 40
type FieldOffset "alphaToOneEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOffset "flags" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOffset "minSampleShading" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOffset "pNext" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOffset "pSampleMask" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOffset "rasterizationSamples" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOffset "rasterizationSamples" VkPipelineMultisampleStateCreateInfo = 20
type FieldOffset "sType" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOffset "sampleShadingEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldOffset "sampleShadingEnable" VkPipelineMultisampleStateCreateInfo = 24
type FieldIsArray "alphaToCoverageEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldIsArray "alphaToOneEnable" VkPipelineMultisampleStateCreateInfo Source # 
type FieldIsArray "flags" VkPipelineMultisampleStateCreateInfo Source # 
type FieldIsArray "minSampleShading" VkPipelineMultisampleStateCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineMultisampleStateCreateInfo Source # 
type FieldIsArray "pSampleMask" VkPipelineMultisampleStateCreateInfo Source # 
type FieldIsArray "rasterizationSamples" VkPipelineMultisampleStateCreateInfo Source # 
type FieldIsArray "sType" VkPipelineMultisampleStateCreateInfo Source # 
type FieldIsArray "sampleShadingEnable" VkPipelineMultisampleStateCreateInfo Source # 

data VkPipelineRasterizationConservativeStateCreateInfoEXT Source #

typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
    VkStructureType sType;
    const void*                                                                      pNext;
    VkPipelineRasterizationConservativeStateCreateFlagsEXT           flags;
    VkConservativeRasterizationModeEXT                                               conservativeRasterizationMode;
    float                                                                            extraPrimitiveOverestimationSize;
} VkPipelineRasterizationConservativeStateCreateInfoEXT;

VkPipelineRasterizationConservativeStateCreateInfoEXT registry at www.khronos.org

Instances

Eq VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
Ord VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
Show VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
Storable VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
VulkanMarshalPrim VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
VulkanMarshal VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
CanWriteField "conservativeRasterizationMode" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
CanWriteField "extraPrimitiveOverestimationSize" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
CanWriteField "flags" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
CanWriteField "pNext" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
CanWriteField "sType" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
CanReadField "conservativeRasterizationMode" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
CanReadField "extraPrimitiveOverestimationSize" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
CanReadField "flags" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
CanReadField "pNext" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
CanReadField "sType" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
HasField "conservativeRasterizationMode" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
HasField "extraPrimitiveOverestimationSize" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 

Associated Types

type FieldType ("extraPrimitiveOverestimationSize" :: Symbol) VkPipelineRasterizationConservativeStateCreateInfoEXT :: Type Source #

type FieldOptional ("extraPrimitiveOverestimationSize" :: Symbol) VkPipelineRasterizationConservativeStateCreateInfoEXT :: Bool Source #

type FieldOffset ("extraPrimitiveOverestimationSize" :: Symbol) VkPipelineRasterizationConservativeStateCreateInfoEXT :: Nat Source #

type FieldIsArray ("extraPrimitiveOverestimationSize" :: Symbol) VkPipelineRasterizationConservativeStateCreateInfoEXT :: Bool Source #

HasField "flags" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
HasField "pNext" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
HasField "sType" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type StructFields VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type StructFields VkPipelineRasterizationConservativeStateCreateInfoEXT = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "conservativeRasterizationMode" ((:) Symbol "extraPrimitiveOverestimationSize" ([] Symbol)))))
type CUnionType VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type ReturnedOnly VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type StructExtends VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldType "conservativeRasterizationMode" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldType "extraPrimitiveOverestimationSize" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldType "flags" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldType "pNext" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldType "sType" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldOptional "conservativeRasterizationMode" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldOptional "extraPrimitiveOverestimationSize" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldOptional "flags" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldOptional "pNext" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldOptional "sType" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldOffset "conservativeRasterizationMode" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldOffset "conservativeRasterizationMode" VkPipelineRasterizationConservativeStateCreateInfoEXT = 20
type FieldOffset "extraPrimitiveOverestimationSize" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldOffset "extraPrimitiveOverestimationSize" VkPipelineRasterizationConservativeStateCreateInfoEXT = 24
type FieldOffset "flags" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldOffset "pNext" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldOffset "sType" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldIsArray "conservativeRasterizationMode" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldIsArray "extraPrimitiveOverestimationSize" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldIsArray "flags" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldIsArray "pNext" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 
type FieldIsArray "sType" VkPipelineRasterizationConservativeStateCreateInfoEXT Source # 

data VkPipelineRasterizationStateCreateInfo Source #

typedef struct VkPipelineRasterizationStateCreateInfo {
    VkStructureType sType;
    const void* pNext;
    VkPipelineRasterizationStateCreateFlags    flags;
    VkBool32               depthClampEnable;
    VkBool32               rasterizerDiscardEnable;
    VkPolygonMode          polygonMode;
    VkCullModeFlags        cullMode;
    VkFrontFace            frontFace;
    VkBool32               depthBiasEnable;
    float                  depthBiasConstantFactor;
    float                  depthBiasClamp;
    float                  depthBiasSlopeFactor;
    float                  lineWidth;
} VkPipelineRasterizationStateCreateInfo;

VkPipelineRasterizationStateCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineRasterizationStateCreateInfo Source # 
Ord VkPipelineRasterizationStateCreateInfo Source # 
Show VkPipelineRasterizationStateCreateInfo Source # 
Storable VkPipelineRasterizationStateCreateInfo Source # 
VulkanMarshalPrim VkPipelineRasterizationStateCreateInfo Source # 
VulkanMarshal VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "cullMode" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "depthBiasClamp" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "depthBiasConstantFactor" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "depthBiasEnable" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "depthBiasSlopeFactor" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "depthClampEnable" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "flags" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "frontFace" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "lineWidth" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "pNext" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "polygonMode" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "rasterizerDiscardEnable" VkPipelineRasterizationStateCreateInfo Source # 
CanWriteField "sType" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "cullMode" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "depthBiasClamp" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "depthBiasConstantFactor" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "depthBiasEnable" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "depthBiasSlopeFactor" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "depthClampEnable" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "flags" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "frontFace" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "lineWidth" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "pNext" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "polygonMode" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "rasterizerDiscardEnable" VkPipelineRasterizationStateCreateInfo Source # 
CanReadField "sType" VkPipelineRasterizationStateCreateInfo Source # 
HasField "cullMode" VkPipelineRasterizationStateCreateInfo Source # 
HasField "depthBiasClamp" VkPipelineRasterizationStateCreateInfo Source # 
HasField "depthBiasConstantFactor" VkPipelineRasterizationStateCreateInfo Source # 

Associated Types

type FieldType ("depthBiasConstantFactor" :: Symbol) VkPipelineRasterizationStateCreateInfo :: Type Source #

type FieldOptional ("depthBiasConstantFactor" :: Symbol) VkPipelineRasterizationStateCreateInfo :: Bool Source #

type FieldOffset ("depthBiasConstantFactor" :: Symbol) VkPipelineRasterizationStateCreateInfo :: Nat Source #

type FieldIsArray ("depthBiasConstantFactor" :: Symbol) VkPipelineRasterizationStateCreateInfo :: Bool Source #

HasField "depthBiasEnable" VkPipelineRasterizationStateCreateInfo Source # 
HasField "depthBiasSlopeFactor" VkPipelineRasterizationStateCreateInfo Source # 
HasField "depthClampEnable" VkPipelineRasterizationStateCreateInfo Source # 
HasField "flags" VkPipelineRasterizationStateCreateInfo Source # 
HasField "frontFace" VkPipelineRasterizationStateCreateInfo Source # 
HasField "lineWidth" VkPipelineRasterizationStateCreateInfo Source # 
HasField "pNext" VkPipelineRasterizationStateCreateInfo Source # 
HasField "polygonMode" VkPipelineRasterizationStateCreateInfo Source # 
HasField "rasterizerDiscardEnable" VkPipelineRasterizationStateCreateInfo Source # 

Associated Types

type FieldType ("rasterizerDiscardEnable" :: Symbol) VkPipelineRasterizationStateCreateInfo :: Type Source #

type FieldOptional ("rasterizerDiscardEnable" :: Symbol) VkPipelineRasterizationStateCreateInfo :: Bool Source #

type FieldOffset ("rasterizerDiscardEnable" :: Symbol) VkPipelineRasterizationStateCreateInfo :: Nat Source #

type FieldIsArray ("rasterizerDiscardEnable" :: Symbol) VkPipelineRasterizationStateCreateInfo :: Bool Source #

HasField "sType" VkPipelineRasterizationStateCreateInfo Source # 
type StructFields VkPipelineRasterizationStateCreateInfo Source # 
type StructFields VkPipelineRasterizationStateCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "depthClampEnable" ((:) Symbol "rasterizerDiscardEnable" ((:) Symbol "polygonMode" ((:) Symbol "cullMode" ((:) Symbol "frontFace" ((:) Symbol "depthBiasEnable" ((:) Symbol "depthBiasConstantFactor" ((:) Symbol "depthBiasClamp" ((:) Symbol "depthBiasSlopeFactor" ((:) Symbol "lineWidth" ([] Symbol)))))))))))))
type CUnionType VkPipelineRasterizationStateCreateInfo Source # 
type ReturnedOnly VkPipelineRasterizationStateCreateInfo Source # 
type StructExtends VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "cullMode" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "depthBiasClamp" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "depthBiasConstantFactor" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "depthBiasConstantFactor" VkPipelineRasterizationStateCreateInfo = Float
type FieldType "depthBiasEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "depthBiasSlopeFactor" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "depthClampEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "flags" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "frontFace" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "lineWidth" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "pNext" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "polygonMode" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "rasterizerDiscardEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldType "sType" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "cullMode" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "depthBiasClamp" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "depthBiasConstantFactor" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "depthBiasEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "depthBiasSlopeFactor" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "depthClampEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "flags" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "frontFace" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "lineWidth" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "pNext" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "polygonMode" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "rasterizerDiscardEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOptional "sType" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "cullMode" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "depthBiasClamp" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "depthBiasConstantFactor" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "depthBiasConstantFactor" VkPipelineRasterizationStateCreateInfo = 44
type FieldOffset "depthBiasEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "depthBiasSlopeFactor" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "depthBiasSlopeFactor" VkPipelineRasterizationStateCreateInfo = 52
type FieldOffset "depthClampEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "flags" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "frontFace" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "lineWidth" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "pNext" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "polygonMode" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "rasterizerDiscardEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldOffset "rasterizerDiscardEnable" VkPipelineRasterizationStateCreateInfo = 24
type FieldOffset "sType" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "cullMode" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "depthBiasClamp" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "depthBiasConstantFactor" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "depthBiasEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "depthBiasSlopeFactor" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "depthClampEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "flags" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "frontFace" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "lineWidth" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "polygonMode" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "rasterizerDiscardEnable" VkPipelineRasterizationStateCreateInfo Source # 
type FieldIsArray "sType" VkPipelineRasterizationStateCreateInfo Source # 

data VkPipelineRasterizationStateRasterizationOrderAMD Source #

typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
    VkStructureType sType;
    const void*                      pNext;
    VkRasterizationOrderAMD          rasterizationOrder;
} VkPipelineRasterizationStateRasterizationOrderAMD;

VkPipelineRasterizationStateRasterizationOrderAMD registry at www.khronos.org

Instances

Eq VkPipelineRasterizationStateRasterizationOrderAMD Source # 
Ord VkPipelineRasterizationStateRasterizationOrderAMD Source # 
Show VkPipelineRasterizationStateRasterizationOrderAMD Source # 
Storable VkPipelineRasterizationStateRasterizationOrderAMD Source # 
VulkanMarshalPrim VkPipelineRasterizationStateRasterizationOrderAMD Source # 
VulkanMarshal VkPipelineRasterizationStateRasterizationOrderAMD Source # 
CanWriteField "pNext" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
CanWriteField "rasterizationOrder" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
CanWriteField "sType" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
CanReadField "pNext" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
CanReadField "rasterizationOrder" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
CanReadField "sType" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
HasField "pNext" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
HasField "rasterizationOrder" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
HasField "sType" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type StructFields VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type StructFields VkPipelineRasterizationStateRasterizationOrderAMD = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "rasterizationOrder" ([] Symbol)))
type CUnionType VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type ReturnedOnly VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type StructExtends VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldType "pNext" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldType "rasterizationOrder" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldType "sType" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldOptional "pNext" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldOptional "rasterizationOrder" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldOptional "sType" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldOffset "pNext" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldOffset "rasterizationOrder" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldOffset "sType" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldIsArray "pNext" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldIsArray "rasterizationOrder" VkPipelineRasterizationStateRasterizationOrderAMD Source # 
type FieldIsArray "sType" VkPipelineRasterizationStateRasterizationOrderAMD Source # 

data VkPipelineSampleLocationsStateCreateInfoEXT Source #

typedef struct VkPipelineSampleLocationsStateCreateInfoEXT {
    VkStructureType sType;
    const void*                      pNext;
    VkBool32                         sampleLocationsEnable;
    VkSampleLocationsInfoEXT         sampleLocationsInfo;
} VkPipelineSampleLocationsStateCreateInfoEXT;

VkPipelineSampleLocationsStateCreateInfoEXT registry at www.khronos.org

Instances

Eq VkPipelineSampleLocationsStateCreateInfoEXT Source # 
Ord VkPipelineSampleLocationsStateCreateInfoEXT Source # 
Show VkPipelineSampleLocationsStateCreateInfoEXT Source # 
Storable VkPipelineSampleLocationsStateCreateInfoEXT Source # 
VulkanMarshalPrim VkPipelineSampleLocationsStateCreateInfoEXT Source # 
VulkanMarshal VkPipelineSampleLocationsStateCreateInfoEXT Source # 
CanWriteField "pNext" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
CanWriteField "sType" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
CanWriteField "sampleLocationsEnable" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
CanWriteField "sampleLocationsInfo" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
CanReadField "pNext" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
CanReadField "sType" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
CanReadField "sampleLocationsEnable" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
CanReadField "sampleLocationsInfo" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
HasField "pNext" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
HasField "sType" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
HasField "sampleLocationsEnable" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
HasField "sampleLocationsInfo" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type StructFields VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type StructFields VkPipelineSampleLocationsStateCreateInfoEXT = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "sampleLocationsEnable" ((:) Symbol "sampleLocationsInfo" ([] Symbol))))
type CUnionType VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type ReturnedOnly VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type StructExtends VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldType "pNext" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldType "sType" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldType "sampleLocationsEnable" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldType "sampleLocationsInfo" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldOptional "pNext" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldOptional "sType" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldOptional "sampleLocationsEnable" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldOptional "sampleLocationsInfo" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldOffset "pNext" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldOffset "sType" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldOffset "sampleLocationsEnable" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldOffset "sampleLocationsInfo" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldIsArray "pNext" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldIsArray "sType" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldIsArray "sampleLocationsEnable" VkPipelineSampleLocationsStateCreateInfoEXT Source # 
type FieldIsArray "sampleLocationsInfo" VkPipelineSampleLocationsStateCreateInfoEXT Source # 

data VkPipelineShaderStageCreateInfo Source #

typedef struct VkPipelineShaderStageCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineShaderStageCreateFlags    flags;
    VkShaderStageFlagBits  stage;
    VkShaderModule         module;
    const char*            pName;
    const VkSpecializationInfo* pSpecializationInfo;
} VkPipelineShaderStageCreateInfo;

VkPipelineShaderStageCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineShaderStageCreateInfo Source # 
Ord VkPipelineShaderStageCreateInfo Source # 
Show VkPipelineShaderStageCreateInfo Source # 
Storable VkPipelineShaderStageCreateInfo Source # 
VulkanMarshalPrim VkPipelineShaderStageCreateInfo Source # 
VulkanMarshal VkPipelineShaderStageCreateInfo Source # 
CanWriteField "flags" VkPipelineShaderStageCreateInfo Source # 
CanWriteField "module" VkPipelineShaderStageCreateInfo Source # 
CanWriteField "pName" VkPipelineShaderStageCreateInfo Source # 
CanWriteField "pNext" VkPipelineShaderStageCreateInfo Source # 
CanWriteField "pSpecializationInfo" VkPipelineShaderStageCreateInfo Source # 
CanWriteField "sType" VkPipelineShaderStageCreateInfo Source # 
CanWriteField "stage" VkPipelineShaderStageCreateInfo Source # 
CanReadField "flags" VkPipelineShaderStageCreateInfo Source # 
CanReadField "module" VkPipelineShaderStageCreateInfo Source # 
CanReadField "pName" VkPipelineShaderStageCreateInfo Source # 
CanReadField "pNext" VkPipelineShaderStageCreateInfo Source # 
CanReadField "pSpecializationInfo" VkPipelineShaderStageCreateInfo Source # 
CanReadField "sType" VkPipelineShaderStageCreateInfo Source # 
CanReadField "stage" VkPipelineShaderStageCreateInfo Source # 
HasField "flags" VkPipelineShaderStageCreateInfo Source # 
HasField "module" VkPipelineShaderStageCreateInfo Source # 
HasField "pName" VkPipelineShaderStageCreateInfo Source # 
HasField "pNext" VkPipelineShaderStageCreateInfo Source # 
HasField "pSpecializationInfo" VkPipelineShaderStageCreateInfo Source # 

Associated Types

type FieldType ("pSpecializationInfo" :: Symbol) VkPipelineShaderStageCreateInfo :: Type Source #

type FieldOptional ("pSpecializationInfo" :: Symbol) VkPipelineShaderStageCreateInfo :: Bool Source #

type FieldOffset ("pSpecializationInfo" :: Symbol) VkPipelineShaderStageCreateInfo :: Nat Source #

type FieldIsArray ("pSpecializationInfo" :: Symbol) VkPipelineShaderStageCreateInfo :: Bool Source #

HasField "sType" VkPipelineShaderStageCreateInfo Source # 
HasField "stage" VkPipelineShaderStageCreateInfo Source # 
type StructFields VkPipelineShaderStageCreateInfo Source # 
type StructFields VkPipelineShaderStageCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "stage" ((:) Symbol "module" ((:) Symbol "pName" ((:) Symbol "pSpecializationInfo" ([] Symbol)))))))
type CUnionType VkPipelineShaderStageCreateInfo Source # 
type ReturnedOnly VkPipelineShaderStageCreateInfo Source # 
type StructExtends VkPipelineShaderStageCreateInfo Source # 
type FieldType "flags" VkPipelineShaderStageCreateInfo Source # 
type FieldType "module" VkPipelineShaderStageCreateInfo Source # 
type FieldType "pName" VkPipelineShaderStageCreateInfo Source # 
type FieldType "pNext" VkPipelineShaderStageCreateInfo Source # 
type FieldType "pSpecializationInfo" VkPipelineShaderStageCreateInfo Source # 
type FieldType "sType" VkPipelineShaderStageCreateInfo Source # 
type FieldType "stage" VkPipelineShaderStageCreateInfo Source # 
type FieldOptional "flags" VkPipelineShaderStageCreateInfo Source # 
type FieldOptional "module" VkPipelineShaderStageCreateInfo Source # 
type FieldOptional "pName" VkPipelineShaderStageCreateInfo Source # 
type FieldOptional "pNext" VkPipelineShaderStageCreateInfo Source # 
type FieldOptional "pSpecializationInfo" VkPipelineShaderStageCreateInfo Source # 
type FieldOptional "sType" VkPipelineShaderStageCreateInfo Source # 
type FieldOptional "stage" VkPipelineShaderStageCreateInfo Source # 
type FieldOffset "flags" VkPipelineShaderStageCreateInfo Source # 
type FieldOffset "module" VkPipelineShaderStageCreateInfo Source # 
type FieldOffset "pName" VkPipelineShaderStageCreateInfo Source # 
type FieldOffset "pNext" VkPipelineShaderStageCreateInfo Source # 
type FieldOffset "pSpecializationInfo" VkPipelineShaderStageCreateInfo Source # 
type FieldOffset "pSpecializationInfo" VkPipelineShaderStageCreateInfo = 40
type FieldOffset "sType" VkPipelineShaderStageCreateInfo Source # 
type FieldOffset "stage" VkPipelineShaderStageCreateInfo Source # 
type FieldIsArray "flags" VkPipelineShaderStageCreateInfo Source # 
type FieldIsArray "module" VkPipelineShaderStageCreateInfo Source # 
type FieldIsArray "pName" VkPipelineShaderStageCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineShaderStageCreateInfo Source # 
type FieldIsArray "pSpecializationInfo" VkPipelineShaderStageCreateInfo Source # 
type FieldIsArray "sType" VkPipelineShaderStageCreateInfo Source # 
type FieldIsArray "stage" VkPipelineShaderStageCreateInfo Source # 

data VkPipelineTessellationDomainOriginStateCreateInfo Source #

typedef struct VkPipelineTessellationDomainOriginStateCreateInfo {
    VkStructureType sType;
    const void*                      pNext;
    VkTessellationDomainOrigin    domainOrigin;
} VkPipelineTessellationDomainOriginStateCreateInfo;

VkPipelineTessellationDomainOriginStateCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineTessellationDomainOriginStateCreateInfo Source # 
Ord VkPipelineTessellationDomainOriginStateCreateInfo Source # 
Show VkPipelineTessellationDomainOriginStateCreateInfo Source # 
Storable VkPipelineTessellationDomainOriginStateCreateInfo Source # 
VulkanMarshalPrim VkPipelineTessellationDomainOriginStateCreateInfo Source # 
VulkanMarshal VkPipelineTessellationDomainOriginStateCreateInfo Source # 
CanWriteField "domainOrigin" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
CanWriteField "pNext" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
CanWriteField "sType" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
CanReadField "domainOrigin" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
CanReadField "pNext" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
CanReadField "sType" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
HasField "domainOrigin" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
HasField "pNext" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
HasField "sType" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type StructFields VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type StructFields VkPipelineTessellationDomainOriginStateCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "domainOrigin" ([] Symbol)))
type CUnionType VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type ReturnedOnly VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type StructExtends VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldType "domainOrigin" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldType "pNext" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldType "sType" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldOptional "domainOrigin" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldOptional "pNext" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldOptional "sType" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldOffset "domainOrigin" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldOffset "pNext" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldOffset "sType" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldIsArray "domainOrigin" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineTessellationDomainOriginStateCreateInfo Source # 
type FieldIsArray "sType" VkPipelineTessellationDomainOriginStateCreateInfo Source # 

data VkPipelineTessellationStateCreateInfo Source #

typedef struct VkPipelineTessellationStateCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineTessellationStateCreateFlags    flags;
    uint32_t               patchControlPoints;
} VkPipelineTessellationStateCreateInfo;

VkPipelineTessellationStateCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineTessellationStateCreateInfo Source # 
Ord VkPipelineTessellationStateCreateInfo Source # 
Show VkPipelineTessellationStateCreateInfo Source # 
Storable VkPipelineTessellationStateCreateInfo Source # 
VulkanMarshalPrim VkPipelineTessellationStateCreateInfo Source # 
VulkanMarshal VkPipelineTessellationStateCreateInfo Source # 
CanWriteField "flags" VkPipelineTessellationStateCreateInfo Source # 
CanWriteField "pNext" VkPipelineTessellationStateCreateInfo Source # 
CanWriteField "patchControlPoints" VkPipelineTessellationStateCreateInfo Source # 
CanWriteField "sType" VkPipelineTessellationStateCreateInfo Source # 
CanReadField "flags" VkPipelineTessellationStateCreateInfo Source # 
CanReadField "pNext" VkPipelineTessellationStateCreateInfo Source # 
CanReadField "patchControlPoints" VkPipelineTessellationStateCreateInfo Source # 
CanReadField "sType" VkPipelineTessellationStateCreateInfo Source # 
HasField "flags" VkPipelineTessellationStateCreateInfo Source # 
HasField "pNext" VkPipelineTessellationStateCreateInfo Source # 
HasField "patchControlPoints" VkPipelineTessellationStateCreateInfo Source # 
HasField "sType" VkPipelineTessellationStateCreateInfo Source # 
type StructFields VkPipelineTessellationStateCreateInfo Source # 
type StructFields VkPipelineTessellationStateCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "patchControlPoints" ([] Symbol))))
type CUnionType VkPipelineTessellationStateCreateInfo Source # 
type ReturnedOnly VkPipelineTessellationStateCreateInfo Source # 
type StructExtends VkPipelineTessellationStateCreateInfo Source # 
type FieldType "flags" VkPipelineTessellationStateCreateInfo Source # 
type FieldType "pNext" VkPipelineTessellationStateCreateInfo Source # 
type FieldType "patchControlPoints" VkPipelineTessellationStateCreateInfo Source # 
type FieldType "sType" VkPipelineTessellationStateCreateInfo Source # 
type FieldOptional "flags" VkPipelineTessellationStateCreateInfo Source # 
type FieldOptional "pNext" VkPipelineTessellationStateCreateInfo Source # 
type FieldOptional "patchControlPoints" VkPipelineTessellationStateCreateInfo Source # 
type FieldOptional "sType" VkPipelineTessellationStateCreateInfo Source # 
type FieldOffset "flags" VkPipelineTessellationStateCreateInfo Source # 
type FieldOffset "pNext" VkPipelineTessellationStateCreateInfo Source # 
type FieldOffset "patchControlPoints" VkPipelineTessellationStateCreateInfo Source # 
type FieldOffset "patchControlPoints" VkPipelineTessellationStateCreateInfo = 20
type FieldOffset "sType" VkPipelineTessellationStateCreateInfo Source # 
type FieldIsArray "flags" VkPipelineTessellationStateCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineTessellationStateCreateInfo Source # 
type FieldIsArray "patchControlPoints" VkPipelineTessellationStateCreateInfo Source # 
type FieldIsArray "sType" VkPipelineTessellationStateCreateInfo Source # 

data VkPipelineVertexInputDivisorStateCreateInfoEXT Source #

typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT {
    VkStructureType sType;
    const void*                         pNext;
    uint32_t                            vertexBindingDivisorCount;
    const VkVertexInputBindingDivisorDescriptionEXT*      pVertexBindingDivisors;
} VkPipelineVertexInputDivisorStateCreateInfoEXT;

VkPipelineVertexInputDivisorStateCreateInfoEXT registry at www.khronos.org

Instances

Eq VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
Ord VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
Show VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
Storable VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
VulkanMarshalPrim VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
VulkanMarshal VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
CanWriteField "pNext" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
CanWriteField "pVertexBindingDivisors" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
CanWriteField "sType" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
CanWriteField "vertexBindingDivisorCount" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
CanReadField "pNext" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
CanReadField "pVertexBindingDivisors" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
CanReadField "sType" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
CanReadField "vertexBindingDivisorCount" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
HasField "pNext" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
HasField "pVertexBindingDivisors" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
HasField "sType" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
HasField "vertexBindingDivisorCount" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type StructFields VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type StructFields VkPipelineVertexInputDivisorStateCreateInfoEXT = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "vertexBindingDivisorCount" ((:) Symbol "pVertexBindingDivisors" ([] Symbol))))
type CUnionType VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type ReturnedOnly VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type StructExtends VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldType "pNext" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldType "pVertexBindingDivisors" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldType "sType" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldType "vertexBindingDivisorCount" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldOptional "pNext" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldOptional "pVertexBindingDivisors" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldOptional "sType" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldOptional "vertexBindingDivisorCount" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldOffset "pNext" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldOffset "pVertexBindingDivisors" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldOffset "sType" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldOffset "vertexBindingDivisorCount" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldOffset "vertexBindingDivisorCount" VkPipelineVertexInputDivisorStateCreateInfoEXT = 16
type FieldIsArray "pNext" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldIsArray "pVertexBindingDivisors" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldIsArray "sType" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 
type FieldIsArray "vertexBindingDivisorCount" VkPipelineVertexInputDivisorStateCreateInfoEXT Source # 

data VkPipelineVertexInputStateCreateInfo Source #

typedef struct VkPipelineVertexInputStateCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineVertexInputStateCreateFlags    flags;
    uint32_t               vertexBindingDescriptionCount;
    const VkVertexInputBindingDescription* pVertexBindingDescriptions;
    uint32_t               vertexAttributeDescriptionCount;
    const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
} VkPipelineVertexInputStateCreateInfo;

VkPipelineVertexInputStateCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineVertexInputStateCreateInfo Source # 
Ord VkPipelineVertexInputStateCreateInfo Source # 
Show VkPipelineVertexInputStateCreateInfo Source # 
Storable VkPipelineVertexInputStateCreateInfo Source # 
VulkanMarshalPrim VkPipelineVertexInputStateCreateInfo Source # 
VulkanMarshal VkPipelineVertexInputStateCreateInfo Source # 
CanWriteField "flags" VkPipelineVertexInputStateCreateInfo Source # 
CanWriteField "pNext" VkPipelineVertexInputStateCreateInfo Source # 
CanWriteField "pVertexAttributeDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
CanWriteField "pVertexBindingDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
CanWriteField "sType" VkPipelineVertexInputStateCreateInfo Source # 
CanWriteField "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
CanWriteField "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
CanReadField "flags" VkPipelineVertexInputStateCreateInfo Source # 
CanReadField "pNext" VkPipelineVertexInputStateCreateInfo Source # 
CanReadField "pVertexAttributeDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
CanReadField "pVertexBindingDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
CanReadField "sType" VkPipelineVertexInputStateCreateInfo Source # 
CanReadField "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
CanReadField "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
HasField "flags" VkPipelineVertexInputStateCreateInfo Source # 
HasField "pNext" VkPipelineVertexInputStateCreateInfo Source # 
HasField "pVertexAttributeDescriptions" VkPipelineVertexInputStateCreateInfo Source # 

Associated Types

type FieldType ("pVertexAttributeDescriptions" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Type Source #

type FieldOptional ("pVertexAttributeDescriptions" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Bool Source #

type FieldOffset ("pVertexAttributeDescriptions" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Nat Source #

type FieldIsArray ("pVertexAttributeDescriptions" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Bool Source #

HasField "pVertexBindingDescriptions" VkPipelineVertexInputStateCreateInfo Source # 

Associated Types

type FieldType ("pVertexBindingDescriptions" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Type Source #

type FieldOptional ("pVertexBindingDescriptions" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Bool Source #

type FieldOffset ("pVertexBindingDescriptions" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Nat Source #

type FieldIsArray ("pVertexBindingDescriptions" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Bool Source #

HasField "sType" VkPipelineVertexInputStateCreateInfo Source # 
HasField "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 

Associated Types

type FieldType ("vertexAttributeDescriptionCount" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Type Source #

type FieldOptional ("vertexAttributeDescriptionCount" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Bool Source #

type FieldOffset ("vertexAttributeDescriptionCount" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Nat Source #

type FieldIsArray ("vertexAttributeDescriptionCount" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Bool Source #

HasField "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 

Associated Types

type FieldType ("vertexBindingDescriptionCount" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Type Source #

type FieldOptional ("vertexBindingDescriptionCount" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Bool Source #

type FieldOffset ("vertexBindingDescriptionCount" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Nat Source #

type FieldIsArray ("vertexBindingDescriptionCount" :: Symbol) VkPipelineVertexInputStateCreateInfo :: Bool Source #

type StructFields VkPipelineVertexInputStateCreateInfo Source # 
type StructFields VkPipelineVertexInputStateCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "vertexBindingDescriptionCount" ((:) Symbol "pVertexBindingDescriptions" ((:) Symbol "vertexAttributeDescriptionCount" ((:) Symbol "pVertexAttributeDescriptions" ([] Symbol)))))))
type CUnionType VkPipelineVertexInputStateCreateInfo Source # 
type ReturnedOnly VkPipelineVertexInputStateCreateInfo Source # 
type StructExtends VkPipelineVertexInputStateCreateInfo Source # 
type FieldType "flags" VkPipelineVertexInputStateCreateInfo Source # 
type FieldType "pNext" VkPipelineVertexInputStateCreateInfo Source # 
type FieldType "pVertexAttributeDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
type FieldType "pVertexBindingDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
type FieldType "sType" VkPipelineVertexInputStateCreateInfo Source # 
type FieldType "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
type FieldType "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo = Word32
type FieldType "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
type FieldType "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo = Word32
type FieldOptional "flags" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOptional "pNext" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOptional "pVertexAttributeDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOptional "pVertexAttributeDescriptions" VkPipelineVertexInputStateCreateInfo = False
type FieldOptional "pVertexBindingDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOptional "pVertexBindingDescriptions" VkPipelineVertexInputStateCreateInfo = False
type FieldOptional "sType" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOptional "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOptional "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo = True
type FieldOptional "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOptional "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo = True
type FieldOffset "flags" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOffset "pNext" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOffset "pVertexAttributeDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOffset "pVertexAttributeDescriptions" VkPipelineVertexInputStateCreateInfo = 40
type FieldOffset "pVertexBindingDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOffset "pVertexBindingDescriptions" VkPipelineVertexInputStateCreateInfo = 24
type FieldOffset "sType" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOffset "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOffset "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo = 32
type FieldOffset "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
type FieldOffset "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo = 20
type FieldIsArray "flags" VkPipelineVertexInputStateCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineVertexInputStateCreateInfo Source # 
type FieldIsArray "pVertexAttributeDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
type FieldIsArray "pVertexAttributeDescriptions" VkPipelineVertexInputStateCreateInfo = False
type FieldIsArray "pVertexBindingDescriptions" VkPipelineVertexInputStateCreateInfo Source # 
type FieldIsArray "pVertexBindingDescriptions" VkPipelineVertexInputStateCreateInfo = False
type FieldIsArray "sType" VkPipelineVertexInputStateCreateInfo Source # 
type FieldIsArray "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
type FieldIsArray "vertexAttributeDescriptionCount" VkPipelineVertexInputStateCreateInfo = False
type FieldIsArray "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo Source # 
type FieldIsArray "vertexBindingDescriptionCount" VkPipelineVertexInputStateCreateInfo = False

data VkPipelineViewportStateCreateInfo Source #

typedef struct VkPipelineViewportStateCreateInfo {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineViewportStateCreateFlags    flags;
    uint32_t               viewportCount;
    const VkViewport*      pViewports;
    uint32_t               scissorCount;
    const VkRect2D*        pScissors;
} VkPipelineViewportStateCreateInfo;

VkPipelineViewportStateCreateInfo registry at www.khronos.org

Instances

Eq VkPipelineViewportStateCreateInfo Source # 
Ord VkPipelineViewportStateCreateInfo Source # 
Show VkPipelineViewportStateCreateInfo Source # 
Storable VkPipelineViewportStateCreateInfo Source # 
VulkanMarshalPrim VkPipelineViewportStateCreateInfo Source # 
VulkanMarshal VkPipelineViewportStateCreateInfo Source # 
CanWriteField "flags" VkPipelineViewportStateCreateInfo Source # 
CanWriteField "pNext" VkPipelineViewportStateCreateInfo Source # 
CanWriteField "pScissors" VkPipelineViewportStateCreateInfo Source # 
CanWriteField "pViewports" VkPipelineViewportStateCreateInfo Source # 
CanWriteField "sType" VkPipelineViewportStateCreateInfo Source # 
CanWriteField "scissorCount" VkPipelineViewportStateCreateInfo Source # 
CanWriteField "viewportCount" VkPipelineViewportStateCreateInfo Source # 
CanReadField "flags" VkPipelineViewportStateCreateInfo Source # 
CanReadField "pNext" VkPipelineViewportStateCreateInfo Source # 
CanReadField "pScissors" VkPipelineViewportStateCreateInfo Source # 
CanReadField "pViewports" VkPipelineViewportStateCreateInfo Source # 
CanReadField "sType" VkPipelineViewportStateCreateInfo Source # 
CanReadField "scissorCount" VkPipelineViewportStateCreateInfo Source # 
CanReadField "viewportCount" VkPipelineViewportStateCreateInfo Source # 
HasField "flags" VkPipelineViewportStateCreateInfo Source # 
HasField "pNext" VkPipelineViewportStateCreateInfo Source # 
HasField "pScissors" VkPipelineViewportStateCreateInfo Source # 
HasField "pViewports" VkPipelineViewportStateCreateInfo Source # 
HasField "sType" VkPipelineViewportStateCreateInfo Source # 
HasField "scissorCount" VkPipelineViewportStateCreateInfo Source # 
HasField "viewportCount" VkPipelineViewportStateCreateInfo Source # 
type StructFields VkPipelineViewportStateCreateInfo Source # 
type StructFields VkPipelineViewportStateCreateInfo = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "viewportCount" ((:) Symbol "pViewports" ((:) Symbol "scissorCount" ((:) Symbol "pScissors" ([] Symbol)))))))
type CUnionType VkPipelineViewportStateCreateInfo Source # 
type ReturnedOnly VkPipelineViewportStateCreateInfo Source # 
type StructExtends VkPipelineViewportStateCreateInfo Source # 
type FieldType "flags" VkPipelineViewportStateCreateInfo Source # 
type FieldType "pNext" VkPipelineViewportStateCreateInfo Source # 
type FieldType "pScissors" VkPipelineViewportStateCreateInfo Source # 
type FieldType "pViewports" VkPipelineViewportStateCreateInfo Source # 
type FieldType "sType" VkPipelineViewportStateCreateInfo Source # 
type FieldType "scissorCount" VkPipelineViewportStateCreateInfo Source # 
type FieldType "viewportCount" VkPipelineViewportStateCreateInfo Source # 
type FieldOptional "flags" VkPipelineViewportStateCreateInfo Source # 
type FieldOptional "pNext" VkPipelineViewportStateCreateInfo Source # 
type FieldOptional "pScissors" VkPipelineViewportStateCreateInfo Source # 
type FieldOptional "pViewports" VkPipelineViewportStateCreateInfo Source # 
type FieldOptional "sType" VkPipelineViewportStateCreateInfo Source # 
type FieldOptional "scissorCount" VkPipelineViewportStateCreateInfo Source # 
type FieldOptional "viewportCount" VkPipelineViewportStateCreateInfo Source # 
type FieldOffset "flags" VkPipelineViewportStateCreateInfo Source # 
type FieldOffset "pNext" VkPipelineViewportStateCreateInfo Source # 
type FieldOffset "pScissors" VkPipelineViewportStateCreateInfo Source # 
type FieldOffset "pViewports" VkPipelineViewportStateCreateInfo Source # 
type FieldOffset "sType" VkPipelineViewportStateCreateInfo Source # 
type FieldOffset "scissorCount" VkPipelineViewportStateCreateInfo Source # 
type FieldOffset "viewportCount" VkPipelineViewportStateCreateInfo Source # 
type FieldIsArray "flags" VkPipelineViewportStateCreateInfo Source # 
type FieldIsArray "pNext" VkPipelineViewportStateCreateInfo Source # 
type FieldIsArray "pScissors" VkPipelineViewportStateCreateInfo Source # 
type FieldIsArray "pViewports" VkPipelineViewportStateCreateInfo Source # 
type FieldIsArray "sType" VkPipelineViewportStateCreateInfo Source # 
type FieldIsArray "scissorCount" VkPipelineViewportStateCreateInfo Source # 
type FieldIsArray "viewportCount" VkPipelineViewportStateCreateInfo Source # 

data VkPipelineViewportSwizzleStateCreateInfoNV Source #

typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
    VkStructureType sType;
    const void*            pNext;
    VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
    uint32_t               viewportCount;
    const VkViewportSwizzleNV*      pViewportSwizzles;
} VkPipelineViewportSwizzleStateCreateInfoNV;

VkPipelineViewportSwizzleStateCreateInfoNV registry at www.khronos.org

Instances

Eq VkPipelineViewportSwizzleStateCreateInfoNV Source # 
Ord VkPipelineViewportSwizzleStateCreateInfoNV Source # 
Show VkPipelineViewportSwizzleStateCreateInfoNV Source # 
Storable VkPipelineViewportSwizzleStateCreateInfoNV Source # 
VulkanMarshalPrim VkPipelineViewportSwizzleStateCreateInfoNV Source # 
VulkanMarshal VkPipelineViewportSwizzleStateCreateInfoNV Source # 
CanWriteField "flags" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
CanWriteField "pNext" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
CanWriteField "pViewportSwizzles" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
CanWriteField "sType" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
CanWriteField "viewportCount" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
CanReadField "flags" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
CanReadField "pNext" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
CanReadField "pViewportSwizzles" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
CanReadField "sType" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
CanReadField "viewportCount" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
HasField "flags" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
HasField "pNext" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
HasField "pViewportSwizzles" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
HasField "sType" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
HasField "viewportCount" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type StructFields VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type StructFields VkPipelineViewportSwizzleStateCreateInfoNV = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "flags" ((:) Symbol "viewportCount" ((:) Symbol "pViewportSwizzles" ([] Symbol)))))
type CUnionType VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type ReturnedOnly VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type StructExtends VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldType "flags" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldType "pNext" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldType "pViewportSwizzles" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldType "sType" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldType "viewportCount" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldOptional "flags" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldOptional "pNext" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldOptional "pViewportSwizzles" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldOptional "sType" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldOptional "viewportCount" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldOffset "flags" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldOffset "pNext" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldOffset "pViewportSwizzles" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldOffset "sType" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldOffset "viewportCount" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldIsArray "flags" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldIsArray "pNext" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldIsArray "pViewportSwizzles" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldIsArray "sType" VkPipelineViewportSwizzleStateCreateInfoNV Source # 
type FieldIsArray "viewportCount" VkPipelineViewportSwizzleStateCreateInfoNV Source # 

data VkPipelineViewportWScalingStateCreateInfoNV Source #

typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
    VkStructureType sType;
    const void*                      pNext;
    VkBool32               viewportWScalingEnable;
    uint32_t               viewportCount;
    const VkViewportWScalingNV*      pViewportWScalings;
} VkPipelineViewportWScalingStateCreateInfoNV;

VkPipelineViewportWScalingStateCreateInfoNV registry at www.khronos.org

Instances

Eq VkPipelineViewportWScalingStateCreateInfoNV Source # 
Ord VkPipelineViewportWScalingStateCreateInfoNV Source # 
Show VkPipelineViewportWScalingStateCreateInfoNV Source # 
Storable VkPipelineViewportWScalingStateCreateInfoNV Source # 
VulkanMarshalPrim VkPipelineViewportWScalingStateCreateInfoNV Source # 
VulkanMarshal VkPipelineViewportWScalingStateCreateInfoNV Source # 
CanWriteField "pNext" VkPipelineViewportWScalingStateCreateInfoNV Source # 
CanWriteField "pViewportWScalings" VkPipelineViewportWScalingStateCreateInfoNV Source # 
CanWriteField "sType" VkPipelineViewportWScalingStateCreateInfoNV Source # 
CanWriteField "viewportCount" VkPipelineViewportWScalingStateCreateInfoNV Source # 
CanWriteField "viewportWScalingEnable" VkPipelineViewportWScalingStateCreateInfoNV Source # 
CanReadField "pNext" VkPipelineViewportWScalingStateCreateInfoNV Source # 
CanReadField "pViewportWScalings" VkPipelineViewportWScalingStateCreateInfoNV Source # 
CanReadField "sType" VkPipelineViewportWScalingStateCreateInfoNV Source # 
CanReadField "viewportCount" VkPipelineViewportWScalingStateCreateInfoNV Source # 
CanReadField "viewportWScalingEnable" VkPipelineViewportWScalingStateCreateInfoNV Source # 
HasField "pNext" VkPipelineViewportWScalingStateCreateInfoNV Source # 
HasField "pViewportWScalings" VkPipelineViewportWScalingStateCreateInfoNV Source # 
HasField "sType" VkPipelineViewportWScalingStateCreateInfoNV Source # 
HasField "viewportCount" VkPipelineViewportWScalingStateCreateInfoNV Source # 
HasField "viewportWScalingEnable" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type StructFields VkPipelineViewportWScalingStateCreateInfoNV Source # 
type StructFields VkPipelineViewportWScalingStateCreateInfoNV = (:) Symbol "sType" ((:) Symbol "pNext" ((:) Symbol "viewportWScalingEnable" ((:) Symbol "viewportCount" ((:) Symbol "pViewportWScalings" ([] Symbol)))))
type CUnionType VkPipelineViewportWScalingStateCreateInfoNV Source # 
type ReturnedOnly VkPipelineViewportWScalingStateCreateInfoNV Source # 
type StructExtends VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldType "pNext" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldType "pViewportWScalings" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldType "sType" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldType "viewportCount" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldType "viewportWScalingEnable" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOptional "pNext" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOptional "pViewportWScalings" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOptional "sType" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOptional "viewportCount" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOptional "viewportWScalingEnable" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOffset "pNext" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOffset "pViewportWScalings" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOffset "sType" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOffset "viewportCount" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOffset "viewportWScalingEnable" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldOffset "viewportWScalingEnable" VkPipelineViewportWScalingStateCreateInfoNV = 16
type FieldIsArray "pNext" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldIsArray "pViewportWScalings" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldIsArray "sType" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldIsArray "viewportCount" VkPipelineViewportWScalingStateCreateInfoNV Source # 
type FieldIsArray "viewportWScalingEnable" VkPipelineViewportWScalingStateCreateInfoNV Source # 

newtype VkSampleCountBitmask a Source #

Instances

Bounded (VkSampleCountBitmask FlagMask) Source # 
Enum (VkSampleCountBitmask FlagMask) Source # 
Eq (VkSampleCountBitmask a) Source # 
Integral (VkSampleCountBitmask FlagMask) Source # 
Typeable FlagType a => Data (VkSampleCountBitmask a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkSampleCountBitmask a -> c (VkSampleCountBitmask a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (VkSampleCountBitmask a) #

toConstr :: VkSampleCountBitmask a -> Constr #

dataTypeOf :: VkSampleCountBitmask a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (VkSampleCountBitmask a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (VkSampleCountBitmask a)) #

gmapT :: (forall b. Data b => b -> b) -> VkSampleCountBitmask a -> VkSampleCountBitmask a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkSampleCountBitmask a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkSampleCountBitmask a -> r #

gmapQ :: (forall d. Data d => d -> u) -> VkSampleCountBitmask a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> VkSampleCountBitmask a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkSampleCountBitmask a -> m (VkSampleCountBitmask a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkSampleCountBitmask a -> m (VkSampleCountBitmask a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkSampleCountBitmask a -> m (VkSampleCountBitmask a) #

Num (VkSampleCountBitmask FlagMask) Source # 
Ord (VkSampleCountBitmask a) Source # 
Read (VkSampleCountBitmask a) Source # 
Real (VkSampleCountBitmask FlagMask) Source # 
Show (VkSampleCountBitmask a) Source # 
Generic (VkSampleCountBitmask a) Source # 
Storable (VkSampleCountBitmask a) Source # 
Bits (VkSampleCountBitmask FlagMask) Source # 

Methods

(.&.) :: VkSampleCountBitmask FlagMask -> VkSampleCountBitmask FlagMask -> VkSampleCountBitmask FlagMask #

(.|.) :: VkSampleCountBitmask FlagMask -> VkSampleCountBitmask FlagMask -> VkSampleCountBitmask FlagMask #

xor :: VkSampleCountBitmask FlagMask -> VkSampleCountBitmask FlagMask -> VkSampleCountBitmask FlagMask #

complement :: VkSampleCountBitmask FlagMask -> VkSampleCountBitmask FlagMask #

shift :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

rotate :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

zeroBits :: VkSampleCountBitmask FlagMask #

bit :: Int -> VkSampleCountBitmask FlagMask #

setBit :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

clearBit :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

complementBit :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

testBit :: VkSampleCountBitmask FlagMask -> Int -> Bool #

bitSizeMaybe :: VkSampleCountBitmask FlagMask -> Maybe Int #

bitSize :: VkSampleCountBitmask FlagMask -> Int #

isSigned :: VkSampleCountBitmask FlagMask -> Bool #

shiftL :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

unsafeShiftL :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

shiftR :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

unsafeShiftR :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

rotateL :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

rotateR :: VkSampleCountBitmask FlagMask -> Int -> VkSampleCountBitmask FlagMask #

popCount :: VkSampleCountBitmask FlagMask -> Int #

FiniteBits (VkSampleCountBitmask FlagMask) Source # 
type Rep (VkSampleCountBitmask a) Source # 
type Rep (VkSampleCountBitmask a) = D1 (MetaData "VkSampleCountBitmask" "Graphics.Vulkan.Types.Enum.SampleCountFlags" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkSampleCountBitmask" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VkFlags)))

pattern VK_SAMPLE_COUNT_1_BIT :: forall a. VkSampleCountBitmask a Source #

Sample count 1 supported

bitpos = 0

pattern VK_SAMPLE_COUNT_2_BIT :: forall a. VkSampleCountBitmask a Source #

Sample count 2 supported

bitpos = 1

pattern VK_SAMPLE_COUNT_4_BIT :: forall a. VkSampleCountBitmask a Source #

Sample count 4 supported

bitpos = 2

pattern VK_SAMPLE_COUNT_8_BIT :: forall a. VkSampleCountBitmask a Source #

Sample count 8 supported

bitpos = 3

pattern VK_SAMPLE_COUNT_16_BIT :: forall a. VkSampleCountBitmask a Source #

Sample count 16 supported

bitpos = 4

pattern VK_SAMPLE_COUNT_32_BIT :: forall a. VkSampleCountBitmask a Source #

Sample count 32 supported

bitpos = 5

pattern VK_SAMPLE_COUNT_64_BIT :: forall a. VkSampleCountBitmask a Source #

Sample count 64 supported

bitpos = 6

newtype VkStructureType Source #

Structure type enumerant

type = enum

VkStructureType registry at www.khronos.org

Constructors

VkStructureType Int32 

Instances

Bounded VkStructureType Source # 
Enum VkStructureType Source # 
Eq VkStructureType Source # 
Data VkStructureType Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VkStructureType -> c VkStructureType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VkStructureType #

toConstr :: VkStructureType -> Constr #

dataTypeOf :: VkStructureType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c VkStructureType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VkStructureType) #

gmapT :: (forall b. Data b => b -> b) -> VkStructureType -> VkStructureType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VkStructureType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VkStructureType -> r #

gmapQ :: (forall d. Data d => d -> u) -> VkStructureType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> VkStructureType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VkStructureType -> m VkStructureType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VkStructureType -> m VkStructureType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VkStructureType -> m VkStructureType #

Num VkStructureType Source # 
Ord VkStructureType Source # 
Read VkStructureType Source # 
Show VkStructureType Source # 
Generic VkStructureType Source # 
Storable VkStructureType Source # 
type Rep VkStructureType Source # 
type Rep VkStructureType = D1 (MetaData "VkStructureType" "Graphics.Vulkan.Types.Enum.StructureType" "vulkan-api-1.1.3.0-FHhzd5k5VLu5phG4JhXQzZ" True) (C1 (MetaCons "VkStructureType" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int32)))

pattern VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO :: VkStructureType Source #

Reserved for internal use by the loader, layers, and ICDs

pattern VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO :: VkStructureType Source #

Reserved for internal use by the loader, layers, and ICDs

type VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME = "VK_NV_fragment_coverage_to_color" Source #